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

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

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

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

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

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

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

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

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

Примечания:

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

4.3. Сравнения

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

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

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

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

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

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

Две дополнительные операции с таким же синтаксическим приоритетом, in и not in, поддерживаются типами, которые являются итерируемыми или реализуют метод __contains__().

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

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

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

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

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

Примечания:

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

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

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

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

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

4.4.1. Битовые операции над целочисленными типами

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

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

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

Примечания:

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

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

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

int.bit_length()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4.4.3. Дополнительные методы для типа Float

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

float.as_integer_ratio()

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

float.is_integer()

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

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

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

float.hex()

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

classmethod float.fromhex(s)

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

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

Шестнадцатеричная строка имеет следующий вид:

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

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

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

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

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

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

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

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

Вот правила в деталях:

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

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

import sys, math

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

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

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

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

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

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

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

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

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

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

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

container.__iter__()

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

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

iterator.__iter__()

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

iterator.__next__()

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

   >>> "gg" in "eggs"
   True
   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

   Добавлено в версии 3.3: clear() и copy() методы.

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

4.6.4. Списки

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

class list([iterable])

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

• Используя пару квадратных скобок для обозначения пустого списка: []
• Используя квадратные скобки, разделяя элементы запятыми: [a], [a, b, c]
• Используя генератор списков: [x for x in iterable]
• Используя конструктор типа: list() или list(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 Python делает список пустым на всё время и вызывает ValueError, если может определить, что список был изменён во время сортировки.

4.6.5. Кортежи

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

class tuple([iterable])

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

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

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

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

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

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

4.6.6. Диапазоны

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

class range(stop)

class range(start, stop[, step])

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

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

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

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

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

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

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

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

start

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

stop

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

step

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class str(object='')

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

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

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

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

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

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

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

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

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

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

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

str.capitalize()

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

str.casefold()

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

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

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

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

str.center(width[, fillchar])

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

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

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

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

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

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

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

Возвращает True если строка заканчивается указанным 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.6.5: При форматировании числа с типом n, функция временно устанавливает локаль LC_CTYPE на локаль LC_NUMERIC в некоторых случаях.

str.format_map(mapping)

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

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

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

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

Подобно find(), но вызывает ValueError, когда подстрока не найдена.

str.isalnum()

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

str.isalpha()

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

str.isdecimal()

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

str.isdigit()

Возвращает true, если все символы в строке являются цифрами и существует хотя бы один символ, в противном случае — false. Цифры включают в себя десятичные символы и цифры, которые требуют специальной обработки, такие как совместимые цифры с верхним индексом. Это охватывает цифры, которые не могут использоваться для образования чисел в системе счисления с основанием 10, такие как цифры системы Харoшти. Формально, цифра — это символ, у которого значение свойства 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, ДРОБЬ ОДНА ПЯТАЯ. Формально числовые символы — это те, у которых свойство Numeric_Type=Digit, Numeric_Type=Decimal или Numeric_Type=Numeric.

str.isprintable()

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

str.isspace()

Возвращает true, если в строке только пробельные символы и есть хотя бы один символ, иначе — false. Пробельные символы — это символы, определенные в базе данных символов Unicode как «Другое» или «Разделитель», а также те, у которых свойство двунаправленности равно одному из «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.

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

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

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

Например:

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

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

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

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

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

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

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

str.strip([chars])

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

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

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

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

str.swapcase()

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

str.title()

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

Например:

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

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

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

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

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

str.translate(table)

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

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

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

str.upper()

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

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

str.zfill(width)

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

Например:

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

4.7.2. 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' является концом строки.

4.8. Бинарные последовательности типов — bytes, bytearray, memoryview

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

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

4.8.1. Объекты типа 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 с использованием соответствующей escape-последовательности.

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

Хотя литералы и представления типа 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'

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

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

Объекты bytearray являются изменяемыми аналогами объектов bytes.

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

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

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

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

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

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

classmethod fromhex(string)

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

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

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

4.8.3. Операции с типами 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 или bytearray.

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

bytes.join(iterable)

bytearray.join(iterable)

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

Разделитель между элементами — содержимое объекта bytes или bytearray, предоставляющего этот метод.

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

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

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

bytes.partition(sep)

bytearray.partition(sep)

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

Аналогично rfind(), но возбуждает ValueError при отсутствии подпоследовательности sub.

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

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

bytes.rpartition(sep)

bytearray.rpartition(sep)

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

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

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

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

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

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

Примечание

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

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

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

Примечание

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

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

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

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

bytes.rstrip([chars])

bytearray.rstrip([chars])

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

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

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

Примечание

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

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

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

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

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

Например:

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

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

Например:

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

bytes.strip([chars])

bytearray.strip([chars])

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

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

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

Примечание

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

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

bytes.capitalize()

bytearray.capitalize()

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

Примечание

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

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

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

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

Примечание

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

bytes.isalnum()

bytearray.isalnum()

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

Например:

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

bytes.isalpha()

bytearray.isalpha()

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

Например:

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

bytes.isdigit()

bytearray.isdigit()

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

Например:

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

bytes.islower()

bytearray.islower()

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

Например:

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

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

bytes.isspace()

bytearray.isspace()

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

bytes.istitle()

bytearray.istitle()

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

Например:

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

bytes.isupper()

bytearray.isupper()

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

Например:

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

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

bytes.lower()

bytearray.lower()

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

Например:

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

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

Примечание

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

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

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

Например:

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

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

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

bytes.swapcase()

bytearray.swapcase()

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

Например:

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

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

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

Примечание

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

bytes.title()

bytearray.title()

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

Например:

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

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

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

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

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

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

Примечание

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

bytes.upper()

bytearray.upper()

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

Например:

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

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

Примечание

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

bytes.zfill(width)

bytearray.zfill(width)

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

Например:

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

Примечание

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

4.8.4. printf-стиль форматирования байтов

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

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

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

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

class memoryview(obj)

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

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

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

A memoryview поддерживает срезы и индексирование для доступа к данным. Одномерный срез приведет к созданию подпредставления:

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

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

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

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

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

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

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

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

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

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

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

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

__eq__(exporter)

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

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

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

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

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

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

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

tobytes()

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

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

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

hex()

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

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

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

tolist()

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

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

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

release()

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

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

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

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

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

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

cast(format[, shape])

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

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

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

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

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

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

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

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

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

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

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

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

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

obj

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

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

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

nbytes

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

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

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

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

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

readonly

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

format

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

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

itemsize

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

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

ndim

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

shape

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

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

strides

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

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

suboffsets

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

c_contiguous

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

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

f_contiguous

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

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

contiguous

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

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

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

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

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

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

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

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

class set([iterable])

class frozenset([iterable])

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

Объекты set и frozenset предоставляют следующие операции:

len(s)

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

x in s

Проверяет принадлежность элемента x множеству s.

x not in s

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

isdisjoint(other)

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

issubset(other)

set <= other

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

set < other

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

issuperset(other)

set >= other

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

set > other

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

union(*others)

set | other | ...

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

intersection(*others)

set & other & ...

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

difference(*others)

set - other - ...

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

symmetric_difference(other)

set ^ other

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

copy()

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

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

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

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

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

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

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

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

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

update(*others)

set |= other | ...

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

intersection_update(*others)

set &= other & ...

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

difference_update(*others)

set -= other | ...

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

symmetric_difference_update(other)

set ^= other

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

add(elem)

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

remove(elem)

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

discard(elem)

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

pop()

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

clear()

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

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

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

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

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

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

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

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

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

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

len(d)

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

d[key]

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

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

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

Приведённый выше пример демонстрирует часть реализации collections.Counter. Разный __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(seq[, value])

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

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

get(key[, default])

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

items()

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

keys()

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

pop(key[, default])

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

popitem()

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

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

setdefault(key[, default])

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

update([other])

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

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

values()

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

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

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

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

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

len(dictview)

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

iter(dictview)

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

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

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

x in dictview

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

Ключевые представления являются множествами, так как их записи уникальны и хешируемы. Если все значения хешируемы, так что пары (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
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

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

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

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

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

contextmanager.__enter__()

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

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

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

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

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

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

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

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

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

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

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

4.12.1. Модули

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

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

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

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

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

4.12.3. Функции

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

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

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

4.12.4. Методы

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

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

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

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

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

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

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

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

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

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

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

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

4.12.7. Объект None

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

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

4.12.8. Объект Ellipsis

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

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

4.12.9. Объект NotImplemented

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

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

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

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

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

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

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

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

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

object.__dict__

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

instance.__class__

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

class.__bases__

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

definition.__name__

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

definition.__qualname__

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

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

class.__mro__

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

class.mro()

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

class.__subclasses__()

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

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

Примечания

1

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

2

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

3

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

4(1,2,3,4)

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

5(1,2)

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