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

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

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

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

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

Примечания:

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

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

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

int.bit_length()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int.as_integer_ratio()

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

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

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

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

float.as_integer_ratio()

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

float.is_integer()

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

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

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

float.hex()

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

classmethod float.fromhex(s)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import sys, math

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

   >>> "gg" in "eggs"
   True
   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

Списки

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

class list([iterable])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Кортежи

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

class tuple([iterable])

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

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

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

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

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

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

Диапазоны

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

class range(stop)

class range(start, stop[, step])

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

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

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

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

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

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

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

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

start

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

stop

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

step

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

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

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

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

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

Методы строк

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

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

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

str.capitalize()

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

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

str.casefold()

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

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

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

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

str.center(width[, fillchar])

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

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

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

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

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

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

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

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

str.expandtabs(tabsize=8)

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

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

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

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

Примечание

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

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

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

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

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

Примечание

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

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

str.format_map(mapping)

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

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

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

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

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

str.isalnum()

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

str.isalpha()

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

str.isascii()

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

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

str.isdecimal()

Возвращает True , если все символы в строке являются десятичными символами и имеется как минимум один символ, False в противном случае. Десятичные символы — это символы, которые могут быть использованы для формирования чисел в системе счисления по основанию 10, например, U+0660, арабская цифра ноль. Формально, десятичный символ — это символ в категории Unicode «Nd».

str.isdigit()

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

str.isidentifier()

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

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

Пример:

>>> from keyword import iskeyword

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

str.islower()

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

str.isnumeric()

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

str.isprintable()

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

str.isspace()

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

Символ является пробелом, если в базе данных символов Юникода (см. unicodedata), либо его общая категория равна Zs («Разделитель, пробел»), либо его направление текста (bidirectional class) является одним из 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 стандарта Юникод.

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

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

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

str.partition(sep)

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

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

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

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

str.rstrip([chars])

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

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

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

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

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

Например:

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

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

Например:

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

str.splitlines([keepends])

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

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

Представление	Описание
\n	Перевод строки
\r	Возврат каретки
\r\n	Возврат каретки + перевод строки
\v or \x0b	Табуляция
\f or \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, если строка начинается с префикса, в противном случае возвращает False. Префикс также может быть кортежем префиксов, которые нужно искать. При необязательном 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).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)

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

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

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

str.upper()

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

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

str.zfill(width)

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

Например:

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

classmethod fromhex(string)

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

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

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

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

hex([sep[, bytes_per_sep]])

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

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

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

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

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

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

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

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

Примечание

Для пользователей Python 2.x: В Python 2.x допускалось множество неявных преобразований между строками 8-битного кода (самый близкий аналог встроенного двоичного типа данных) и строками Unicode. Это был обходной путь обратной совместимости для учета того факта, что Python изначально поддерживал только 8-битный текст, а текст Unicode — это более позднее дополнение. В Python 3.x неявные преобразования отсутствуют — преобразования между двоичными данными 8-битного кода и текстом Unicode должны быть явными, и объекты bytes и строковые объекты всегда будут считаться разными.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

bytes.join(iterable)

bytearray.join(iterable)

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

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

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

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

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

bytes.partition(sep)

bytearray.partition(sep)

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

bytes.rpartition(sep)

bytearray.rpartition(sep)

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

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

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

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

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

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

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

bytearray.isascii()

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

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

bytes.isdigit()

bytearray.isdigit()

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

Например:

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

bytes.islower()

bytearray.islower()

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

Например:

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

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

bytes.isspace()

bytearray.isspace()

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

bytes.istitle()

bytearray.istitle()

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

Например:

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

bytes.isupper()

bytearray.isupper()

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

Например:

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

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

bytes.lower()

bytearray.lower()

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

Например:

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

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

Примечание

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

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

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

Примечание

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

bytes.title()

bytearray.title()

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

Например:

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

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

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

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

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

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

Примечание

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

bytes.upper()

bytearray.upper()

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

Например:

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

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

Примечание

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

bytes.zfill(width)

bytearray.zfill(width)

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

Например:

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

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

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

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

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

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

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

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

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

hex([sep[, bytes_per_sep]])

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

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

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

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

tolist()

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

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

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

toreadonly()

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

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

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

release()

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

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

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

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

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

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

cast(format[, shape])

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

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

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

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

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

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

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

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

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

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

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

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

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

obj

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

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

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

nbytes

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

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

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

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

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

readonly

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

format

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

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

itemsize

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

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

ndim

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

shape

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

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

strides

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

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

suboffsets

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

c_contiguous

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

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

f_contiguous

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

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

contiguous

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

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

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

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

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

len(dictview)

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

iter(dictview)

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

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

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

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

x in dictview

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

reversed(dictview)

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

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

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

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

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

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

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

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

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

Модули

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

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

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

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

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

Функции

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

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

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

Методы

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

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

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

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

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

Объекты кода

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

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

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

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

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

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

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

Объект null

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

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

Объект ellipsis

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

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

Объект NotImplemented

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

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

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

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

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

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

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

Затронутые API

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

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

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

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

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

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

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

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

• sys.get_int_max_str_digits() и sys.set_int_max_str_digits() — это функции получения и установки ограничения для всего интерпретатора. У подинтерпретаторов есть свои ограничения.

Дополнительную информацию о значении по умолчанию и минимуме можно найти в sys.int_info:

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

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

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

Пример:

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

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

Примечания

1

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

2

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

3

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

4(1,2,3,4)

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

5(1,2)

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