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

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

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

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

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

Проверка истинности

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

По умолчанию объект считается истинным, если его класс не определяет метод __bool__(), возвращающий False, или метод __len__(), возвращающий ноль, при вызове с объектом. 1 Вот большинство встроенных объектов, рассматриваемых как ложные:

• константы, определённые как ложные: None и False.
• ноль любого числового типа: 0, 0.0, 0j, Decimal(0), Fraction(0, 1).
• пустые последовательности и коллекции: '', (), [], {}, set(), range(0).

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

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

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

Примечания:

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

Сравнения

В 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, поддерживаются типами, которые являются итерируемыми или реализуют метод __contains__().

Числовые типы — 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).

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

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

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

Битовые операции для целочисленных типов

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

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

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

Примечания:

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

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

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

int.bit_length()

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

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

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

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

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

Новая версия с версии 3.1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Дополнительные методы для типа 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'

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

Для чисел x и y, возможно, разных типов, требуется, чтобы hash(x) == hash(y) всякий раз, когда x == y (см. документацию метода __hash__() для получения более подробной информации).

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

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

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

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

import sys, math

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

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

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

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

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

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

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

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

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

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

Для того, чтобы объекты контейнеров поддерживали итерацию, должен быть определён один метод:

container.__iter__()

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

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

iterator.__iter__()

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

iterator.__next__()

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

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

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

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

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

Типы последовательностей — список, кортеж, диапазон

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

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

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

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

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

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

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

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

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

Списки

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

class list([iterable])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Кортежи

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

class tuple([iterable])

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

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

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

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

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

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

Диапазоны

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

class range(stop)

class range(start, stop[, step])

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

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

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

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

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

Примеры range:

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

start

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

stop

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

step

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

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

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

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

Тип последовательности текста — 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 или 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 и раздел Методы строк ниже. Для вывода отформатированных строк см. разделы Литералы отформатированных строк и Синтаксис форматирования строк. Кроме того, см. раздел Услуги обработки текста.

Методы строк

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

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

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

str.capitalize()

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

str.casefold()

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

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

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

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

str.center(width[, fillchar])

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

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

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

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

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

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

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

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

str.expandtabs(tabsize=8)

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

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

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

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

Примечание

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

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

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

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

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

Примечание

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

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

str.format_map(mapping)

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

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

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

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

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

str.isalnum()

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

str.isalpha()

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

str.isascii()

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

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

str.isdecimal()

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

str.isdigit()

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

str.isidentifier()

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

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

str.islower()

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

str.isnumeric()

Возвращает True, если все символы в строке являются числовыми символами и существует хотя бы один такой символ, False в противном случае. Числовые символы включают цифры и все символы, имеющие числовое значение Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Строго говоря, числовые символы — это те, у которых свойство Numeric_Type равно Digit, Decimal или Numeric.

str.isprintable()

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

str.isspace()

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

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

str.istitle()

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

str.isupper()

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

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 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, вернуть кортеж из 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 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, вернуть кортеж из 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__(), обычно это отображение или последовательность. При индексировании по порядковому номеру Unicode (целое число), объект таблицы может выполнить любое из следующего: вернуть порядковый номер Unicode или строку, чтобы отобразить символ на один или несколько других символов; вернуть None, чтобы удалить символ из результирующей строки; или вызвать исключение LookupError, чтобы отобразить символ на себя.

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

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

str.upper()

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

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

str.zfill(width)

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

Например:

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

printf-стиль форматирования строк

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

5. Если точность N, выходные данные усекаются до N символов.
6. См. PEP 237.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

classmethod fromhex(string)

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

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

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

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

hex()

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

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

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

bytearray объекты — это изменяемые аналоги объектов bytes.

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

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

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

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

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

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

classmethod fromhex(string)

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

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

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

Существует обратная функция преобразования для преобразования объекта 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).

Операции с Bytes и Bytearray

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

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

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

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

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

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

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

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

Подпоследовательность, которую нужно искать, может быть любым объектом типа bytes-like или целым числом в диапазоне от 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-like непосредственно, без необходимости создания временного объекта bytes или bytearray.

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

bytes.join(iterable)

bytearray.join(iterable)

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

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

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

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

bytes.partition(sep)

bytearray.partition(sep)

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

Как rfind(), но генерирует исключение ValueError, если подпоследовательность sub не найдена.

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

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

bytes.rpartition(sep)

bytearray.rpartition(sep)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

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

Примечание

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

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

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

Примечание

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

bytes.lstrip([chars])

bytearray.lstrip([chars])

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

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

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

Примечание

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

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

Примечание

Версия этого метода для 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 может быть любым объектом типа байт-подобный.

Например:

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

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

Примечание

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

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

bytes.capitalize()

bytearray.capitalize()

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

Примечание

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

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

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

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

Примечание

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

bytes.isalnum()

bytearray.isalnum()

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

Например:

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

bytes.isalpha()

bytearray.isalpha()

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

Например:

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

bytes.isascii()

bytearray.isascii()

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

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

bytes.isdigit()

bytearray.isdigit()

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

Например:

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

bytes.islower()

bytearray.islower()

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

Например:

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

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

bytes.isspace()

bytearray.isspace()

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

bytes.istitle()

bytearray.istitle()

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

Например:

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

bytes.isupper()

bytearray.isupper()

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

Например:

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

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

bytes.lower()

bytearray.lower()

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

Например:

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

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

Примечание

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

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

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

Например:

>>> 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, хотя это не всегда верно для произвольных кодовых точек Unicode.

Примечание

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

bytes.title()

bytearray.title()

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

Например:

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

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

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

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

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

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

Примечание

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

bytes.upper()

bytearray.upper()

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

Например:

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

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

Примечание

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

bytes.zfill(width)

bytearray.zfill(width)

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

Например:

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

Примечание

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

printf-форматирование байтовых объектов

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

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

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

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

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, индексирование целым числом или кортежем целых чисел также поддерживается и возвращает один элемент с правильным типом. Одномерные memoryviews могут индексироваться целым числом или кортежем из одного целого числа. Многомерные memoryviews могут индексироваться кортежами ровно из ndim целых чисел, где ndim — количество измерений. Нульмерные memoryviews могут индексироваться пустым кортежем.

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

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

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

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

Одномерные memoryviews хешируемых (только для чтения) типов с форматами ‘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: Одномерные memoryviews теперь могут быть разрезаны. Одномерные memoryviews с форматами 'B', 'b' или 'c' теперь хешируются.

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

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

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

__eq__(exporter)

memoryview и экспортер 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 на memoryview.

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

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

Базовый объект memoryview:

>>> 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) для каждого элемента в представлении. Представление memoryview может быть создано из экспортеров с произвольными строками форматов, но некоторые методы (например, 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.

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

Объект множества представляет собой неупорядоченное множество различных хешируемых объектов. Типичные применения включают проверку принадлежности, удаление дубликатов из последовательности и вычисление математических операций, таких как пересечение, объединение, разность и симметричная разность. (Для других контейнеров см. встроенные классы 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])

Возвращает новый объект типа set или 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()

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

Обратите внимание, что не-операторные версии 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() может быть множеством. Для поддержки поиска эквивалентного frozenset создается временное множество из elem.

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

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

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

Словари могут создаваться с использованием списка пар ключ-значение, разделенных запятыми, заключённых в фигурные скобки, например: {'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. В противном случае можно использовать любые допустимые ключи.

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

list(d)

Возвращает список всех ключей, используемых в словаре d.

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. Разный __missing__ метод используется collections.defaultdict.

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(iterable[, value])

Создает новый словарь с ключами из iterable и значениями, установленными на 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) пару из словаря. Пары возвращаются в порядке LIFO.

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

Изменено в версии 3.7: Порядок LIFO теперь гарантирован. В предыдущих версиях popitem() возвращал произвольную пару ключ/значение.

setdefault(key[, default])

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

update([other])

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

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

values()

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

Сравнение на равенство между одним dict.values() представлением и другим всегда возвращает False. Это также относится к сравнениям dict.values() с самим собой:

>>> d = {'a': 1}
>>> d.values() == d.values()
False

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

Словари сохраняют порядок вставки. Обратите внимание, что обновление ключа не влияет на порядок. Ключи, добавленные после удаления, вставляются в конец.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

Изменено в версии 3.7: Порядок словаря гарантированно является порядком вставки. Это поведение было реализационной деталью CPython с 3.6.

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

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

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

len(dictview)

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

iter(dictview)

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

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

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

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

x in dictview

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

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

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

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

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

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

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

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

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

В 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 метод. По сравнению с накладными расходами на создание контекста выполнения, накладные расходы на поиск в словаре класса ничтожны.

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

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

Модули

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

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

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

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

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

Функции

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

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

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

Методы

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

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

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

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

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

Объекты кода

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

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

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

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

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

Типы записываются следующим образом: <class 'int'>.

Объект Null

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

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

Объект Эллипсис

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

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

Объект NotImplemented

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

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

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

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

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

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

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

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

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

object.__dict__

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

instance.__class__

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

class.__bases__

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

definition.__name__

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

definition.__qualname__

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

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

class.__mro__

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

class.mro()

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

class.__subclasses__()

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

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

Примечания

1

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

2

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

3

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

4(1,2,3,4)

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

5(1,2)

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