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

В следующих разделах описываются стандартные типы, встроенные в интерпретатор.

Основные встроенные типы — это числовые типы, последовательности, отображения, классы, экземпляры и исключения.

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

Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать, проверять на истинность и преобразовывать в строку (с помощью функции repr() или немного отличающейся функции str()). Последняя функция используется неявно, когда объект выводится функцией print().

1. Проверка на истинность

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

• None
• False
• ноль любого числового типа, например, 0, 0.0, 0j.
• любая пустая последовательность, например, '', (), [].
• любое пустое отображение, например, {}.
• экземпляры классов, определённых пользователем, если класс определяет метод __bool__() или __len__(), когда этот метод возвращает целое число ноль или значение bool False. [1]

Все остальные значения считаются истинными — так что объекты многих типов всегда истинны.

Операции и встроенные функции, которые имеют логический результат, всегда возвращают 0 или False для ложного значения и 1 или True для истинного, если не указано иное. (Важное исключение: логические операции or и and всегда возвращают один из своих операндов.)

2. Логические операции — and, or, not

Это логические операции, упорядоченные по возрастанию приоритета:

Примечания:

1. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент только если первый ложный.
2. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент только если первый истинный.
3. not имеет более низкий приоритет, чем операции, не являющиеся логическими, поэтому not a == b интерпретируется как not (a == b), а a == not b является синтаксической ошибкой.

3. Сравнения

В Python восемь операций сравнения. У всех одинаковый приоритет (который выше, чем у логических операций). Сравнения можно цеплять произвольно; например, x < y <= z эквивалентно x < y and y <= z, за исключением того, что y вычисляется только один раз (но в обоих случаях z не вычисляется вообще, когда x < y оказывается ложным).

В этой таблице обобщены операции сравнения:

Объекты разных типов, за исключением разных числовых типов, никогда не сравниваются как равные. Кроме того, некоторые типы (например, объекты функций) поддерживают только вырожденное понятие сравнения, где любые два объекта этого типа не равны. Операторы <, <=, > и >= вызовут исключение TypeError при сравнении комплексного числа с другим встроенным числовым типом, когда объекты имеют разные типы, которые нельзя сравнить, или в других случаях, когда нет определённого порядка.

Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет метод __eq__().

Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или другим типам объектов, если класс не определяет достаточное количество методов __lt__(), __le__(), __gt__() и __ge__() (в общем случае, __lt__() и __eq__() достаточно, если вы хотите стандартные значения операторов сравнения).

Поведение операторов is и is not нельзя настроить; они также могут применяться к любым двум объектам и никогда не вызывают исключения.

Ещё две операции с тем же синтаксическим приоритетом, in и not in, поддерживаются только типами последовательностей (ниже).

4. Числовые типы — int, float, complex

Существует три различных числовых типа: целые числа, числа с плавающей точкой и комплексные числа. Кроме того, булевы значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с использованием double в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется ваша программа, доступна в sys.float_info. Комплексные числа имеют действительную и мнимую части, каждая из которых — число с плавающей точкой. Чтобы извлечь эти части из комплексного числа z, используйте z.real и z.imag. (Стандартная библиотека включает дополнительные числовые типы, fractions, которые хранят рациональные числа, и decimal, которые хранят числа с плавающей точкой с задаваемой пользователем точностью.)

Числа создаются числовыми литералами или в результате встроенных функций и операторов. Неприукрашенные целочисленные литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) приводят к целым числам. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление 'j' или 'J' к числовому литералу дает мнимое число (комплексное число с нулевой действительной частью), которое можно добавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.

Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с «более узким» типом расширяется до типа другого, где целое число уже, чем число с плавающей точкой, а число с плавающей точкой уже, чем комплексное. Сравнения между числами смешанного типа используют то же правило. [2] Конструкторы int(), float() и complex() могут использоваться для создания чисел определённого типа.

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

Примечания:

1. Также известна как целочисленное деление. Результирующее значение — целое число, хотя тип результата необязательно int. Результат всегда округляется до ближайшего меньшего целого: 1//2 равно 0, (-1)//2 равно -1, 1//(-2) равно -1, и (-1)//(-2) равно 0.
2. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей точкой, используя abs(), если это необходимо.
3. Преобразование числа с плавающей точкой в целое может округлять или усекать, как в C; см. функции math.floor() и math.ceil() для определённых преобразований.
4. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Не числа (NaN) и положительной или отрицательной бесконечности.
5. Python определяет pow(0, 0) и 0 ** 0 как 1, как это обычно делается в языках программирования.

6. Принимаемые числовые литералы включают цифры от 0 до 9 или любые эквивалентные Unicode-символы (кодовые точки с Nd свойством).

   Полный список кодовых точек с Nd свойством см. на http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedNumericType.txt.

Все типы numbers.Real (int и float) также включают следующие операции:

Дополнительные числовые операции см. в модулях math и cmath.

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

Побитовые операции имеют смысл только для целых чисел. Отрицательные числа рассматриваются как их значения в дополнительном коде 2 (предполагается, что есть достаточно битов, чтобы избежать переполнения при выполнении операции).

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

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

Примечания:

1. Отрицательные сдвиги недопустимы и вызывают исключение ValueError.
2. Левый сдвиг на n битов эквивалентен умножению на pow(2, n) без проверки на переполнение.
3. Правый сдвиг на n битов эквивалентен делению на pow(2, n) без проверки на переполнение.

4.2. Дополнительные методы для целочисленных типов

Тип 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 в качестве значения порядка байтов.

Аргумент signed определяет, используется ли дополнительный код 2 для представления целого числа. Если 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 должен быть либо объектом типа bytes-like, либо итерируемым объектом, производящим байты.

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

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

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

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

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

float.as_integer_ratio()

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

float.is_integer()

Возвращает True, если экземпляр float конечен и имеет целое значение, и 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'

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

Для чисел 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 имеют одинаковое значение хеша).
• Для комплексного числа 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

5. Типы итераторов

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

Для контейнерных объектов необходимо определить один метод для поддержки итерации:

container.__iter__()

Возвращает объект итератора. Объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные типы итерации, можно предоставить дополнительные методы для конкретного запроса итераторов для этих типов итерации. (Пример объекта, поддерживающего несколько форм итерации, — это структура дерева, которая поддерживает как обход в ширину, так и обход в глубину.) Этот метод соответствует слоту tp_iter структуры типа для объектов Python в API Python/C.

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

iterator.__iter__()

Возвращает сам объект итератора. Это необходимо для использования контейнеров и итераторов с операторами for и in. Этот метод соответствует слоту tp_iter структуры типа для объектов Python в API Python/C.

iterator.__next__()

Возвращает следующий элемент из контейнера. Если больше элементов нет, генерирует исключение StopIteration. Этот метод соответствует слоту tp_iternext структуры типа для объектов Python в API Python/C.

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

После того, как метод __next__() итератора сгенерирует StopIteration, он должен продолжать генерировать это исключение при последующих вызовах. Реализации, которые не подчиняются этому свойству, считаются некорректными.

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

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

6. Типы последовательностей — list, tuple, range

Существует три основных типа последовательностей: списки, кортежи и объекты range. Дополнительные типы последовательностей, предназначенные для обработки бинарных данных и строк текста, описаны в отдельных разделах.

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

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

В этой таблице операции упорядочены по возрастанию приоритета. В таблице, 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. В случае поддержки дополнительные аргументы к методу index позволяют эффективно искать подпоследовательности. Передача дополнительных аргументов примерно эквивалентна использованию s[i:j].index(x), только без копирования данных и с возвращаемым индексом, относящимся к началу последовательности, а не к началу среза.

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

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

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

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

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

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

В таблице 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)

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

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

6.4. Списки

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

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=None)

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

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

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

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

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

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

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

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

6.5. Кортежи

Кортежи — это неизменяемые последовательности, которые обычно используются для хранения коллекций разнородных данных (например, 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() может быть более подходящим выбором, чем обычный кортеж.

6.6. Диапазоны

Тип 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.

Объект range будет пустым, если 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))
[]

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

start

Значение параметра start (или 0 если параметр не был предоставлен)

stop

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

step

Значение параметра step (или 1 если параметр не был предоставлен)

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

Объекты range реализуют 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

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

7. Тип последовательности текста — str

Текстовые данные в Python обрабатываются с помощью объектов str или строк. Строки — это неизменяемые последовательности точек кода Юникода. Литералы строк записываются различными способами:

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

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

Литералы строк, которые являются частью одного выражения и имеют только пробелы между ними, будут неявно преобразованы в один литерал строки. То есть, ("spam " "eggs") == "spam eggs".

См. Литералы строк и байтов для получения дополнительной информации о различных формах литералов строк, включая поддерживаемые escape-последовательности и префикс r («сырой»), который отключает обработку большинства escape-последовательностей.

Строки также могут быть созданы из других объектов с помощью конструктора str.

Поскольку нет отдельного типа «символ», индексирование строки возвращает строки длиной 1. То есть, для непустой строки s, s[0] == s[0:1].

Также нет изменяемого типа строки, но str.join() или io.StringIO могут использоваться для эффективного построения строк из нескольких фрагментов.

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

Возвращает строковую версию объекта object. Если object не указан, возвращает пустую строку. В противном случае поведение str() зависит от того, указаны ли encoding или errors, как следует:

Если ни encoding, ни errors не указаны, str(object) возвращает object.__str__(), которая представляет собой «неформальное» или наглядное представление объекта object. Для объектов строк это сама строка. Если у объекта object нет метода __str__(), то str() возвращает repr(object).

Если хотя бы один из encoding или errors указан, object должен быть объектом типа bytes-like object (например, bytes или bytearray). В этом случае, если object — это объект bytes (или bytearray), тогда str(bytes, encoding, errors) эквивалентно bytes.decode(encoding, errors). В противном случае, объект байтов, лежащий в основе объекта буфера, извлекается перед вызовом bytes.decode(). См. Типы последовательностей двоичных данных — bytes, bytearray, memoryview и Протокол буфера для получения информации об объектах буфера.

Передача объекта bytes в str() без аргументов encoding или errors относится к первому случаю возврата неформального строкового представления (см. также параметр командной строки -b для Python). Например:

>>> str(b'Zoot!')
"b'Zoot!'"

Для получения дополнительной информации о классе str и его методах, см. Тип последовательности текста — str и раздел Методы строк ниже. Для вывода форматированных строк см. раздел Синтаксис форматирования строк. Кроме того, см. раздел Утилиты для работы со строками.

7.1. Методы строк

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

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

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

str.capitalize()

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

str.casefold()

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

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

Алгоритм casefolding описан в разделе 3.13 стандарта Юникод.

Добавлено в версии 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(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

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

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

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

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'

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

str.format_map(mapping)

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

>>> 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.isdecimal()

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

str.isdigit()

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

str.isidentifier()

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

Используйте keyword.iskeyword() для проверки на зарезервированные идентификаторы, такие как def и class.

str.islower()

Возвращает true, если все символы с регистром [4] в строке являются строчными и есть хотя бы один такой символ, иначе false.

str.isnumeric()

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

str.isprintable()

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

str.isspace()

Возвращает true, если в строке есть только символы пробелов и есть хотя бы один такой символ, иначе false. Символы пробелов — это символы, определенные в базе данных Unicode как «Другие» или «Разделители», и те, у которых свойство направления (bidirectional property) равно одному из «WS», «B» или «S».

str.istitle()

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

str.isupper()

Возвращает true, если все символы с регистром [4] в строке являются заглавными и есть хотя бы один такой символ, иначе false.

str.join(iterable)

Возвращает строку, являющуюся конкатенацией строк в iterable. Будет возбуждено исключение TypeError, если в iterable есть значения, не являющиеся строками, включая объекты 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'

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

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

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

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

str.partition(sep)

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

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(), но поднимает исключение ValueError, если подстрока sub не найдена.

str.rjust(width[, fillchar])

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

str.rpartition(sep)

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

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

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

str.rstrip([chars])

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

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

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])

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

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

Представление	Описание
\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 по умолчанию удаляет пробелы. Аргумент 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"

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

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

str.translate(table)

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

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

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

str.upper()

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

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

str.zfill(width)

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

Например:

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

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

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

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

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

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

8. Типы двоичных последовательностей — bytes, bytearray, memoryview

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

Модуль array поддерживает эффективное хранение основных типов данных, таких как 32-битные целые числа и значения двойной точности IEEE754.

8.1. Bytes

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

Во-первых, синтаксис для литералов типа 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 с использованием соответствующей последовательности escape.

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

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

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

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

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

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

classmethod bytes.fromhex(string)

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

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

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

bytes.hex()

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

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

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

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

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

8.2. Объекты Bytearray

bytearray объекты являются изменяемыми аналогами bytes объектов. Нет специального синтаксиса литерала для объектов bytearray, вместо этого они всегда создаются путем вызова конструктора:

• Создание пустого экземпляра: bytearray()
• Создание заполненного нулями экземпляра заданной длины: bytearray(10)
• Из итерируемого набора целых чисел: bytearray(range(20))
• Копирование существующих двоичных данных с помощью протокола буфера: bytearray(b'Hi!')

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

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

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

classmethod bytearray.fromhex(string)

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

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

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

bytearray.hex()

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

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

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

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

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

8.3. Операции с 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.decode(encoding="utf-8", errors="strict")

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

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

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

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(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

Примечание

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

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

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, если подпоследовательность не найдена.

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

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

bytes.join(iterable)

bytearray.join(iterable)

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

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

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

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

bytes.partition(sep)

bytearray.partition(sep)

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

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

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 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, вернуть кортеж из 3 элементов, содержащий копию исходной последовательности, а также два пустых объекта bytes или bytearray.

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

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

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

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

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

bytes.translate(table[, delete])

bytearray.translate(table[, delete])

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

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

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

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

Следующие методы объектов 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'

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

Примечание

Метод 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'

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

Примечание

Версия этого метода для 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.

Например:

>>> 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.

Примечание

Версия этого метода для 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.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. Этот метод использует подход универсальных разделителей строк для разделения строк. Разделители строк не включаются в результирующий список, если keepends не задан или равен false.

Например:

>>> 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 не изменяет исходный объект — она всегда создаёт новый объект, даже если изменений не произошло.

8.4. Форматирование байтовых объектов в стиле printf

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

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

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

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

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

>>> 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.

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

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

class memoryview(obj)

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

У memoryview есть понятие элемента, которое является атомарной единицей памяти, обрабатываемой исходным объектом obj. Для многих простых типов, таких как 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 для объектов memoryview.

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

tobytes()

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

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

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

hex()

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

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

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

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, а также многомерные представления.

release()

Освободить базовый буфер, экспонированный объектом memoryview. Многие объекты выполняют специальные действия, когда на них находится представление (например, 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/беззнаковые байты:

>>> 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/беззнаковых байтов в 1D/символ:

>>> 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/байтов в 3D/целые числа в 1D/знаковые символы:

>>> 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/беззнакового символа в 2D/беззнаковый длинное целое:

>>> 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

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

>>> 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.

9. Типы множеств — set, frozenset

Объект set представляет собой неупорядоченное множество различных хешируемых объектов. Типичные применения включают проверку на принадлежность, удаление дубликатов из последовательности и вычисление математических операций, таких как пересечение, объединение, разность и симметрическая разность. (Для других контейнеров см. встроенные классы dict, list и tuple, а также модуль collections.)

Как и другие коллекции, множества поддерживают x in set, len(set), и for x in set. Поскольку множество является неупорядоченной коллекцией, оно не записывает позиции элементов или порядок вставки. Соответственно, множества не поддерживают индексирование, срезы или другое подобное последовательностям поведение.

В настоящее время существуют два встроенных типа множеств: set и frozenset. Тип set является изменяемым — его содержимое можно изменить с помощью методов, таких как add() и remove(). Поскольку он изменяемый, у него нет хеш-значения, и его нельзя использовать в качестве ключа словаря или элемента другого множества. Тип frozenset является неизменяемым и хешируемым — его содержимое нельзя изменить после создания; поэтому его можно использовать в качестве ключа словаря или элемента другого множества.

Непустые множества (не frozensets) можно создать, поместив в фигурные скобки список элементов, разделенных запятыми, например: {'jack', 'sjoerd'}, помимо конструктора set.

Конструкторы обоих классов работают одинаково:

class set([iterable])

class frozenset([iterable])

Возвращает новый объект множества или неизменяемого множества (frozenset), элементы которого взяты из iterable. Элементы множества должны быть хешируемыми. Для представления множеств множеств вложенные множества должны быть объектами frozenset. Если iterable не указан, возвращается новое пустое множество.

Экземпляры set и frozenset предоставляют следующие операции:

len(s)

Возвращает количество элементов в множестве s (мощность s).

x in s

Проверяет, является ли x элементом множества s.

x not in s

Проверяет, не является ли x элементом множества s.

isdisjoint(other)

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

issubset(other)

set <= other

Проверяет, содержится ли каждый элемент множества в other.

set < other

Проверяет, является ли множество надмножеством other, т.е. set <= other and set != other.

issuperset(other)

set >= other

Проверяет, содержится ли каждый элемент other в множестве.

set > other

Проверяет, является ли множество истинным надмножеством other, т.е. set >= other and set != other.

union(*others)

set | other | ...

Возвращает новое множество с элементами из множества и всех других.

intersection(*others)

set & other & ...

Возвращает новое множество с элементами, общими для множества и всех остальных.

difference(*others)

set - other - ...

Возвращает новое множество с элементами множества, которых нет в других множествах.

symmetric_difference(other)

set ^ other

Возвращает новое множество с элементами, которые содержатся либо в данном множестве, либо в other, но не в обоих.

copy()

Возвращает новое множество с поверхностной копией s.

Обратите внимание, что неунарные версии union(), intersection(), difference() и symmetric_difference(), issubset() и issuperset() методов примут любой итерируемый объект в качестве аргумента. В отличие от этого, их операторные аналоги требуют, чтобы их аргументы были множествами. Это предотвращает создание склонных к ошибкам конструкций вроде set('abc') & 'cbs' в пользу более удобочитаемой set('abc').intersection('cbs').

И set, и frozenset поддерживают сравнения множеств с множествами. Два множества равны тогда и только тогда, когда каждый элемент каждого множества содержится в другом (каждое является подмножеством другого). Множество меньше другого множества тогда и только тогда, когда первое множество является собственным подмножеством второго множества (является подмножеством, но не равно). Множество больше другого множества тогда и только тогда, когда первое множество является собственным надмножеством второго множества (является надмножеством, но не равно).

Экземпляры set сравниваются с экземплярами frozenset на основе их элементов. Например, set('abc') == frozenset('abc') возвращает True, и то же самое делает set('abc') in set([frozenset('abc')]).

Сравнения подмножества и равенства не обобщаются до функции полного упорядочивания. Например, любые два непустых непересекающихся множества не равны и не являются подмножествами друг друга, поэтому все из следующего возвращают False: a<b, a==b, или a>b.

Так как множества определяют только частичное упорядочивание (отношения подмножества), выход метода list.sort() для списков множеств не определен.

Элементы множества, как и ключи словаря, должны быть хешируемыми.

Бинарные операции, которые смешивают экземпляры set с frozenset, возвращают тип первого операнда. Например: frozenset('ab') | set('bc') возвращает экземпляр frozenset.

В следующей таблице перечислены операции, доступные для set, которые не применяются к неизменяемым экземплярам frozenset:

update(*others)

set |= other | ...

Обновить множество, добавив элементы из всех остальных.

intersection_update(*others)

set &= other & ...

Обновить множество, сохранив только элементы, которые находятся в нем и во всех остальных.

difference_update(*others)

set -= other | ...

Обновить множество, удалив элементы, присутствующие в других множествах.

symmetric_difference_update(other)

set ^= other

Обновить множество, сохранив только элементы, присутствующие либо в одном множестве, либо в другом, но не в обоих.

add(elem)

Добавить элемент elem в множество.

remove(elem)

Удалить элемент elem из множества. Вызывает KeyError, если elem не содержится в множестве.

discard(elem)

Удалить элемент elem из множества, если он присутствует.

pop()

Удалить и вернуть произвольный элемент из множества. Вызывает KeyError, если множество пусто.

clear()

Удалить все элементы из множества.

Обратите внимание, что неунарные версии update(), intersection_update(), difference_update() и symmetric_difference_update() методов примут любой итерируемый объект в качестве аргумента.

Обратите внимание, что аргумент elem к методам __contains__(), remove() и discard() может быть множеством. Для поддержки поиска эквивалентного неизменяемого множества создается временное неизменяемое множество из elem.

10. Типы отображений — dict

Объект отображения сопоставляет хешируемые значения произвольным объектам. Отображения являются изменяемыми объектами. В настоящее время существует только один стандартный тип отображения — словарь. (Для других контейнеров см. встроенные классы list, set и tuple, и модуль collections.)

Ключи словаря — это почти произвольные значения. Значения, которые не являются хешируемыми, то есть значения, содержащие списки, словари или другие изменяемые типы (сравниваемые по значению, а не по идентификатору объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа сравниваются как равные (например, 1 и 1.0 ), то их можно использовать взаимозаменяемо для индексирования одной и той же записи словаря. (Однако, поскольку компьютеры хранят числа с плавающей точкой как приближения, обычно не рекомендуется использовать их в качестве ключей словаря.)

Словари можно создать, поместив список пар key: value через запятую в фигурные скобки, например: {'jack': 4098, 'sjoerd': 4127} или {4098: 'jack', 4127: 'sjoerd'}, или с помощью конструктора dict.

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

Если позиционный аргумент не указан, создаётся пустой словарь. Если позиционный аргумент указан и это объект отображения, создаётся словарь с теми же парами ключ-значение, что и у объекта отображения. В противном случае позиционный аргумент должен быть объектом итерируемого объекта. Каждый элемент в итерируемом объекте должен сам быть итерируемым объектом с ровно двумя объектами. Первый объект каждого элемента становится ключом в новом словаре, а второй объект — соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.

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

Для иллюстрации, следующие примеры все возвращают словарь, равный {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

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

Это операции, которые поддерживают словари (и, следовательно, пользовательские типы отображения должны поддерживать их тоже):

len(d)

Возвращает количество элементов в словаре d.

d[key]

Возвращает элемент d с ключом key. Вызывает KeyError, если key отсутствует в отображении.

Если подкласс dict определяет метод __missing__() и key отсутствует, операция d[key] вызывает этот метод с ключом key в качестве аргумента. Операция d[key] затем возвращает или вызывает то, что возвращает или вызывает вызов __missing__(key). Никакие другие операции или методы не вызывают __missing__(). Если __missing__() не определён, возникает KeyError. __missing__() должен быть методом; он не может быть переменной экземпляра:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

В примере выше показана часть реализации collections.Counter. collections.defaultdict использует другой метод __missing__.

d[key] = value

Установить d[key] в value.

del d[key]

Удалить d[key] из d. Возникает KeyError, если key отсутствует в отображении.

key in d

Возвращает True если d имеет ключ key, в противном случае False.

key not in d

Эквивалентно not key in d.

iter(d)

Возвращает итератор по ключам словаря. Это сокращение для iter(d.keys()).

clear()

Удаляет все элементы из словаря.

copy()

Возвращает поверхностную копию словаря.

classmethod fromkeys(seq[, value])

Создаёт новый словарь с ключами из seq и значениями, установленным в value.

fromkeys() — это метод класса, который возвращает новый словарь. value по умолчанию None.

get(key[, default])

Возвращает значение для key, если key есть в словаре, иначе default. Если default не указан, он имеет значение None, так что этот метод никогда не вызывает KeyError.

items()

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

keys()

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

pop(key[, default])

Если key есть в словаре, удаляет его и возвращает его значение, иначе возвращает default. Если default не указан и key отсутствует в словаре, возникает KeyError.

popitem()

Удаляет и возвращает произвольную пару (key, value) из словаря.

popitem() полезно для деструктивного итерирования по словарю, как это часто используется в алгоритмах множеств. Если словарь пуст, вызов popitem() вызывает KeyError.

setdefault(key[, default])

Если key есть в словаре, возвращает его значение. Если нет, вставляет key со значением default и возвращает default. default по умолчанию None.

update([other])

Обновляет словарь парами ключ/значение из other, перезаписывая существующие ключи. Возвращает None.

update() принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (как кортежи или другие итерируемые объекты длиной два). Если указаны ключевые аргументы, словарь затем обновляется этими парами ключ/значение: d.update(red=1, blue=2).

values()

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

Словари равны только тогда, когда они имеют одинаковые пары (key, value). Сравнения порядка (‘<’, ‘<=’, ‘>=’, ‘>’) вызывают TypeError.

10.1. Объекты просмотра словарей

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

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

len(dictview)

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

iter(dictview)

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

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

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

x in dictview

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

Представления словарей (views) по ключам являются множествами, так как их записи уникальны и хешируемы. Если все значения хешируемы, так что (key, value) пары уникальны и хешируемы, то представление по элементам (items view) также является множеством. (Представления по значениям (values views) не рассматриваются как множества, поскольку записи в них, как правило, не уникальны.) Для представлений, подобных множествам, доступны все операции, определенные для абстрактного базового класса 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
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

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

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

11. Типы менеджеров контекста

Утверждение Python with поддерживает концепцию контекста выполнения, определённого менеджером контекста. Это реализуется с помощью пары методов, которые позволяют определяемым пользователем классам определять контекст выполнения, который входит в действие перед выполнением тела утверждения и выходит, когда утверждение завершается:

contextmanager.__enter__()

Вход в контекст выполнения и возврат этого объекта или другого объекта, связанного с контекстом выполнения. Значение, возвращаемое этим методом, привязывается к идентификатору в предложении as утверждений with с использованием этого менеджера контекста.

Пример менеджера контекста, который возвращает себя, — это объект файла. Объекты файлов возвращают себя из __enter__(), чтобы позволить open() использоваться в качестве выражения контекста в утверждении with.

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

Выход из контекста выполнения и возврат булевого флага, указывающего, следует ли подавлять любое произошедшее исключение. Если во время выполнения тела утверждения with возникло исключение, аргументы содержат тип, значение и информацию о трассировке исключения. В противном случае все три аргумента — None.

Возврат истинного значения из этого метода заставит утверждение with подавить исключение и продолжить выполнение со следующим оператором после утверждения with. В противном случае исключение продолжает распространяться после завершения работы этого метода. Исключение, возникающее во время выполнения этого метода, заменит любое исключение, произошедшее в теле утверждения with.

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

Python определяет несколько менеджеров контекста для поддержки лёгкой синхронизации потоков, быстрой закрытия файлов или других объектов и упрощённого управления активным контекстом десятичной арифметики. Указанные типы не обрабатываются специально, за исключением их реализации протокола управления контекстом. См. модуль contextlib для примеров.

Генераторы Python и декоратор contextlib.contextmanager предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором contextlib.contextmanager, она вернёт менеджер контекста, реализующий необходимые методы __enter__() и __exit__(), а не итератор, производимый недекорированной функцией-генератором.

Обратите внимание, что в структуре типов объектов Python в Python/C API нет специального слота для этих методов. Расширяемые типы, желающие определить эти методы, должны предоставить их как обычный доступный из Python метод. По сравнению с накладными расходами на настройку контекста выполнения, накладные расходы на один поиск в словаре класса ничтожны.

12. Другие встроенные типы

Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.

12.1. Модули

Единственной специальной операцией над модулем является доступ к атрибутам: m.name, где m — модуль, а name получает имя, определённое в таблице символов m. Атрибуты модулей могут быть присвоены. (Обратите внимание, что оператор import не является, строго говоря, операцией над объектом модуля; import foo не требует существования объекта модуля 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'>.

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

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

12.3. Функции

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

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

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

12.4. Методы

Методы — это функции, вызываемые с помощью нотации атрибутов. Существует два вида: встроенные методы (например, 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'

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

12.5. Объекты кода

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

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

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

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

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

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

12.7. Объект NULL

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

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

12.8. Объект Ellipsis

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

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

12.9. Объект NotImplemented

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

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

12.10. Логические значения

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

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

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

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

13. Специальные атрибуты

Реализация добавляет несколько специальных только для чтения атрибутов к нескольким типам объектов, где они имеют отношение. Некоторые из них не отображаются встроенной функцией dir().

object.__dict__

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

instance.__class__

Класс, к которому принадлежит экземпляр класса.

class.__bases__

Кортеж базовых классов объекта класса.

definition.__name__

Имя класса, функции, метода, дескриптора или экземпляра генератора.

definition.__qualname__

Квалифицированное имя класса, функции, метода, дескриптора или экземпляра генератора.

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

class.__mro__

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

class.mro()

Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат хранится в __mro__.

class.__subclasses__()

Каждый класс сохраняет список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех таких ссылок, которые всё ещё активны. Пример:

>>> int.__subclasses__()
[<class 'bool'>]

Примечания