Встроенные типы

Побитовые операции над целыми типами

Побитовые операции имеют смысл только для целых чисел. Результат побитовых операций вычисляется так, как будто они выполняются в дополнении до двух с бесконечным количеством знаковых битов.

Приоритеты бинарных побитовых операций ниже приоритетов арифметических операций и выше приоритетов сравнений; унарная операция ~ имеет тот же приоритет, что и другие унарные арифметические операции (+ и -).

В этой таблице побитовые операции упорядочены по возрастанию приоритета:

Примечания:

1. Отрицательные сдвиги недопустимы и вызывают исключение ValueError.
2. Сдвиг влево на n битов эквивалентен умножению на pow(2, n).
3. Сдвиг вправо на n битов эквивалентен целочисленному делению с отбрасыванием дробной части (floor division) на pow(2, n).
4. Выполнение этих вычислений с хотя бы одним дополнительным знаковым битом расширения в конечном представлении с дополнением до двух (разрядность побитового представления 1 + max(x.bit_length(), y.bit_length()) или больше) достаточно, чтобы получить тот же результат, что и при бесконечном числе знаковых битов.

Дополнительные методы целых типов

Тип int реализует numbers.Integral абстрактный базовый класс. Кроме того, он предоставляет несколько дополнительных методов:

int.bit_length()

Возвращает количество битов, необходимых для представления целого числа в двоичном формате, исключая знак и ведущие нули:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Точнее, если x не равно нулю, то x.bit_length() — это единственное положительное целое число k такое, что 2**(k-1) <= abs(x) < 2**k. Аналогично, когда abs(x) достаточно мало, чтобы иметь правильно округленный логарифм, то k = 1 + int(log(abs(x), 2)). Если x равно нулю, то x.bit_length() возвращает 0.

Эквивалентно:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

Добавлено в версии 3.1.

int.to_bytes(length, byteorder, *, signed=False)

Возвращает массив байтов, представляющий целое число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

Целое число представляется с использованием length байтов. Если целое число не может быть представлено заданным количеством байтов, генерируется исключение OverflowError.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа. Если byteorder равен "big", самый старший байт находится в начале массива байтов. Если byteorder равен "little", самый старший байт находится в конце массива байтов. Чтобы запросить порядок байтов хост-системы, используйте значение sys.byteorder для byteorder.

Аргумент signed определяет, используется ли дополнение до двух для представления целого числа. Если signed равно False и задано отрицательное целое число, генерируется исключение OverflowError. Значение по умолчанию для signed равно False.

Добавлено в версии 3.2.

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

Возвращает целое число, представленное заданным массивом байтов.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Аргумент bytes должен быть объектом-подобным байтам или итерируемым объектом, возвращающим байты.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа. Если byteorder равен "big", самый старший байт находится в начале массива байтов. Если byteorder равен "little", самый старший байт находится в конце массива байтов. Чтобы запросить порядок байтов хост-системы, используйте значение sys.byteorder для byteorder.

Аргумент signed указывает, используется ли дополнение до двух для представления целого числа.

Добавлено в версии 3.2.

int.as_integer_ratio()

Возвращает пару целых чисел, отношение которых точно равно исходному целому числу и с положительным знаменателем. Целочисленное отношение целых чисел всегда имеет целое число в качестве числителя и 1 в качестве знаменателя.

Добавлено в версии 3.8.

Дополнительные методы для типа float

Тип float реализует numbers.Real абстрактный базовый класс. Тип float также имеет следующие дополнительные методы.

float.as_integer_ratio()

Возвращает пару целых чисел, отношение которых точно равно исходному числу с плавающей запятой и с положительным знаменателем. Возвращает исключение OverflowError для бесконечностей и исключение ValueError для NaN.

float.is_integer()

Возвращает True если экземпляр числа с плавающей точкой является конечным с целым значением, и False в противном случае:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

Два метода поддерживают преобразование в и из шестнадцатеричных строк. Поскольку числа с плавающей запятой в Python хранятся внутри как двоичные числа, преобразование числа с плавающей запятой в или из десятичной строки обычно приводит к небольшой ошибке округления. В противоположность этому, шестнадцатеричные строки позволяют точное представление и задание чисел с плавающей запятой. Это может быть полезно при отладке и в численных расчетах.

float.hex()

Возвращает шестнадцатеричное представление числа с плавающей запятой. Для конечных чисел с плавающей запятой это представление всегда включает ведущую 0x и заключительную p и показатель степени.

classmethod float.fromhex(s)

Метод класса для возвращения числа с плавающей запятой, представленного шестнадцатеричной строкой s. Строка s может иметь пробелы в начале и конце.

Обратите внимание, что float.hex() — метод экземпляра, а float.fromhex() — метод класса.

Шестнадцатеричная строка имеет вид:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

где необязательный sign может быть + или -, integer и fraction — строки шестнадцатеричных цифр, а exponent — целое десятичное число с необязательным ведущим знаком. Регистр не имеет значения, и должно быть хотя бы одно шестнадцатеричное число в целой или дробной части. Этот синтаксис аналогичен синтаксису, указанному в разделе 6.4.4.2 стандарта C99, а также синтаксису, используемому в Java 1.5 и более поздних версиях. В частности, вывод float.hex() может использоваться как шестнадцатеричная литеральная константа числа с плавающей запятой в коде C или Java, а шестнадцатеричные строки, созданные форматирующим символом %a языка C или форматирующим символом Double.toHexString языка Java, принимаются float.fromhex().

Обратите внимание, что показатель степени записывается в десятичном, а не в шестнадцатеричном формате, и что он указывает степень 2, на которую нужно умножить коэффициент. Например, шестнадцатеричная строка 0x3.a7p10 представляет число с плавающей запятой (3 + 10./16 + 7./16**2) * 2.0**10, или 3740.0:

>>> float.fromhex('0x3.a7p10')
3740.0

Применение обратного преобразования к 3740.0 даёт другую шестнадцатеричную строку, представляющую то же самое число:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Хэширование числовых типов

Для чисел x и y, возможно, разных типов, требуется, чтобы hash(x) == hash(y) всякий раз, когда x == y (см. документацию метода __hash__() для получения более подробной информации). Для простоты реализации и эффективности работы с различными числовыми типами (включая int, float, decimal.Decimal и fractions.Fraction) хэш-функция Python для числовых типов основана на одной математической функции, определённой для любого рационального числа, и поэтому применяется ко всем экземплярам int и fractions.Fraction, и ко всем конечным экземплярам float и decimal.Decimal. По сути, эта функция задаётся как остаток от деления на P для заданного простого числа P. Значение P доступно для Python как атрибут modulus объекта sys.hash_info.

Вот подробное описание правил:

• Если x = m / n — неотрицательное рациональное число, и n не делится на P, определите hash(x) как m * invmod(n, P) % P, где invmod(n, P) даёт обратное значение n по модулю P.
• Если x = m / n — неотрицательное рациональное число, и n делится на P (но m не делится), то у n нет обратного значения по модулю P, и правило выше не применяется; в этом случае определите hash(x) как постоянное значение sys.hash_info.inf.
• Если x = m / n — отрицательное рациональное число, определите hash(x) как -hash(-x). Если полученный хэш равен -1, замените его на -2.
• Конкретные значения sys.hash_info.inf, -sys.hash_info.inf и sys.hash_info.nan используются в качестве хэшей для положительной бесконечности, отрицательной бесконечности или NaN (соответственно). (Все хэшируемые NaN имеют одинаковый хэш).
• Для комплексного числа complex z, хэши действительной и мнимой частей объединяются вычислением hash(z.real) + sys.hash_info.imag * hash(z.imag), остаток от деления на 2**sys.hash_info.width, так, чтобы он лежал в range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Опять же, если результат равен -1, он заменяется на -2.

Для большей ясности вышеуказанных правил, вот пример кода Python, эквивалентного встроенному хэшированию, для вычисления хэша рационального числа, float или complex:

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

Типы генераторов

Генераторы Python предоставляют удобный способ реализации протокола итератора. Если метод __iter__() объекта-контейнера реализован как генератор, он автоматически вернёт объект-итератор (технически, объект генератора), предоставляя методы __iter__() и __next__(). Более подробную информацию о генераторах можно найти в документации по выражению yield.

Общие операции с последовательностями

Операции в следующей таблице поддерживаются большинством типов последовательностей, как изменяемыми, так и неизменяемыми. collections.abc.Sequence ABC предоставляет удобный способ правильной реализации этих операций для пользовательских типов последовательностей.

В этой таблице операции упорядочены по возрастанию приоритета. В таблице s и t — последовательности одного типа, n, i, j и k — целые числа, а x — произвольный объект, удовлетворяющий любым ограничениям типа и значения, наложенным на s.

Операции in и not in имеют тот же приоритет, что и операции сравнения. Операции + (конкатенация) и * (повторение) имеют тот же приоритет, что и соответствующие числовые операции. 3

Последовательности одного типа также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путем сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равен, и две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в разделе Сравнения в справочнике языка.)

Примечания:

1. Хотя операции in и not in в общем случае используются только для простого тестирования включения, некоторые специализированные последовательности (такие как str, bytes и bytearray) также используют их для проверки подпоследовательности:

   >>> "gg" in "eggs"
   True
   

2. Значения n, меньшие 0, обрабатываются как 0 (что приводит к пустой последовательности того же типа, что и s). Обратите внимание, что элементы в последовательности s не копируются; они ссылаются несколько раз. Это часто беспокоит начинающих программистов Python; рассмотрите:

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]
   

   Произошло следующее: [[]] — это список из одного элемента, содержащий пустой список, поэтому все три элемента [[]] * 3 ссылаются на этот единственный пустой список. Изменение любого из элементов lists изменяет этот единственный список. Вы можете создать список различных списков таким образом:

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]
   

   Дополнительные объяснения см. в записи FAQ Как создать многомерный список?.

3. Если i или j отрицательны, индекс относится к концу последовательности s: len(s) + i или len(s) + j заменяются. Но обратите внимание, что -0 по-прежнему 0.
4. Срез s от i до j определяется как последовательность элементов с индексом k, таким что i <= k < j. Если i или j больше len(s), используйте len(s). Если i опущено или None, используйте 0. Если j опущено или None, используйте len(s). Если i больше или равно j, срез пустой.
5. Срез s от i до j с шагом k определяется как последовательность элементов с индексом x = i + n*k таким образом, что 0 <= n < (j-i)/k. Другими словами, индексы — это i, i+k, i+2*k, i+3*k и так далее, останавливаясь, когда достигается j (но никогда не включая j). Когда k положительно, i и j сокращаются до len(s) если они больше. Когда k отрицательно, i и j сокращаются до len(s) - 1 если они больше. Если i или j опущено или None, они становятся «конечными» значениями (которые зависят от знака k). Обратите внимание, что k не может быть нулём. Если k None, он обрабатывается как 1.

6. Конкатенация неизменяемых последовательностей всегда приводит к новому объекту. Это означает, что построение последовательности с помощью многократной конкатенации потребует квадратичной временной сложности по общей длине последовательности. Чтобы получить линейную временную сложность, необходимо перейти к одному из приведенных ниже альтернативных вариантов:

   • при конкатенации объектов str вы можете создать список и использовать str.join() в конце или же записывать в экземпляр io.StringIO и извлекать его значение, когда завершение будет достигнуто
   • при конкатенации объектов bytes вы можете аналогично использовать bytes.join() или io.BytesIO, или вы можете выполнить конкатенацию на месте с объектом bytearray. Объекты bytearray изменяемы и имеют механизм эффективного перераспределения памяти
   • при конкатенации объектов tuple вместо этого расширяйте объект list
   • для других типов изучите документацию соответствующего класса
7. Некоторые типы последовательностей (например, range) поддерживают только последовательности элементов, которые следуют определенным шаблонам, и поэтому не поддерживают конкатенацию или повторение последовательностей.
8. index вызывает ValueError, когда x не найден в s. Не все реализации поддерживают передачу дополнительных аргументов i и j. Эти аргументы позволяют эффективно искать подпоследовательности. Передача дополнительных аргументов примерно эквивалентна использованию s[i:j].index(x), только без копирования каких-либо данных и с возвращаемым индексом, относящимся к началу последовательности, а не к началу среза.

Неизменяемые типы последовательностей

Единственной операцией, которую неизменяемые типы последовательностей обычно реализуют, но которая не реализуется изменяемыми типами последовательностей, является поддержка встроенного hash().

Эта поддержка позволяет использовать неизменяемые последовательности, такие как экземпляры tuple, в качестве ключей dict и хранить их в экземплярах set и frozenset.

Попытка хеширования неизменяемой последовательности, содержащей нехешируемые значения, приведет к TypeError.

Изменяемые типы последовательностей

Операции в следующей таблице определены для изменяемых типов последовательностей. collections.abc.MutableSequence ABC предоставляет удобный способ корректной реализации этих операций для пользовательских типов последовательностей.

В таблице s — это экземпляр изменяемого типа последовательности, t — любой итерируемый объект, а x — произвольный объект, удовлетворяющий любым ограничениям типа и значения, накладываемым на s (например, bytearray принимает только целые числа, удовлетворяющие ограничению значения 0 <= x <= 255).

Примечания:

1. t должен иметь такую же длину, как срез, который он заменяет.
2. Необязательный аргумент i по умолчанию равен -1, поэтому по умолчанию удаляется и возвращается последний элемент.
3. remove() вызывает ValueError, когда x не найден в s.
4. Метод reverse() изменяет последовательность на месте для экономии памяти при развороте большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он не возвращает изменённую последовательность.

5. clear() и copy() включены для согласованности с интерфейсами изменяемых контейнеров, не поддерживающих операции среза (например, dict и set). copy() не является частью collections.abc.MutableSequence ABC, но большинство конкретных классов изменяемых последовательностей предоставляют его.

   Введено в версии 3.3: clear() и copy() методы.

6. Значение n — целое число или объект, реализующий __index__(). Нулевые и отрицательные значения n очищают последовательность. Элементы последовательности не копируются; они ссылаются на них несколько раз, как объяснено для s * n в разделе Общие операции с последовательностями.

Списки

Списки — изменяемые последовательности, обычно используемые для хранения наборов однородных элементов (степень однородности может варьироваться в зависимости от приложения).

class list([iterable])

Списки могут быть созданы несколькими способами:

• Используя пару квадратных скобок для обозначения пустого списка: []
• Используя квадратные скобки, разделяя элементы запятыми: [a], [a, b, c]
• Используя список с выражением: [x for x in iterable]
• Используя конструктор типа: list() или list(iterable)

Конструктор создаёт список, элементы которого такие же и в том же порядке, что и элементы iterable. iterable может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если iterable уже является списком, создаётся копия и возвращается, аналогично iterable[:]. Например, list('abc') возвращает ['a', 'b', 'c'], а list( (1, 2, 3) ) возвращает [1, 2, 3]. Если аргумент не указан, конструктор создаёт новый пустой список, [].

Многие другие операции также производят списки, включая встроенную функцию sorted().

Списки реализуют все общие и изменяемые операции с последовательностями. Списки также предоставляют следующий дополнительный метод:

sort(*, key=None, reverse=False)

Этот метод сортирует список на месте, используя только сравнения между элементами. Исключение не подавляется — если какая-либо операция сравнения завершается ошибкой, вся операция сортировки завершается ошибкой (и список, вероятно, останется в частично изменённом состоянии).

sort() принимает два аргумента, которые могут быть переданы только по ключевому слову (аргументы только по ключевому слову):

key определяет функцию от одного аргумента, используемую для извлечения ключа сравнения для каждого элемента списка (например, key=str.lower). Ключ, соответствующий каждому элементу в списке, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию None означает, что элементы списка сортируются непосредственно без вычисления отдельного значения ключа.

Утилита functools.cmp_to_key() доступна для преобразования функции cmp в стиле 2.x в функцию key.

reverse — булево значение. Если установлено в True, элементы списка сортируются так, как будто каждое сравнение было обращено.

Этот метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он не возвращает отсортированную последовательность (используйте sorted(), чтобы явно запросить новый экземпляр отсортированного списка).

Метод sort() гарантированно устойчив. Сортировка устойчива, если она гарантирует, что не будет изменять относительный порядок элементов, которые сравниваются одинаково — это полезно для сортировки в несколько проходов (например, сортировка по отделу, затем по званию).

Примеры сортировки и краткое руководство по сортировке см. в Руководстве по сортировке.

Деталь реализации CPython: Пока список сортируется, эффект попытки изменить или даже проверить список не определен. Реализация C Python делает список пустым на время и вызывает ValueError, если она может обнаружить, что список был изменён во время сортировки.

Кортежи

Кортежи — это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (например, 2-кортежей, создаваемых встроенной функцией enumerate()). Кортежи также используются в случаях, когда требуется неизменяемая последовательность однородных данных (например, для хранения в экземпляре set или dict).

class tuple([iterable])

Кортежи можно создать несколькими способами:

• Используя пару скобок для обозначения пустого кортежа: ()
• Используя заключительный запятую для кортежа с одним элементом: a, или (a,)
• Разделяя элементы запятыми: a, b, c или (a, b, c)
• Используя встроенную функцию tuple(): tuple() или tuple(iterable)

Конструктор создаёт кортеж, элементы которого совпадают и расположены в том же порядке, что и элементы iterable. iterable может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если iterable уже является кортежем, он возвращается без изменений. Например, tuple('abc') возвращает ('a', 'b', 'c') и tuple( [1, 2, 3] ) возвращает (1, 2, 3). Если аргумент не указан, конструктор создаёт новый пустой кортеж, ().

Обратите внимание, что кортеж образуется с помощью запятой, а не скобок. Скобки необязательны, за исключением пустого кортежа или когда они необходимы для избежания синтаксической неоднозначности. Например, f(a, b, c) — это вызов функции с тремя аргументами, а f((a, b, c)) — это вызов функции с 3-кортежем в качестве единственного аргумента.

Кортежи реализуют все операции над последовательностями общими последовательностями.

Для разнородных коллекций данных, где доступ по имени понятнее, чем доступ по индексу, collections.namedtuple() может быть более подходящим выбором, чем простой кортеж.

Диапазоны

Тип range представляет собой неизменяемую последовательность чисел и обычно используется для циклического повторения определённого числа раз в циклах for.

class range(stop)

class range(start, stop[, step])

Аргументы конструктора range должны быть целыми числами (встроенными int или объектами, реализующими специальный метод __index__()). Если аргумент step опущен, он по умолчанию равен 1. Если аргумент start опущен, он по умолчанию равен 0. Если step равен нулю, возникает исключение ValueError.

Для положительного step содержимое диапазона r определяется формулой r[i] = start + step*i где i >= 0 и r[i] < stop.

Для отрицательного step содержимое диапазона всё ещё определяется формулой r[i] = start + step*i, но ограничениями являются i >= 0 и r[i] > stop.

Объект диапазона будет пустым, если r[0] не удовлетворяет ограничению по значению. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексы с конца последовательности, определяемой положительными индексами.

Диапазоны с абсолютными значениями, большими, чем sys.maxsize, разрешены, но некоторые функции (например, len()) могут вызвать исключение OverflowError.

Примеры диапазонов:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

Диапазоны реализуют все операции над последовательностями общими последовательностями, кроме конкатенации и повторения (поскольку объекты диапазона могут представлять только последовательности, которые следуют строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).

start

Значение параметра start (или 0 если параметр не был указан)

stop

Значение параметра stop

step

Значение параметра step (или 1 если параметр не был указан)

Преимущество типа range перед обычным list или tuple заключается в том, что объект range всегда занимает одинаковый (малый) объём памяти, независимо от размера представляемого им диапазона (поскольку он хранит только значения start, stop и step, вычисляя отдельные элементы и поддиапазоны по мере необходимости).

Объекты диапазона реализуют ABC collections.abc.Sequence и предоставляют такие функции, как проверка на вхождение, поиск индекса элемента, срезы и поддержка отрицательных индексов (см. Типы последовательностей — список, кортеж, диапазон):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Проверка равенства объектов диапазона с помощью == и != сравнивает их как последовательности. То есть два объекта диапазона считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два объекта диапазона, которые сравниваются как равные, могут иметь разные атрибуты start, stop и step, например, range(0) == range(2, 1, 3) или range(0, 3, 2) == range(0, 4, 2).)

Методы строк

Строки реализуют все общие операции со последовательностями, а также дополнительные методы, описанные ниже.

Строки также поддерживают два стиля форматирования строк: один обеспечивает большую гибкость и настраиваемость (см. str.format(), Синтаксис форматирования строк и Настраиваемое форматирование строк), а другой основан на стиле форматирования C printf и обрабатывает более узкий диапазон типов и немного сложнее для корректного использования, но часто быстрее в тех случаях, когда он применим (Форматирование строк в стиле printf).

Раздел «Службы обработки текста» стандартной библиотеки охватывает ряд других модулей, которые предоставляют различные служебные программы для работы с текстом (включая поддержку регулярных выражений в модуле re).

str.capitalize()

Возвращает копию строки, в которой первая буква заглавная, а остальные строчные.

Изменено в версии 3.8: Теперь первая буква преобразуется в заглавную букву (titlecase), а не в верхний регистр (uppercase). Это означает, что такие символы, как диграфы, будут иметь только первую букву в заглавном регистре, а не весь символ.

str.casefold()

Возвращает копию строки в сложенном формате. Строки в сложенном формате могут использоваться для сопоставления без учета регистра.

Преобразование в сложенный формат похоже на преобразование в нижний регистр, но более агрессивно, так как предназначено для устранения всех различий в регистре в строке. Например, немецкая строчная буква 'ß' эквивалентна "ss". Поскольку она уже в нижнем регистре, lower() не произведет никаких изменений в 'ß'; casefold() преобразует её в "ss".

Алгоритм сложения регистров описан в разделе 3.13 стандарта Unicode.

Добавлена в версии 3.3.

str.center(width[, fillchar])

Возвращает строку, центрированную в строке длиной width. Выравнивание выполняется с использованием указанного fillchar (по умолчанию – ASCII пробел). Исходная строка возвращается, если width меньше или равно len(s).

str.count(sub[, start[, end]])

Возвращает количество неперекрывающихся вхождений подстроки sub в диапазоне [start, end]. Дополнительные аргументы start и end интерпретируются так же, как в обозначении срезов.

str.encode(encoding="utf-8", errors="strict")

Возвращает закодированную версию строки в виде объекта bytes. По умолчанию используется кодировка 'utf-8'. errors может быть задан для настройки схемы обработки ошибок. По умолчанию errors равен 'strict', что означает, что ошибки кодирования генерируют исключение UnicodeError. Другие возможные значения – 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' и любое другое имя, зарегистрированное через codecs.register_error(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

По умолчанию аргумент errors не проверяется для повышения производительности, а используется только при первой ошибке кодирования. Включите режим разработки Python или используйте отладочную сборку для проверки errors.

Изменено в версии 3.1: Добавлена поддержка ключевых аргументов.

Изменено в версии 3.9: Теперь errors проверяется в режиме разработки и в отладочном режиме.

str.endswith(suffix[, start[, end]])

Возвращает True если строка заканчивается указанным suffix, в противном случае возвращает False. suffix также может быть кортежем суффиксов для поиска. С необязательным start, проверка начинается с этой позиции. С необязательным end, сравнение останавливается на этой позиции.

str.expandtabs(tabsize=8)

Возвращает копию строки, где все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции происходят через каждые tabsize символов (по умолчанию 8, давая позиции табуляции в колонках 0, 8, 16 и т. д.). Для расширения строки текущая колонка устанавливается в ноль, и строка проверяется символ за символом. Если символом является табуляция (\t), в результат вставляется один или несколько символов пробела, пока текущая колонка не станет равной следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символом является перевод строки (\n) или возврат каретки (\r), он копируется, и текущая колонка сбрасывается до нуля. Любой другой символ копируется без изменений, и текущая колонка увеличивается на единицу независимо от того, как символ представлен при печати.

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

str.find(sub[, start[, end]])

Возвращает наименьший индекс в строке, где подстрока sub найдена в срезе s[start:end]. Дополнительные аргументы start и end интерпретируются так же, как в обозначении срезов. Возвращает -1 если sub не найдена.

Примечание

Метод find() следует использовать только если вам нужно знать позицию sub. Чтобы проверить, является ли sub подстрокой или нет, используйте оператор in:

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

Выполняет операцию форматирования строк. Строка, к которой применяется этот метод, может содержать литеральные текстовые данные или поля замещения, ограниченные фигурными скобками {}. Каждое поле замещения содержит либо числовой индекс позиционного аргумента, либо имя ключевого аргумента. Возвращает копию строки, где каждое поле замещения заменяется строковым значением соответствующего аргумента.

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

См. Синтаксис форматирования строк для описания различных параметров форматирования, которые могут быть указаны в строках форматирования.

Примечание

При форматировании числа (int, float, complex, decimal.Decimal и подклассы) с типом n (например: '{:n}'.format(1234)), функция временно устанавливает локаль LC_CTYPE на локаль LC_NUMERIC для декодирования decimal_point и thousands_sep полей localeconv() если они не ASCII или длиннее 1 байта, и локаль LC_NUMERIC отличается от локали LC_CTYPE. Это временное изменение влияет на другие потоки.

Изменено в версии 3.7: При форматировании числа с типом n, функция временно устанавливает локаль LC_CTYPE на локаль LC_NUMERIC в некоторых случаях.

str.format_map(mapping)

Аналогично str.format(**mapping), за исключением того, что mapping используется напрямую, а не копируется в dict. Это полезно, например, если mapping является подклассом dict:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

Добавлена в версии 3.2.

str.index(sub[, start[, end]])

Аналогично find(), но генерирует исключение ValueError при отсутствии подстроки.

str.isalnum()

Возвращает True если все символы в строке являются буквенно-цифровыми и присутствует хотя бы один символ, False в противном случае. Символ c считается буквенно-цифровым, если одно из следующих выражений возвращает True: c.isalpha(), c.isdecimal(), c.isdigit(), или c.isnumeric().

str.isalpha()

Возвращает True если все символы в строке являются буквенными и присутствует хотя бы один символ, False в противном случае. Буквенные символы – это те символы, которые определены в базе данных символов Unicode как «Буква», т.е. те, у которых свойство общей категории равно одному из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Буквенный» в стандарте Unicode.

str.isascii()

Возвращает True если строка пустая или все символы в строке являются ASCII, False в противном случае. ASCII символы имеют кодовые точки в диапазоне U+0000-U+007F.

Добавлена в версии 3.7.

str.isdecimal()

Возвращает True если все символы в строке являются десятичными символами и в строке есть хотя бы один символ, False в противном случае. Десятичные символы — это символы, которые могут быть использованы для формирования чисел в системе счисления по основанию 10, например, U+0660, АРАБСКАЯ ЦИФРА НОЛЬ. Строго говоря, десятичный символ — это символ с категорией Unicode «Nd».

str.isdigit()

Возвращает True если все символы в строке являются цифрами и в строке есть хотя бы один символ, False в противном случае. Цифры включают десятичные символы и цифры, которые требуют специальной обработки, такие как цифры с верхними индексами. Это охватывает цифры, которые нельзя использовать для формирования чисел в системе счисления по основанию 10, например, цифры системы Харошти. Строго говоря, цифра — это символ, у которого значение свойства Numeric_Type равно Digit или Decimal.

str.isidentifier()

Возвращает True если строка является допустимым идентификатором в соответствии с определением языка, раздел Идентификаторы и ключевые слова.

Вызовите keyword.iskeyword() для проверки, является ли строка s зарезервированным идентификатором, например def и class.

Пример:

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()

Возвращает True если все символы с регистром 4 в строке являются строчными и в строке есть хотя бы один символ с регистром, False в противном случае.

str.isnumeric()

Возвращает True если все символы в строке являются числовыми символами и в строке есть хотя бы один символ, False в противном случае. Числовые символы включают символы цифр и все символы, имеющие числовое значение Unicode, например U+2155, ДРОБЬ ОДНА ПЯТАЯ. Строго говоря, числовые символы — это те, у которых значение свойства Numeric_Type равно Digit, Decimal или Numeric.

str.isprintable()

Возвращает True если все символы в строке являются печатными или строка пуста, False в противном случае. Непечатаемые символы — это те символы, которые в базе данных Unicode определены как «Другие» или «Разделитель», за исключением ASCII-пробела (0x20), который считается печатным. (Обратите внимание, что печатные символы в данном контексте — это те, которые не должны быть экранированы, когда на строку вызывается repr(). Это никак не влияет на обработку строк, записанных в sys.stdout или sys.stderr.)

str.isspace()

Возвращает True если в строке есть только символы пробелов и в строке есть хотя бы один символ, False в противном случае.

Символ является пробелом, если в базе данных Unicode (см. unicodedata) его общая категория — Zs («Разделитель, пробел»), или его класс двунаправленной обработки — один из WS, B, или S.

str.istitle()

Возвращает True если строка является строкой с заглавными буквами в начале слов и в строке есть хотя бы один символ, например, прописные буквы могут следовать только за непрописными, а строчные — только за прописными. Возвращает False в противном случае.

str.isupper()

Возвращает True если все символы с регистром 4 в строке являются заглавными и в строке есть хотя бы один символ с регистром, False в противном случае.

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)

Возвращает строку, которая является конкатенацией строк в итерируемом объекте. Будет вызвано исключение TypeError, если в итерируемом объекте есть какие-либо значения, не являющиеся строками, включая объекты bytes. Разделитель между элементами — это строка, предоставляющая этот метод.

str.ljust(width[, fillchar])

Возвращает строку, выровненную по левому краю в строке длиной width. Заполнение выполняется с использованием указанного fillchar (по умолчанию — ASCII-пробел). Исходная строка возвращается, если width меньше или равно len(s).

str.lower()

Возвращает копию строки со всеми символами с регистром 4, преобразованными в строчные.

Алгоритм приведения к нижнему регистру описан в разделе 3.13 стандарта Unicode.

str.lstrip([chars])

Возвращает копию строки со удаленными начальными символами. Аргумент chars — это строка, определяющая набор символов для удаления. Если он опущен или None, аргумент chars по умолчанию удаляет пробелы. Аргумент chars не является префиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

См. str.removeprefix() для метода, удаляющего одну строку-префикс, а не весь набор символов. Например:

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(x[, y[, z]])

Этот статический метод возвращает таблицу преобразования, используемую для str.translate().

Если есть только один аргумент, он должен быть словарем, сопоставляющим порядковые номера Unicode (целые числа) или символы (строки длиной 1) с порядковыми номерами Unicode, строками (любой длины) или None. Символьные ключи затем будут преобразованы в порядковые номера.

Если есть два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ в x будет сопоставлен с символом на той же позиции в y. Если есть третий аргумент, он должен быть строкой, символы которой будут сопоставлены с None в результате.

str.partition(sep)

Разделяет строку по первому вхождению sep и возвращает кортеж из 3 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из 3 элементов: сама строка, за ней две пустые строки.

str.removeprefix(prefix, /)

Если строка начинается со строки prefix, возвращает string[len(prefix):]. В противном случае возвращает копию исходной строки:

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

Новое в версии 3.9.

str.removesuffix(suffix, /)

Если строка заканчивается на строку suffix и эта suffix не пуста, возвращает string[:-len(suffix)]. В противном случае возвращает копию исходной строки:

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

Новое в версии 3.9.

str.replace(old, new[, count])

Возвращает копию строки со всеми вхождениями подстроки old, заменёнными на new. Если необязательный аргумент count задан, заменяются только первые count вхождений.

str.rfind(sub[, start[, end]])

Возвращает наибольший индекс в строке, где найдена подстрока sub, такая, что sub содержится в s[start:end]. Необязательные аргументы start и end интерпретируются как в нотации срезов. В случае неудачи возвращает -1.

str.rindex(sub[, start[, end]])

Подобно rfind(), но в случае, если подстрока sub не найдена, вызывает исключение ValueError.

str.rjust(width[, fillchar])

Возвращает строку, выровненную по правому краю в строке длиной width. Заполнение выполняется с использованием указанного fillchar (по умолчанию — ASCII-пробел). Исходная строка возвращается, если width меньше или равно len(s).

str.rpartition(sep)

Разделяет строку по последнему вхождению sep и возвращает кортеж из 3 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из 3 элементов: две пустые строки, за которыми следует сама строка.

str.rsplit(sep=None, maxsplit=-1)

Возвращает список слов в строке, используя sep в качестве разделителя. Если задан maxsplit, выполняется не более maxsplit разделений, начиная с правого. Если sep не указан или None, любая строка пробелов является разделителем. За исключением разделения справа налево, rsplit() ведет себя как split(), подробно описанный ниже.

str.rstrip([chars])

Возвращает копию строки с удаленными конечными символами. Аргумент chars — это строка, определяющая набор символов, которые нужно удалить. Если он опущен или None, по умолчанию удаляются пробелы. Аргумент chars не является суффиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

См. str.removesuffix() для метода, который удаляет одну строку-суффикс, а не весь набор символов. Например:

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

str.split(sep=None, maxsplit=-1)

Возвращает список слов в строке, используя sep в качестве разделителя. Если задан maxsplit, выполняется не более maxsplit разбиений (следовательно, список будет содержать не более maxsplit+1 элементов). Если maxsplit не указан или -1, ограничений на количество разбиений нет (производится все возможные разбиения).

Если задан sep, последовательные разделители не объединяются и считаются разделителями пустых строк (например, '1,,2'.split(',') возвращает ['1', '', '2']). Аргумент sep может состоять из нескольких символов (например, '1<>2<>3'.split('<>') возвращает ['1', '2', '3']). Разбиение пустой строки с указанным разделителем возвращает [''].

Например:

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

Если sep не указан или None, применяется другой алгоритм разбиения: последовательности пробелов считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если строка имеет начальные или конечные пробелы. Следовательно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем None возвращает [].

Например:

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

str.splitlines(keepends=False)

Возвращает список строк в строке, разбивая их по границам строк. Разделители строк не включены в результирующий список, если не задан и не имеет значение keepends.

Этот метод разделяет по следующим границам строк. В частности, границы являются надмножеством универсальных разделителей строк.

Представление	Описание
\n	Возврат строки
\r	Возврат каретки
\r\n	Возврат каретки + возврат строки
\v или \x0b	Табуляция
\f или \x0c	Форма подачи
\x1c	Разделитель файла
\x1d	Разделитель группы
\x1e	Разделитель записи
\x85	Следующая строка (код управления C1)
\u2028	Разделитель строки
\u2029	Разделитель абзаца

Изменено в версии 3.2: \v и \f добавлены в список границ строк.

Например:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

В отличие от split(), когда задана строка-разделитель sep, этот метод возвращает пустой список для пустой строки, и конечный разделитель строк не приводит к дополнительной строке:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

Для сравнения, split('\n') дает:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])

Возвращает True если строка начинается с prefix, в противном случае возвращает False. prefix также может быть кортежем из префиксов для поиска. С необязательным start проверять строку начиная с этой позиции. С необязательным end останавливать сравнение строки на этой позиции.

str.strip([chars])

Возвращает копию строки с удаленными начальными и конечными символами. Аргумент chars — это строка, определяющая набор символов, которые нужно удалить. Если он опущен или None, по умолчанию удаляются пробелы. Аргумент chars не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

Удаляются крайние начальные и конечные символы аргумента chars. Символы удаляются с начального конца, пока не будет достигнут символ строки, не входящий в набор символов в chars. Аналогичное действие происходит с конечным концом. Например:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

str.swapcase()

Возвращает копию строки, в которой заглавные буквы заменены строчными и наоборот. Обратите внимание, что s.swapcase().swapcase() == s не всегда верно.

str.title()

Возвращает строку в формате заголовка, где слова начинаются с заглавной буквы, а остальные символы — строчные.

Например:

>>> 'Hello world'.title()
'Hello World'

Алгоритм использует простое независимое от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но это означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может не быть желаемым результатом:

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

Функция string.capwords() не имеет этой проблемы, так как она разбивает слова только по пробелам.

В качестве обходного пути для апострофов можно использовать регулярные выражения:

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)

Возвращает копию строки, в которой каждый символ отображается через заданную таблицу преобразования. Таблица должна быть объектом, реализующим индексирование с помощью __getitem__(), обычно это отображение или последовательность. При индексировании по коду Юникода (целому числу) объект таблицы может выполнить любое из следующих действий: вернуть код Юникода или строку, чтобы отобразить символ на один или несколько других символов; вернуть None, чтобы удалить символ из возвращаемой строки; или вызвать исключение LookupError, чтобы отобразить символ на сам себя.

Вы можете использовать str.maketrans() для создания таблицы преобразования из соответствий символ-символ в разных форматах.

См. также модуль codecs для более гибкого подхода к пользовательским отображениям символов.

str.upper()

Возвращает копию строки со всеми символами с регистром 4, преобразованными в верхний регистр. Обратите внимание, что s.upper().isupper() может быть False, если s содержит символы без регистра, или если категория Юникода результирующего символа(ов) не «Lu» (буква, заглавная), а, например, «Lt» (буква, строчная).

Используемый алгоритм преобразования в верхний регистр описан в разделе 3.13 стандарта Юникод.

str.zfill(width)

Возвращает копию строки, дополненную слева ASCII цифрами до длины width. Префикс знака ('+'/'-' обрабатывается путем вставки заполнения *после* символа знака, а не перед ним. Исходная строка возвращается, если width меньше или равен len(s).

Например:

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf-форматирование строк

Объекты строк имеют одну уникальную встроенную операцию: оператор % (modulo). Он также известен как оператор форматирования или интерполяции строк. При задании format % values (где format — это строка), % спецификации преобразования в format заменяются одним или несколькими элементами из values. Эффект аналогичен использованию оператора sprintf() в языке C.

Если format требует единственного аргумента, values может быть одним объектом, не являющимся кортежем. 5 В противном случае values должен быть кортежем с точным количеством элементов, указанным в формате строки, или одним объектом сопоставления (например, словарем).

Спецификатор преобразования содержит два или более символов и состоит из следующих компонентов, которые должны следовать в этом порядке:

1. Символ '%', обозначающий начало спецификатора.
2. Ключ сопоставления (необязательный), представляющий собой заключенную в скобки последовательность символов (например, (somename)).
3. Флаги преобразования (необязательные), влияющие на результат некоторых типов преобразований.
4. Минимальная ширина поля (необязательная). Если указано как '*' (звездочка), фактическая ширина считывается из следующего элемента кортежа в values, а объект для преобразования следует за минимальной шириной поля и необязательной точностью.
5. Точность (необязательная), задаваемая символом '.' (точка) и значением точности. Если указано как '*' (звездочка), фактическая точность считывается из следующего элемента кортежа в values, а значение для преобразования следует за точностью.
6. Модификатор длины (необязательный).
7. Тип преобразования.

Когда правым аргументом является словарь (или другой тип сопоставления), форматы в строке должны содержать ключ сопоставления в этом словаре, заключенный в скобки и вставленный непосредственно после символа '%'. Ключ сопоставления выбирает значение, подлежащее форматированию, из сопоставления. Например:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

В этом случае * спецификаторы не могут встречаться в формате (поскольку они требуют последовательного списка параметров).

Символы флагов преобразования:

Модификатор длины (h, l, или L) может быть присутствовать, но игнорируется, так как он не нужен в Python — например, %ld идентично %d.

Типы преобразований:

Примечания:

1. Альтернативная форма вставляет ведущий восьмеричный спецификатор ('0o') перед первой цифрой.
2. Альтернативная форма вставляет ведущий '0x' или '0X' (в зависимости от того, использовался ли формат 'x' или 'X') перед первой цифрой.

3. Альтернативная форма всегда включает в результат десятичную точку, даже если за ней не следуют цифры.

   Точность определяет количество цифр после десятичной точки и по умолчанию равна 6.

4. Альтернативная форма всегда включает в результат десятичную точку, и хвостовые нули не удаляются, как это было бы в противном случае.

   Точность определяет количество значащих цифр до и после десятичной точки и по умолчанию равна 6.

5. Если точность N, вывод обрезается до N символов.
6. См. PEP 237.

Поскольку строки Python имеют явную длину, преобразования %s не предполагают, что '\0' является концом строки.

Объекты типа bytes

Объекты типа bytes являются неизменяемыми последовательностями отдельных байтов. Поскольку многие основные двоичные протоколы основаны на кодировке ASCII, объекты типа bytes предлагают несколько методов, которые допустимы только при работе с данными, совместимыми с ASCII, и тесно связаны с объектами типа string во многих других отношениях.

class bytes([source[, encoding[, errors]]])

Во-первых, синтаксис для литералов типа bytes в основном такой же, как и для строковых литералов, за исключением того, что добавляется префикс b:

• Одинарные кавычки: b'still allows embedded "double" quotes'
• Двойные кавычки: b"still allows embedded 'single' quotes"
• Тройные кавычки: b'''3 single quotes''', b"""3 double quotes"""

В литералах типа bytes разрешены только символы ASCII (независимо от объявленной кодировки исходного кода). Любые двоичные значения свыше 127 должны быть введены в литералы типа bytes с использованием соответствующей последовательности экранирования.

Как и в случае со строковыми литералами, литералы типа bytes также могут использовать префикс r для отключения обработки последовательностей экранирования. Дополнительную информацию о различных формах литералов типа bytes, включая поддерживаемые последовательности экранирования, см. в разделе Литералы строк и байтов.

Хотя литералы и представления типа bytes основаны на тексте ASCII, объекты типа bytes фактически ведут себя как неизменяемые последовательности целых чисел, при этом каждое значение в последовательности ограничено таким образом, что 0 <= x < 256 (попытки нарушения этого ограничения приведут к исключению ValueError). Это сделано намеренно, чтобы подчеркнуть, что хотя многие двоичные форматы включают элементы ASCII и могут быть полезно обработаны с помощью некоторых алгоритмов, ориентированных на текст, это обычно не относится к произвольным двоичным данным (слепое применение алгоритмов обработки текста к двоичным форматам, не совместимым с ASCII, обычно приводит к повреждению данных).

Помимо литеральных форм, объекты типа bytes можно создать несколькими другими способами:

• Нулевой объект типа bytes заданной длины: bytes(10)
• Из итерируемого объекта целых чисел: bytes(range(20))
• Копирование существующих двоичных данных с помощью протокола буфера: bytes(obj)

См. также встроенную функцию bytes.

Поскольку 2 шестнадцатеричных цифры точно соответствуют одному байту, шестнадцатеричные числа являются часто используемым форматом для описания двоичных данных. Соответственно, тип bytes имеет дополнительный метод класса для чтения данных в этом формате:

classmethod fromhex(string)

Этот метод класса bytes возвращает объект типа bytes, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробелы ASCII игнорируются.

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

Изменено в версии 3.7: bytes.fromhex() теперь пропускает все пробелы ASCII в строке, а не только пробелы.

Существует обратная функция преобразования для преобразования объекта типа bytes в его шестнадцатеричное представление.

hex([sep[, bytes_per_sep]])

Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в экземпляре.

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

Если вы хотите сделать шестнадцатеричную строку более читаемой, вы можете указать параметр sep с одним символом разделителя для включения в выходные данные. По умолчанию между каждым байтом. Второй необязательный параметр bytes_per_sep управляет позицией разделителя. Положительные значения рассчитывают позицию разделителя справа, отрицательные — слева.

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

Добавлена в версии 3.5.

Изменено в версии 3.8: bytes.hex() теперь поддерживает необязательные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричном выводе.

Поскольку объекты типа bytes являются последовательностями целых чисел (аналогично кортежу), для объекта типа bytes b, b[0] будет целым числом, а b[0:1] будет объектом типа bytes длиной 1. (Это контрастирует со строками текста, где как индексирование, так и срезы дадут строку длиной 1)

Представление объектов типа bytes использует формат литерала (b'...'), поскольку он часто более полезен, чем, например, bytes([46, 46, 46]). Вы всегда можете преобразовать объект типа bytes в список целых чисел, используя list(b).

Операции с объектами bytes и bytearray

Объекты bytes и bytearray поддерживают общие операции со последовательностями. Они взаимодействуют не только с операндами того же типа, но и с любым объектом типа bytes. Благодаря этой гибкости, они могут свободно комбинироваться в операциях без вызова ошибок. Однако тип результата может зависеть от порядка операндов.

a = "abc"
b = a.replace("a", "f")

a = b"abc"
b = a.replace(b"a", b"f")

Некоторые операции с bytes и bytearray предполагают использование совместимых с ASCII двоичных форматов и, следовательно, должны быть избегаемы при работе с произвольными двоичными данными. Эти ограничения рассмотрены ниже.

Следующие методы объектов bytes и bytearray могут использоваться с произвольными двоичными данными.

bytes.count(sub[, start[, end]])

bytearray.count(sub[, start[, end]])

Возвращает количество неперекрывающихся вхождений подпоследовательности sub в диапазоне [start, end]. Необязательные аргументы start и end интерпретируются как в обозначении срезов.

Подпоследовательность, которую требуется найти, может быть любым объектом типа bytes или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также принимается целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.removeprefix(prefix, /)

bytearray.removeprefix(prefix, /)

Если двоичные данные начинаются с строки prefix, возвращает bytes[len(prefix):]. В противном случае возвращает копию исходных двоичных данных:

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

Prefix может быть любым объектом типа bytes.

Примечание

Версия этого метода для bytearray не выполняется на месте — она всегда создаёт новый объект, даже если изменений не было.

Введено в версии 3.9.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

Если двоичные данные заканчиваются строкой suffix и suffix не пуст, возвращает bytes[:-len(suffix)]. В противном случае возвращает копию исходных двоичных данных:

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

Suffix может быть любым объектом типа bytes.

Примечание

Версия этого метода для bytearray не выполняется на месте — она всегда создаёт новый объект, даже если изменений не было.

Введено в версии 3.9.

bytes.decode(encoding="utf-8", errors="strict")

bytearray.decode(encoding="utf-8", errors="strict")

Возвращает строку, декодированную из заданных байтов. По умолчанию кодировка — 'utf-8'. errors можно использовать для настройки другой схемы обработки ошибок. По умолчанию errors — 'strict', что означает, что ошибки кодирования генерируют исключение UnicodeError. Другие возможные значения — 'ignore', 'replace' и любые другие имена, зарегистрированные через codecs.register_error(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

По умолчанию аргумент errors не проверяется для повышения производительности, а используется только при первой ошибке декодирования. Включите Режим разработки Python или используйте отладочную сборку для проверки errors.

Примечание

Передача аргумента encoding в str позволяет декодировать любой объект типа bytes напрямую без необходимости создания временного объекта bytes или bytearray.

Изменено в версии 3.1: Добавлена поддержка ключевых аргументов.

Изменено в версии 3.9: Теперь errors проверяется в режиме разработки и в отладочном режиме.

bytes.endswith(suffix[, start[, end]])

bytearray.endswith(suffix[, start[, end]])

Возвращает True если двоичные данные заканчиваются указанным suffix, в противном случае возвращает False. suffix также может быть кортежем суффиксов для поиска. С необязательным start, поиск начинается с этой позиции. С необязательным end, сравнение останавливается на этой позиции.

Суффиксы для поиска могут быть любыми объектами типа bytes.

bytes.find(sub[, start[, end]])

bytearray.find(sub[, start[, end]])

Возвращает наименьший индекс в данных, где найдена подпоследовательность sub, так что sub содержится в срезе s[start:end]. Необязательные аргументы start и end интерпретируются как в обозначении срезов. Возвращает -1 если sub не найдена.

Подпоследовательность, которую требуется найти, может быть любым объектом типа bytes или целым числом в диапазоне от 0 до 255.

Примечание

Метод find() следует использовать только если нужно знать положение sub. Для проверки, является ли sub подстрокой, используйте оператор in:

>>> b'Py' in b'Python'
True

Изменено в версии 3.3: Также принимается целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.index(sub[, start[, end]])

bytearray.index(sub[, start[, end]])

Аналогично find(), но вызывает ValueError, если подпоследовательность не найдена.

Подпоследовательность, которую требуется найти, может быть любым объектом типа bytes или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также принимается целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.join(iterable)

bytearray.join(iterable)

Возвращает объект bytes или bytearray, являющийся конкатенацией последовательностей двоичных данных в iterable. Будет выведено исключение TypeError, если в iterable есть какие-либо значения, которые не являются объектами типа bytes, включая объекты str. Разделитель между элементами — содержимое объекта bytes или bytearray, предоставляющего этот метод.

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

Этот статический метод возвращает таблицу преобразования, пригодную для bytes.translate(), которая сопоставляет каждый символ в from с символом в том же положении в to; from и to должны быть объектами типа bytes и иметь одинаковую длину.

Введено в версии 3.1.

bytes.partition(sep)

bytearray.partition(sep)

Разделяет последовательность на первом вхождении sep и возвращает кортеж из 3 элементов, содержащий часть перед разделителем, сам разделитель или его копию bytearray, и часть после разделителя. Если разделитель не найден, возвращает кортеж из 3 элементов, содержащий копию исходной последовательности, за которым следуют два пустых объекта bytes или bytearray.

Разделитель для поиска может быть любым объектом типа bytes.

bytes.replace(old, new[, count])

bytearray.replace(old, new[, count])

Возвращает копию последовательности, в которой все вхождения подпоследовательности old заменены на new. Если необязательный аргумент count задан, заменяются только первые count вхождений.

Подпоследовательность для поиска и её замена могут быть любым объектом-подобным байтам.

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.rfind(sub[, start[, end]])

bytearray.rfind(sub[, start[, end]])

Возвращает наибольший индекс в последовательности, где найдена подпоследовательность sub, такая что sub содержится в s[start:end]. Необязательные аргументы start и end интерпретируются так же, как в нотации срезов. При неудаче возвращает -1.

Подпоследовательность для поиска может быть любым объектом-подобным байтам или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также принимает целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.rindex(sub[, start[, end]])

bytearray.rindex(sub[, start[, end]])

Подобно rfind(), но вызывает исключение ValueError, когда подпоследовательность sub не найдена.

Подпоследовательность для поиска может быть любым объектом-подобным байтам или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также принимает целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.rpartition(sep)

bytearray.rpartition(sep)

Разделяет последовательность по последнему вхождению sep и возвращает кортеж из 3 элементов: часть перед разделителем, сам разделитель (или его копия bytearray), и часть после разделителя. Если разделитель не найден, возвращает кортеж из двух пустых объектов bytes или bytearray, после которого следует копия исходной последовательности.

Разделитель для поиска может быть любым объектом-подобным байтам.

bytes.startswith(prefix[, start[, end]])

bytearray.startswith(prefix[, start[, end]])

Возвращает True, если бинарные данные начинаются с указанного префикса prefix, в противном случае возвращает False. prefix также может быть кортежем префиксов для поиска. С необязательным start, поиск начинается с этой позиции. С необязательным end, сравнение останавливается на этой позиции.

Префикс(ы) для поиска могут быть любыми объектами-подобными байтам.

bytes.translate(table, /, delete=b'')

bytearray.translate(table, /, delete=b'')

Возвращает копию объекта bytes или bytearray, где все байты, присутствующие в необязательном аргументе delete, удалены, а оставшиеся байты были отображены через заданную таблицу преобразования, которая должна быть объектом bytes длиной 256.

Вы можете использовать метод bytes.maketrans() для создания таблицы преобразования.

Установите аргумент table в None, для переводов, которые только удаляют символы:

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

Изменено в версии 3.6: delete теперь поддерживается в качестве ключевого аргумента.

Следующие методы для объектов bytes и bytearray имеют по умолчанию поведение, предполагающее использование ASCII-совместимых бинарных форматов, но их можно использовать и с произвольными бинарными данными, передавая соответствующие аргументы. Обратите внимание, что все методы bytearray в этом разделе не работают на месте, а вместо этого производят новые объекты.

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

Возвращает копию объекта, центрированную в последовательности длиной width. Заполнение выполняется с использованием указанного fillbyte (по умолчанию — ASCII-пробел). Для объектов bytes, исходная последовательность возвращается, если width меньше или равно len(s).

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

Возвращает копию объекта, выровненного по левому краю в последовательности длиной width. Заполнение выполняется с использованием указанного fillbyte (по умолчанию — ASCII-пробел). Для объектов bytes, исходная последовательность возвращается, если width меньше или равно len(s).

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.lstrip([chars])

bytearray.lstrip([chars])

Возвращает копию последовательности с удаленными указанными начальными байтами. Аргумент chars — бинарная последовательность, определяющая набор значений байтов для удаления — имя указывает на то, что этот метод обычно используется с ASCII-символами. Если опущен или None, аргумент chars по умолчанию удаляет ASCII-пробелы. Аргумент chars не является префиксом; вместо этого удаляются все комбинации его значений:

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

Бинарная последовательность значений байтов для удаления может быть любым объектом-подобным байтам. См. removeprefix() для метода, который удалит одну строку-префикс, а не все символы набора. Например:

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

Возвращает копию объекта, выровненного по правому краю в последовательности длиной width. Заполнение выполняется с использованием указанного fillbyte (по умолчанию — ASCII-пробел). Для объектов bytes, исходная последовательность возвращается, если width меньше или равно len(s).

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.rsplit(sep=None, maxsplit=-1)

bytearray.rsplit(sep=None, maxsplit=-1)

Разделяет бинарную последовательность на подпоследовательности того же типа, используя sep в качестве разделителя. Если задан maxsplit, выполняется не более maxsplit разделений, начиная с правого. Если sep не указан или None, любая подпоследовательность, состоящая только из ASCII-пробелов, является разделителем. За исключением разделения справа, rsplit() ведет себя как split(), которое описано подробно ниже.

bytes.rstrip([chars])

bytearray.rstrip([chars])

Возвращает копию последовательности с удаленными указанными конечными байтами. Аргумент chars — бинарная последовательность, определяющая набор значений байтов для удаления — имя указывает на то, что этот метод обычно используется с ASCII-символами. Если опущен или None, аргумент chars по умолчанию удаляет ASCII-пробелы. Аргумент chars не является суффиксом; вместо этого удаляются все комбинации его значений:

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

Бинарная последовательность значений байтов для удаления может быть любым объектом-подобным байтам. См. removesuffix() для метода, который удалит одну строку-суффикс, а не все символы набора. Например:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не было.

bytes.split(sep=None, maxsplit=-1)

bytearray.split(sep=None, maxsplit=-1)

Разделить бинарную последовательность на подпоследовательности того же типа, используя sep в качестве разделительной строки. Если maxsplit задан и неотрицателен, выполняется не более maxsplit разбиений (следовательно, список будет содержать не более maxsplit+1 элементов). Если maxsplit не указан или равен -1, то количество разбиений не ограничено (выполняются все возможные разбиения).

Если задан sep, последовательные разделители не группируются вместе и считаются разделителями пустых подпоследовательностей (например, b'1,,2'.split(b',') возвращает [b'1', b'', b'2']). Аргумент sep может состоять из многобайтовой последовательности (например, b'1<>2<>3'.split(b'<>') возвращает [b'1', b'2', b'3']). Разбиение пустой последовательности с указанным разделителем возвращает [b''] или [bytearray(b'')] в зависимости от типа разделяемого объекта. Аргумент sep может быть любым объектом типа bytes-like object.

Например:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

Если sep не указан или равен None, применяется другой алгоритм разбиения: последовательности из последовательных ASCII-пробелов рассматриваются как один разделитель, и результат не будет содержать пустых строк в начале или конце, если последовательность имеет ведущие или завершающие пробелы. Следовательно, разбиение пустой последовательности или последовательности, состоящей только из ASCII-пробелов без указанного разделителя, возвращает [].

Например:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip([chars])

bytearray.strip([chars])

Возвращает копию последовательности с удаленными указанными ведущими и завершающими байтами. Аргумент chars представляет собой бинарную последовательность, указывающую множество значений байтов, которые нужно удалить — название связано с тем, что этот метод обычно используется с символами ASCII. Если он опущен или None, аргумент chars по умолчанию удаляет ASCII-пробелы. Аргумент chars не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

Бинарная последовательность значений байтов для удаления может быть любым объектом типа bytes-like object.

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создает новый объект, даже если изменений не было.

В следующих методах для объектов bytes и bytearray предполагается использование совместимых с ASCII бинарных форматов, и их не следует применять к произвольным бинарным данным. Обратите внимание, что все методы bytearray в этом разделе не работают на месте и вместо этого создают новые объекты.

bytes.capitalize()

bytearray.capitalize()

Возвращает копию последовательности, в которой каждый байт интерпретируется как символ ASCII, а первый байт — в верхнем регистре, а остальные — в нижнем. Не-ASCII значения байтов передаются без изменений.

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создает новый объект, даже если изменений не было.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

Возвращает копию последовательности, в которой все символы ASCII-табуляции заменяются одним или несколькими символами ASCII-пробела в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции встречаются каждые tabsize байтов (по умолчанию 8, что дает позиции табуляции в столбцах 0, 8, 16 и так далее). Для расширения последовательности текущая колонка устанавливается в ноль, и последовательность проверяется байт за байтом. Если байт является символом ASCII-табуляции (b'\t'), в результате вставляется один или несколько символов пробела, пока текущая колонка не станет равной следующей позиции табуляции. (Сам символ табуляции не копируется.) Если текущий байт является символом ASCII-перевода строки (b'\n') или возврата каретки (b'\r'), он копируется, а текущая колонка сбрасывается в ноль. Любое другое значение байта копируется без изменений, и текущая колонка увеличивается на один независимо от того, как значение байта представлено при печати:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создает новый объект, даже если изменений не было.

bytes.isalnum()

bytearray.isalnum()

Возвращает True, если все байты в последовательности являются алфавитными символами ASCII или десятичными цифрами ASCII, и последовательность не пуста, False в противном случае. Алфавитные символы ASCII — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. Десятичные цифры ASCII — это те значения байтов в последовательности b'0123456789'.

Например:

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()

bytearray.isalpha()

Возвращает True, если все байты в последовательности являются алфавитными символами ASCII, и последовательность не пуста, False в противном случае. Алфавитные символы ASCII — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Например:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()

bytearray.isascii()

Возвращает True, если последовательность пуста или все байты в последовательности являются ASCII, False в противном случае. Байты ASCII находятся в диапазоне 0-0x7F.

Новое в версии 3.7.

bytes.isdigit()

bytearray.isdigit()

Возвращает True, если все байты в последовательности являются десятичными цифрами ASCII, и последовательность не пуста, False в противном случае. Десятичные цифры ASCII — это те значения байтов в последовательности b'0123456789'.

Например:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()

bytearray.islower()

Возвращает True, если в последовательности есть хотя бы один строчный символ ASCII и нет прописных символов ASCII, False в противном случае.

Например:

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

Строчные символы ASCII — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Прописные символы ASCII — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.isspace()

bytearray.isspace()

Возвращает True, если все байты в последовательности являются ASCII-пробелами, и последовательность не пуста, False в противном случае. Символы ASCII-пробела — это те значения байтов в последовательности b' \t\n\r\x0b\f' (пробел, табуляция, перевод строки, возврат каретки, вертикальная табуляция, перевод страницы).

bytes.istitle()

bytearray.istitle()

Возвращает True, если последовательность является заголовком ASCII, и последовательность не пуста, False в противном случае. См. bytes.title() для получения более подробной информации об определении «заголовка».

Например:

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()

bytearray.isupper()

Возвращает True, если в последовательности есть хотя бы один прописной алфавитный символ ASCII и нет строчных символов ASCII, False в противном случае.

Например:

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

Строчные символы ASCII — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Прописные символы ASCII — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.lower()

bytearray.lower()

Возвращает копию последовательности со всеми прописными символами ASCII, преобразованными в соответствующие строчные символы.

Например:

>>> b'Hello World'.lower()
b'hello world'

Строчные символы ASCII — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Прописные символы ASCII — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Примечание

Версия этого метода для bytearray не работает на месте — она всегда создает новый объект, даже если изменений не было.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

Возвращает список строк в бинарной последовательности, разбивая их на границах строк ASCII. Этот метод использует подход universal newlines для разбиения строк. Разрывы строк не включаются в результирующий список, если только keepends не задан и не имеет значение true.

Например:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

В отличие от split(), когда задана разделительная строка sep, этот метод возвращает пустой список для пустой строки, и конечный разрыв строки не приводит к дополнительной строке:

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()

bytearray.swapcase()

Возвращает копию последовательности, в которой все строчные ASCII-символы преобразованы в соответствующие заглавные и наоборот.

Например:

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

Строчные ASCII-символы — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Заглавные ASCII-символы — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

В отличие от str.swapcase(), для бинарных версий всегда верно, что bin.swapcase().swapcase() == bin. Преобразования регистра в ASCII симметричны, хотя это не всегда верно для произвольных кодовых точек Юникода.

Примечание

Версия метода bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не произошло.

bytes.title()

bytearray.title()

Возвращает версию последовательности в стиле заголовка, где слова начинаются с заглавной ASCII-буквы, а оставшиеся символы — строчные. Небуквенные значения байтов остаются неизменными.

Например:

>>> b'Hello world'.title()
b'Hello World'

Строчные ASCII-символы — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Заглавные ASCII-символы — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Все остальные значения байтов не изменяются.

Алгоритм использует простое, независимое от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но это означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может не быть желаемым результатом:

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

Обходной путь для апострофов может быть построен с использованием регулярных выражений:

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends."

Примечание

Версия метода bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не произошло.

bytes.upper()

bytearray.upper()

Возвращает копию последовательности, в которой все строчные ASCII-символы преобразованы в соответствующие заглавные.

Например:

>>> b'Hello World'.upper()
b'HELLO WORLD'

Строчные ASCII-символы — это те значения байтов в последовательности b'abcdefghijklmnopqrstuvwxyz'. Заглавные ASCII-символы — это те значения байтов в последовательности b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Примечание

Версия метода bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не произошло.

bytes.zfill(width)

bytearray.zfill(width)

Возвращает копию последовательности, заполненную слева ASCII b'0' цифрами, чтобы получить последовательность длиной width. Предшествующий знак префикс (b'+'/ b'-') обрабатывается вставкой заполнения после символа знака, а не перед ним. Для объектов bytes исходная последовательность возвращается, если width меньше или равно len(seq).

Например:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

Примечание

Версия метода bytearray не работает на месте — она всегда создаёт новый объект, даже если изменений не произошло.

printf-форматирование байтов

Объекты байтов (bytes/bytearray) имеют одну уникальную встроенную операцию: оператор % (modulo). Это также известно как оператор форматирования или интерполяции байтов. Учитывая format % values (где формат — объект байтов), спецификации преобразования % в формате заменяются нулём или более элементами из значений. Эффект аналогичен использованию оператора sprintf() в языке C.

Если формат требует одного аргумента, значения может быть одним объектом, не являющимся кортежем. 5 В противном случае значения должны быть кортежем с ровно таким количеством элементов, которое указано объектом байтов формата, или одним объектом отображения (например, словарем).

Спецификатор преобразования содержит два или более символов и состоит из следующих компонентов, которые должны следовать в этом порядке:

1. Символ '%', который отмечает начало спецификатора.
2. Ключ отображения (необязательный), представляющий собой заключённую в скобки последовательность символов (например, (somename)).
3. Флаги преобразования (необязательные), которые влияют на результат некоторых типов преобразования.
4. Минимальная ширина поля (необязательная). Если она указана как '*' (звёздочка), фактическая ширина считывается из следующего элемента кортежа в значениях, а преобразуемый объект следует за минимальной шириной поля и необязательной точностью.
5. Точность (необязательная), заданная как '.' (точка) и точностью. Если она указана как '*' (звёздочка), фактическая точность считывается из следующего элемента кортежа в значениях, а преобразуемое значение следует за точностью.
6. Модификатор длины (необязательный).
7. Тип преобразования.

Когда правым аргументом является словарь (или другой тип отображения), форматы в объекте байтов должны включать ключ отображения в этот словарь, вставленный непосредственно после символа '%'. Ключ отображения выбирает значение, которое будет форматироваться из отображения. Например:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

В этом случае в формате не может быть спецификаторов * (поскольку они требуют последовательного списка параметров).

Символы флагов преобразования:

Модификатор длины (h, l, или L) может быть присутствовать, но игнорируется, поскольку он не нужен для Python — например, %ld идентичен %d.

Типы преобразования:

Примечания:

1. Альтернативная форма вставляет префикс «0o» перед первой цифрой.
2. Альтернативная форма вставляет префикс «0x» или «0X» (в зависимости от того, использовался ли формат 'x' или 'X') перед первой цифрой.

3. Альтернативная форма гарантирует наличие десятичной точки в результате, даже если за ней не следуют цифры.

   Точность определяет количество цифр после десятичной точки и по умолчанию равна 6.

4. Альтернативная форма гарантирует наличие десятичной точки в результате, и хвостовые нули не удаляются, как это обычно происходит.

   Точность определяет количество значащих цифр до и после десятичной точки и по умолчанию равна 6.

5. Если точность равна N, вывод усекается до N символов.
6. b'%s' устарел, но не будет удалён в серии 3.x.
7. b'%r' устарел, но не будет удалён в серии 3.x.
8. См. PEP 237.

Представления памяти

memoryview объекты позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего протокол буфера buffer, без копирования.

class memoryview(object)

Создать memoryview, ссылающийся на object. object должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают bytes и bytearray.

У memoryview есть понятие элемента, являющегося атомной единицей памяти, обрабатываемой исходным объектом. Для многих простых типов, таких как bytes и bytearray, элемент — это один байт, но другие типы, такие как array.array, могут иметь элементы большего размера.

len(view) равно длине tolist. Если view.ndim = 0, длина равна 1. Если view.ndim = 1, длина равна количеству элементов в представлении. Для многомерных представлений длина равна длине вложенного списка представления.

Атрибут itemsize даст вам количество байтов в одном элементе.

memoryview поддерживает срезы и индексирование для доступа к данным. Срез одномерного представления приведет к представлению подчасти:

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

Если format является одним из нативных спецификаторов формата из модуля struct, индексирование целым числом или кортежем целых чисел также поддерживается и возвращает один элемент с соответствующим типом. Одномерные представления памяти могут быть индексированы целым числом или кортежем из одного целого числа. Многомерные представления памяти могут быть индексированы кортежами ровно ndim целых чисел, где ndim — количество измерений. Нулевые представления памяти могут быть индексированы пустым кортежем.

Вот пример с небайтовым форматом:

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

Если базовый объект изменяем, представление памяти поддерживает присваивание срезам одномерного вида. Изменение размера недопустимо:

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

Одномерные представления памяти для хешируемых (только для чтения) типов с форматами ‘B’, ‘b’ или ‘c’ также хешируемы. Хеш определяется как hash(m) == hash(m.tobytes()):

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

Изменено в версии 3.3: Одномерные представления памяти теперь могут быть срезами. Одномерные представления памяти с форматами ‘B’, ‘b’ или ‘c’ теперь хешируемы.

Изменено в версии 3.4: Представление памяти теперь автоматически регистрируется в collections.abc.Sequence

Изменено в версии 3.5: Теперь представления памяти могут быть индексированы кортежами целых чисел.

memoryview имеет несколько методов:

__eq__(exporter)

Представление памяти и экспортер PEP 3118 равны, если их формы эквивалентны, и если все соответствующие значения равны, когда соответствующие коды формата операндов интерпретируются с использованием синтаксиса struct.

Для подмножества строк формата struct, в настоящее время поддерживаемых tolist(), v и w равны, если v.tolist() == w.tolist():

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

Если ни одна из строк формата не поддерживается модулем struct, то объекты всегда будут считаться неравными (даже если строки форматов и содержимое буфера идентичны):

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

Обратите внимание, что, как и с числами с плавающей точкой, v is w не подразумевает v == w для объектов представления памяти.

Изменено в версии 3.3: Предыдущие версии сравнивали исходную память, не учитывая формат элемента и логическую структуру массива.

tobytes(order=None)

Возвращает данные в буфере в виде строки байтов. Это эквивалентно вызову конструктора bytes для представления памяти.

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

Для несмежных массивов результат равен уплощенному представлению списка со всеми элементами, преобразованными в байты. tobytes() поддерживает все строки форматов, включая те, которые не находятся в синтаксисе модуля struct.

Новое в версии 3.8: order может быть {‘C’, ‘F’, ‘A’}. Когда order равен ‘C’ или ‘F’, данные исходного массива преобразуются в порядок C или Fortran. Для смежных представлений ‘A’ возвращает точную копию физической памяти. В частности, сохраняется порядок Fortran в памяти. Для несмежных представлений данные сначала преобразуются в порядок C. order=None эквивалентно order=’C’.

hex([sep[, bytes_per_sep]])

Возвращает строку, содержащую две шестнадцатеричные цифры для каждого байта в буфере.

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

Новое в версии 3.5.

Изменено в версии 3.8: Аналогично bytes.hex(), memoryview.hex() теперь поддерживает необязательные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричном выводе.

tolist()

Возвращает данные в буфере в виде списка элементов.

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

Изменено в версии 3.3: tolist() теперь поддерживает все нативные форматы с одиночными символами в синтаксисе модуля struct, а также многомерные представления.

toreadonly()

Возвращает представление памяти только для чтения. Исходное представление памяти не изменяется.

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

Новое в версии 3.8.

release()

Освободить базовый буфер, представленный объектом представления памяти. Многие объекты выполняют особые действия при удерживании представления (например, bytearray временно запретит изменение размера); поэтому вызов release() полезен для снятия этих ограничений (и освобождения любых висячих ресурсов) как можно скорее.

После вызова этого метода любая дальнейшая операция с представлением вызывает ValueError (кроме release() самого, которое можно вызвать несколько раз):

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

Для аналогичного эффекта можно использовать протокол управления контекстом, используя инструкцию with:

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

Новое в версии 3.2.

cast(format[, shape])

Преобразовать представление памяти в новый формат или форму. shape по умолчанию [byte_length//new_itemsize], что означает, что результирующее представление будет одномерным. Возвращаемое значение — новое представление памяти, но сам буфер не копируется. Поддерживаемые преобразования: 1D -> C-смежный и C-смежный -> 1D.

Формат назначения ограничен единственным нативным форматом элемента в синтаксисе модуля struct. Один из форматов должен быть байтовым форматом (‘B’, ‘b’ или ‘c’). Длина байтов результата должна быть такой же, как и исходная длина.

Преобразование 1D/long в 1D/unsigned bytes:

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

Преобразование 1D/unsigned bytes в 1D/char:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

Преобразование 1D/bytes в 3D/ints в 1D/signed char:

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

Преобразование 1D/unsigned long в 2D/unsigned long:

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

Новое в версии 3.3.

Изменено в версии 3.5: Исходный формат больше не ограничен при преобразовании в байтовое представление.

Также доступны несколько атрибутов только для чтения:

obj

Базовый объект представления памяти:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

Новое в версии 3.3.

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()). Это количество байтов, которое массив занимал бы в непрерывном представлении. Оно не обязательно равно len(m):

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

Многомерные массивы:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

Введено в версии 3.3.

readonly

Булево значение, указывающее, является ли память только для чтения.

format

Строка, содержащая формат (в стиле модуля struct) для каждого элемента в представлении. Представление памяти может быть создано из экспортеров с произвольными строками формата, но некоторые методы (например, tolist()) ограничены нативными форматами с одним элементом.

Изменено в версии 3.3: формат 'B' теперь обрабатывается в соответствии с синтаксисом модуля struct. Это означает, что memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize

Размер в байтах каждого элемента представления памяти:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim

Целое число, указывающее количество измерений многомерного массива, представленного памятью.

shape

Кортеж целых чисел длиной ndim, задающий форму памяти как N-мерного массива.

Изменено в версии 3.3: Пустой кортеж вместо None при ndim = 0.

strides

Кортеж целых чисел длиной ndim, задающий размер в байтах для доступа к каждому элементу для каждого измерения массива.

Изменено в версии 3.3: Пустой кортеж вместо None при ndim = 0.

suboffsets

Используется внутри для массивов в стиле PIL. Значение только информативное.

c_contiguous

Булево значение, указывающее, является ли память C-непрерывной.

Введено в версии 3.3.

f_contiguous

Булево значение, указывающее, является ли память Fortran непрерывной.

Введено в версии 3.3.

contiguous

Булево значение, указывающее, является ли память непрерывной.

Введено в версии 3.3.

Объекты представления словаря

Объекты, возвращаемые dict.keys(), dict.values() и dict.items(), являются объектами представления. Они предоставляют динамическое представление записей словаря, что означает, что при изменении словаря представление отражает эти изменения.

Объекты представления словаря можно перебирать, чтобы получить соответствующие данные, и они поддерживают проверки на вхождение:

len(dictview)

Возвращает количество записей в словаре.

iter(dictview)

Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей из (key, value)) в словаре.

Ключи и значения перебираются в порядке вставки. Это позволяет создавать (value, key) пары с помощью zip(): pairs = zip(d.values(), d.keys()). Другой способ создать тот же список — pairs = [(v, k) for (k, v) in d.items()].

Перебор представлений при добавлении или удалении записей в словаре может вызвать RuntimeError или не перебрать все записи.

Изменено в версии 3.7: Порядок словаря гарантируется в порядке вставки.

x in dictview

Возвращает True , если x содержится в ключах, значениях или элементах (в последнем случае x должен быть (key, value) кортежем) базового словаря.

reversed(dictview)

Возвращает обратный итератор по ключам, значениям или элементам словаря. Представление будет перебираться в обратном порядке вставки.

Изменено в версии 3.8: Представления словаря теперь обратимы.

Представления ключей похожи на множества, так как их записи уникальны и хешируемы. Если все значения хешируемы, так что (key, value) пары уникальны и хешируемы, то представление элементов также похоже на множество. (Представления значений не рассматриваются как множества, поскольку записи, как правило, не уникальны.) Для представлений, похожих на множества, доступны все операции, определенные для абстрактного базового класса collections.abc.Set (например, ==, <, или ^).

Пример использования представления словаря:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

Стандартные обобщённые классы

Следующие стандартные классы библиотеки поддерживают параметризованные обобщения. Этот список неполный.

• tuple
• list
• dict
• set
• frozenset
• type
• collections.deque
• collections.defaultdict
• collections.OrderedDict
• collections.Counter
• collections.ChainMap
• collections.abc.Awaitable
• collections.abc.Coroutine
• collections.abc.AsyncIterable
• collections.abc.AsyncIterator
• collections.abc.AsyncGenerator
• collections.abc.Iterable
• collections.abc.Iterator
• collections.abc.Generator
• collections.abc.Reversible
• collections.abc.Container
• collections.abc.Collection
• collections.abc.Callable
• collections.abc.Set
• collections.abc.MutableSet
• collections.abc.Mapping
• collections.abc.MutableMapping
• collections.abc.Sequence
• collections.abc.MutableSequence
• collections.abc.ByteString
• collections.abc.MappingView
• collections.abc.KeysView
• collections.abc.ItemsView
• collections.abc.ValuesView
• contextlib.AbstractContextManager
• contextlib.AbstractAsyncContextManager
• dataclasses.Field
• functools.cached_property
• functools.partialmethod
• os.PathLike
• queue.LifoQueue
• queue.Queue
• queue.PriorityQueue
• queue.SimpleQueue
• re.Pattern
• re.Match
• shelve.BsdDbShelf
• shelve.DbfilenameShelf
• shelve.Shelf
• types.MappingProxyType
• weakref.WeakKeyDictionary
• weakref.WeakMethod
• weakref.WeakSet
• weakref.WeakValueDictionary

Специальные атрибуты объектов GenericAlias

Все параметризованные обобщения реализуют специальные атрибуты только для чтения.

genericalias.__origin__

Этот атрибут указывает на неопределенный обобщённый класс:

>>> list[int].__origin__
<class 'list'>

genericalias.__args__

Этот атрибут — это tuple (возможно, длиной 1) типов обобщений, переданных в исходный __class_getitem__() обобщенного класса:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__

Этот атрибут — вычисляемый кортеж (возможно, пустой) уникальных переменных типов, встречающихся в __args__:

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

Модули

Единственная специальная операция над модулем — доступ к атрибутам: m.name, где m — модуль, а name обращается к имени, определённому в таблице символов m. Атрибуты модулей можно присваивать. (Обратите внимание, что оператор import строго говоря, не является операцией над объектом модуля; import foo не требует существования объекта модуля foo, а требует (внешнего) определения модуля foo где-то.)

Специальный атрибут каждого модуля — __dict__. Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически изменит таблицу символов модуля, но прямое присваивание атрибуту __dict__ невозможно (можно записать m.__dict__['a'] = 1, что определяет m.a как 1, но нельзя записать m.__dict__ = {}). Изменение __dict__ напрямую не рекомендуется.

Модули, встроенные в интерпретатор, записываются так: <module 'sys' (built-in)>. Если они загружаются из файла, они записываются как <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>.

Классы и экземпляры классов

См. Объекты, значения и типы и Определения классов для этих сведений.

Функции

Объекты функций создаются с помощью определений функций. Единственная операция над объектом функции — это вызов: func(argument-list).

На самом деле есть два типа объектов функций: встроенные функции и функции, определённые пользователем. Обе поддерживают одну и ту же операцию (вызов функции), но реализация отличается, поэтому и типы объектов разные.

См. Определения функций для получения дополнительной информации.

Методы

Методы — это функции, которые вызываются с помощью обозначения атрибутов. Есть два типа: встроенные методы (например, append() для списков) и методы экземпляров классов. Встроенные методы описываются с типами, которые их поддерживают.

Если вы обращаетесь к методу (функции, определённой в пространстве имён класса), через экземпляр, вы получаете специальный объект: объект связанного метода (также называемый методом экземпляра). При вызове он добавит аргумент self в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: m.__self__ — объект, над которым работает метод, и m.__func__ — функция, реализующая метод. Вызов m(arg-1, arg-2, ..., arg-n) полностью эквивалентен вызову m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Как и объекты функций, объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты методов фактически хранятся в базовой функции (meth.__func__), установка атрибутов методов для связанных методов запрещена. Попытка установить атрибут для метода приводит к тому, что генерируется исключение AttributeError. Чтобы установить атрибут метода, необходимо явно установить его в базовой функции:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

См. Стандартная иерархия типов для получения дополнительной информации.

Объекты кода

Объекты кода используются реализацией для представления «псевдоскомпилированного» исполняемого Python-кода, например, тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на свою глобальную среду выполнения. Объекты кода возвращаются встроенной функцией compile() и могут быть извлечены из объектов функций через атрибут __code__. См. также модуль code.

Обращение к __code__ вызывает событие аудита аудита object.__getattr__ с аргументами obj и "__code__".

Объект кода можно выполнить или оценить, передав его (вместо строки исходного кода) встроенным функциям exec() или eval().

См. Стандартную иерархию типов для получения дополнительной информации.

Объекты типов

Объекты типов представляют различные типы объектов. Тип объекта можно получить с помощью встроенной функции type(). Нет специальных операций над типами. Стандартный модуль types определяет имена всех стандартных встроенных типов.

Типы записываются так: <class 'int'>.

Объект null

Этот объект возвращается функциями, которые не явно не возвращают значения. Он не поддерживает никаких специальных операций. Существует ровно один объект null, названный None (встроенное имя). type(None)() производит тот же синглтон.

Он записывается как None.

Объект Ellipsis

Этот объект часто используется при срезах (см. Срезы). Он не поддерживает никаких специальных операций. Существует ровно один объект Ellipsis, названный Ellipsis (встроенное имя). type(Ellipsis)() производит синглтон Ellipsis.

Он записывается как Ellipsis или ....

Объект NotImplemented

Этот объект возвращается из сравнений и бинарных операций, когда они запрошены для работы с типами, которые они не поддерживают. См. Сравнения для получения дополнительной информации. Существует ровно один объект NotImplemented. type(NotImplemented)() производит экземпляр синглтона.

Он записывается как NotImplemented.

Булевы значения

Булевы значения — это два константных объекта False и True . Они используются для представления значений истинности (хотя и другие значения могут рассматриваться как ложные или истинные). В числовых контекстах (например, когда они используются в качестве аргумента арифметического оператора) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция bool() может использоваться для преобразования любого значения в булево, если значение может быть интерпретировано как значение истинности (см. раздел Проверка истинности выше).

Они записываются как False и True соответственно.

Внутренние объекты

См. Стандартную иерархию типов для получения этой информации. Она описывает объекты стековой рамки, объекты отслеживания исключений и объекты срезов.

Затронутые API

Ограничение применяется только к потенциально медленным преобразованиям между int и str или bytes:

• int(string) с основанием по умолчанию 10.
• int(string, base) для всех оснований, которые не являются степенью двойки.
• str(integer).
• repr(integer)
• любое другое преобразование строки в десятичную систему счисления, например f"{integer}", "{}".format(integer), или b"%d" % integer.

Ограничения не применяются к функциям с линейным алгоритмом:

• int(string, base) с основанием 2, 4, 8, 16 или 32.
• int.from_bytes() и int.to_bytes().
• hex(), oct(), bin().
• Форматное мини-язык для шестнадцатеричных, восьмеричных и двоичных чисел.
• str в float.
• str в decimal.Decimal.

Настройка ограничения

Перед запуском Python вы можете использовать переменную среды или флаг командной строки интерпретатора для настройки ограничения:

• PYTHONINTMAXSTRDIGITS, например PYTHONINTMAXSTRDIGITS=640 python3 для установки ограничения на 640 или PYTHONINTMAXSTRDIGITS=0 python3 для отключения ограничения.
• -X int_max_str_digits, например python3 -X int_max_str_digits=640
• sys.flags.int_max_str_digits содержит значение PYTHONINTMAXSTRDIGITS или -X int_max_str_digits. Если обе переменные среды и флаг -X установлены, приоритет имеет флаг -X . Значение -1 указывает, что обе переменные не установлены, поэтому при инициализации использовалось значение sys.int_info.default_max_str_digits.

Из кода вы можете просмотреть текущее ограничение и установить новое с помощью этих sys API:

• sys.get_int_max_str_digits() и sys.set_int_max_str_digits() являются методом получения и установки интерпретаторского ограничения. Подинтерпретаторы имеют своё собственное ограничение.

Информация о значении по умолчанию и минимальном значении находится в sys.int_info:

• sys.int_info.default_max_str_digits — это ограничение по умолчанию, заданное при компиляции.
• sys.int_info.str_digits_check_threshold — это минимально допустимое значение ограничения (кроме 0, которое отключает его).

Рекомендуемая конфигурация

Значение по умолчанию sys.int_info.default_max_str_digits должно быть приемлемым для большинства приложений. Если вашему приложению требуется другое ограничение, установите его из основной точки входа, используя код, независимый от версии Python, так как эти API были добавлены в исправления безопасности в версиях до 3.11.

Пример:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

Если вам нужно полностью отключить ограничение, установите его в значение 0.

Примечания

1

Дополнительная информация об этих специальных методах может быть найдена в Справке по Python (Основные настройки).

2

Следовательно, список [1, 2] считается равным [1.0, 2.0], и аналогично для кортежей.

3

Они должны быть такими, так как анализатор не может определить тип операндов.

4(1,2,3,4)

Символы с регистром — это те, у которых свойство общей категории является одной из «Lu» (Буква, заглавная), «Ll» (Буква, строчная) или «Lt» (Буква, строчная с заглавной).

5(1,2)

Для форматирования только кортежа необходимо предоставить одиночный кортеж, единственным элементом которого является кортеж, подлежащий форматированию.