stdtypes.md

1> **Источник:** https://python-all.ru/3.15/library/stdtypes.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# Встроенные типы89В следующих разделах описываются стандартные типы, встроенные в интерпретатор.1011Основные встроенные типы: числовые типы, последовательности, отображения, классы, экземпляры и исключения.1213Некоторые классы коллекций являются изменяемыми. Методы, которые добавляют, удаляют или перестраивают их элементы на месте и не возвращают конкретный элемент, никогда не возвращают сам экземпляр коллекции, а `None`.1415Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать на равенство, проверять на истинность и преобразовывать в строку (с помощью функции [`repr()`](https://python-all.ru/3.15/library/functions.html#repr) или немного отличающейся функции [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.15/library/functions.html#print).1617## Проверка на истинность1819Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.15/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.15/reference/compound_stmts.html#while) или в качестве операнда булевых операций, описанных ниже.2021По умолчанию объект считается истинным, если его класс не определяет метод [`__bool__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__bool__), возвращающий `False`, или метод [`__len__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__len__), возвращающий ноль, при вызове с этим объектом. [\[1\]](https://python-all.ru/3.15/library/stdtypes.html#id12) Если один из методов вызывает исключение при вызове, исключение распространяется, и объект не имеет значения истинности (например, [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented)). Вот большинство встроенных объектов, которые считаются ложными:2223- константы, определённые как ложные: `None` и `False`24- ноль любого числового типа: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`25- пустые последовательности и коллекции: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`2627Операции и встроенные функции, возвращающие булев результат, всегда возвращают `0` или `False` для ложного и `1` или `True` для истинного, если не указано иное. (Важное исключение: булевы операции `or` и `and` всегда возвращают один из своих операндов.)2829## Булевы операции – `and`, `or`, `not`3031Это булевы операции в порядке возрастания приоритета:3233| Операция | Результат | Примечания |34| --- | --- | --- |35| `x or y` | если *x* истинно, то *x*, иначе *y* | (1) |36| `x and y` | если *x* ложно, то *x*, иначе *y* | (2) |37| `not x` | если *x* ложно, то `True`, иначе `False` | (3) |3839Примечания:40411. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый ложен.422. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый истинен.433. `not` имеет более низкий приоритет, чем небулевы операторы, поэтому `not a == b` интерпретируется как `not (a == b)`, а `a == not b` является синтаксической ошибкой.4445## Сравнения4647В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (выше, чем у булевых операций). Сравнения можно произвольно объединять в цепочки; например, `x < y <= z` эквивалентно `x < y and y <= z`, за исключением того, что *y* вычисляется только один раз (но в обоих случаях *z* вообще не вычисляется, если `x < y` оказывается ложным).4849В этой таблице приведены операции сравнения:5051| Операция | Значение |52| --- | --- |53| `<` | строго меньше |54| `<=` | меньше или равно |55| `>` | строго больше |56| `>=` | больше или равно |57| `==` | равно |58| `!=` | не равно |59| `is` | идентичность объектов |60| `is not` | отрицание идентичности объектов |6162Если не указано иное, объекты разных типов никогда не сравниваются как равные. Оператор `==` всегда определён, но для некоторых типов объектов (например, объектов классов) эквивалентен [`is`](https://python-all.ru/3.15/reference/expressions.html#is). Операторы `<`, `<=`, `>` и `>=` определены только там, где они имеют смысл; например, они вызывают исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError), если один из аргументов – комплексное число.6364Разные экземпляры класса обычно сравниваются как неравные, если только класс не определяет метод [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__).6566Экземпляры класса нельзя упорядочить относительно других экземпляров того же класса или объектов других типов, если только класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__ge__) (в общем случае достаточно `__lt__()` и [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__), если нужны традиционные значения операторов сравнения).6768Поведение операторов [`is`](https://python-all.ru/3.15/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.15/reference/expressions.html#is-not) не может быть настроено; кроме того, они применимы к любым двум объектам и никогда не вызывают исключение.6970Ещё две операции с тем же синтаксическим приоритетом, [`in`](https://python-all.ru/3.15/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.15/reference/expressions.html#not-in), поддерживаются типами, которые являются [итерируемыми](https://python-all.ru/3.15/glossary.html#term-iterable) или реализуют метод [`__contains__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__contains__).7172## Числовые типы – [`int`](https://python-all.ru/3.15/library/functions.html#int), [`float`](https://python-all.ru/3.15/library/functions.html#float), [`complex`](https://python-all.ru/3.15/library/functions.html#complex)7374Существует три различных числовых типа: *целые числа*, *числа с плавающей запятой* и *комплексные числа*. Кроме того, логический тип является подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей запятой обычно реализуются с помощью double в C; информация о точности и внутреннем представлении чисел с плавающей запятой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.15/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей запятой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы: [`fractions.Fraction`](https://python-all.ru/3.15/library/fractions.html#fractions.Fraction) для рациональных чисел и [`decimal.Decimal`](https://python-all.ru/3.15/library/decimal.html#decimal.Decimal) для чисел с плавающей запятой с определяемой пользователем точностью.)7576Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Обычные целочисленные литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей запятой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно прибавить к целому или вещественному числу, чтобы получить комплексное число с действительной и мнимой частями.7778Конструкторы [`int()`](https://python-all.ru/3.15/library/functions.html#int), [`float()`](https://python-all.ru/3.15/library/functions.html#float) и [`complex()`](https://python-all.ru/3.15/library/functions.html#complex) можно использовать для создания чисел определённого типа.7980Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных встроенных числовых типов, операнд с «более узким» типом расширяется до типа другого.8182- Если оба аргумента – комплексные числа, преобразование не выполняется;83- если любой из аргументов является комплексным числом или числом с плавающей запятой, другой преобразуется в число с плавающей запятой;84- в противном случае оба должны быть целыми числами, и преобразование не требуется.8586Арифметика с комплексными и вещественными операндами определяется обычными математическими формулами, например:8788```python89x + complex(u, v) = complex(x + u, v)90x * complex(u, v) = complex(x * u, x * v)91```9293Сравнение чисел разных типов ведёт себя так, как если бы сравнивались точные значения этих чисел. [\[2\]](https://python-all.ru/3.15/library/stdtypes.html#id13)9495Все числовые типы (кроме комплексных) поддерживают следующие операции (о приоритетах операций см. [Приоритет операций](https://python-all.ru/3.15/reference/expressions.html#operator-summary)):9697| Операция | Результат | Примечания | Полная документация |98| --- | --- | --- | --- |99| `x + y` | сумма *x* и *y* |  |  |100| `x - y` | разность *x* и *y* |  |  |101| `x * y` | произведение *x* и *y* |  |  |102| `x / y` | частное *x* и *y* |  |  |103| `x // y` | неполное частное *x* и *y* | (1)(2) |  |104| `x % y` | остаток от `x / y` | (2) |  |105| `-x` | *x* с обратным знаком |  |  |106| `+x` | *x* без изменений |  |  |107| `abs(x)` | абсолютное значение или модуль *x* |  | [`abs()`](https://python-all.ru/3.15/library/functions.html#abs) |108| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.15/library/functions.html#int) |109| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.15/library/functions.html#float) |110| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.15/library/functions.html#complex) |111| `c.conjugate()` | сопряжённое комплексного числа *c* |  |  |112| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.15/library/functions.html#divmod) |113| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.15/library/functions.html#pow) |114| `x ** y` | *x* в степени *y* | (5) |  |115116Примечания:1171181. Также называется целочисленным делением. Для операндов типа [`int`](https://python-all.ru/3.15/library/functions.html#int) результат имеет тип `int`. Для операндов типа [`float`](https://python-all.ru/3.15/library/functions.html#float) результат имеет тип `float`. В общем случае результат – целое число, хотя его тип не обязательно `int`. Результат всегда округляется в сторону минус бесконечности: `1//2` равно `0`, `(-1)//2` равно `-1`, `1//(-2)` равно `-1`, а `(-1)//(-2)` равно `0`.1192. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей запятой с помощью [`abs()`](https://python-all.ru/3.15/library/functions.html#abs), если это уместно.1203. Преобразование из [`float`](https://python-all.ru/3.15/library/functions.html#float) в [`int`](https://python-all.ru/3.15/library/functions.html#int) усекает, отбрасывая дробную часть. См. функции [`math.floor()`](https://python-all.ru/3.15/library/math.html#math.floor) и [`math.ceil()`](https://python-all.ru/3.15/library/math.html#math.ceil) для альтернативных преобразований.1214. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.1225. Python определяет `pow(0, 0)` и `0 ** 0` как `1`, что общепринято для языков программирования.1236. Принимаемые числовые литералы включают цифры от `0` до `9` или любой эквивалент в Unicode (кодовые точки со свойством `Nd`).124125   См. [стандарт Unicode](https://python-all.ru/3.15/library/stdtypes.html) для полного списка кодовых точек со свойством `Nd`.126127Все типы [`numbers.Real`](https://python-all.ru/3.15/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.15/library/functions.html#int) и [`float`](https://python-all.ru/3.15/library/functions.html#float)) также включают следующие операции:128129| Операция | Результат |130| --- | --- |131| [`math.trunc(x)`](https://python-all.ru/3.15/library/math.html#math.trunc) | *x*, усечённое до [`Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral) |132| [`round(x[, n])`](https://python-all.ru/3.15/library/functions.html#round) | *x*, округлённое до *n* знаков, с округлением до ближайшего чётного. Если *n* опущено, по умолчанию равно 0. |133| [`math.floor(x)`](https://python-all.ru/3.15/library/math.html#math.floor) | наибольшее [`Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral) \<= *x* |134| [`math.ceil(x)`](https://python-all.ru/3.15/library/math.html#math.ceil) | наименьшее [`Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral) \>= *x* |135136За дополнительными числовыми операциями обращайтесь к модулям [`math`](https://python-all.ru/3.15/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.15/library/cmath.html#module-cmath).137138### Побитовые операции над целыми типами139140Побитовые операции имеют смысл только для целых чисел. Результат побитовых операций вычисляется так, как если бы они выполнялись в дополнительном коде с бесконечным количеством знаковых битов.141142Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция `~` имеет тот же приоритет, что и другие унарные числовые операции (`+` и `-`).143144В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета:145146| Операция | Результат | Примечания |147| --- | --- | --- |148| `x \| y` | побитовое *ИЛИ* для *x* и *y* | (4) |149| `x ^ y` | побитовое *исключающее ИЛИ* для *x* и *y* | (4) |150| `x & y` | побитовое *И* для *x* и *y* | (4) |151| `x << n` | *x*, сдвинутое влево на *n* битов | (1)(2) |152| `x >> n` | *x*, сдвинутое вправо на *n* битов | (1)(3) |153| `~x` | инвертированные биты *x* |  |154155Примечания:1561571. Отрицательные значения сдвига недопустимы и вызывают [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError).1582. Сдвиг влево на *n* битов эквивалентен умножению на `pow(2, n)`.1593. Сдвиг вправо на *n* битов эквивалентен целочисленному делению на `pow(2, n)`.1604. Выполнение этих вычислений с хотя бы одним дополнительным битом знакового расширения в конечном дополнительном коде (рабочая разрядность `1 + max(x.bit_length(), y.bit_length())` или более) достаточно для получения того же результата, как если бы было бесконечное количество знаковых битов.161162### Дополнительные методы для целых типов163164Тип int реализует [`numbers.Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral) [абстрактный базовый класс](https://python-all.ru/3.15/glossary.html#term-abstract-base-class). Кроме того, он предоставляет ещё несколько методов:165166#### `int.bit_length()`167168Возвращает количество битов, необходимое для представления целого числа в двоичном виде, без учёта знака и ведущих нулей:169170```python171>>> n = -37172>>> bin(n)173'-0b100101'174>>> n.bit_length()1756176```177178Более точно, если `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`.179180Эквивалентно следующему:181182```python183def bit_length(self):184    s = bin(self)       # двоичное представление:  bin(-37) --> '-0b100101'185    s = s.lstrip('-0b') # удалить ведущие нули и знак минус186    return len(s)       # len('100101') --> 6187```188189Добавлено в версии 3.1.190191#### `int.bit_count()`192193Возвращает количество единиц в двоичном представлении абсолютного значения целого числа. Также известно как population count. Пример:194195```python196>>> n = 19197>>> bin(n)198'0b10011'199>>> n.bit_count()2003201>>> (-n).bit_count()2023203```204205Эквивалентно следующему:206207```python208def bit_count(self):209    return bin(self).count("1")210```211212Добавлено в версии 3.10.213214#### `int.to_bytes(length=1, byteorder='big', *, signed=False)`215216Возвращает массив байтов, представляющий целое число.217218```python219>>> (1024).to_bytes(2, byteorder='big')220b'\x04\x00'221>>> (1024).to_bytes(10, byteorder='big')222b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'223>>> (-1024).to_bytes(10, byteorder='big', signed=True)224b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'225>>> x = 1000226>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')227b'\xe8\x03'228```229230Целое число представляется с использованием *length* байтов, по умолчанию – 1. Если целое число невозможно представить заданным количеством байтов, вызывается исключение [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError).231232Аргумент *byteorder* определяет порядок байтов для представления целого числа, по умолчанию – `"big"`. Если *byteorder* равен `"big"`, старший байт находится в начале массива байтов. Если *byteorder* равен `"little"`, старший байт находится в конце массива байтов.233234Аргумент *signed* определяет, используется ли дополнительный код для представления целого числа. Если *signed* равен `False` и передано отрицательное целое число, вызывается исключение [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError). Значение по умолчанию для *signed* – `False`.235236Значения по умолчанию можно использовать для удобного преобразования целого числа в однобайтовый объект:237238```python239>>> (65).to_bytes()240b'A'241```242243Однако при использовании аргументов по умолчанию не следует пытаться преобразовать значение больше 255, иначе будет вызвано исключение [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError).244245Эквивалентно следующему:246247```python248def to_bytes(n, length=1, byteorder='big', signed=False):249    if byteorder == 'little':250        order = range(length)251    elif byteorder == 'big':252        order = reversed(range(length))253    else:254        raise ValueError("byteorder must be either 'little' or 'big'")255256    return bytes((n >> i*8) & 0xff for i in order)257```258259Добавлено в версии 3.2.260261Изменено в версии 3.11: Добавлены значения аргументов по умолчанию для `length` и `byteorder`.262263#### `classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)`264265Возвращает целое число, представленное заданным массивом байтов.266267```python268>>> int.from_bytes(b'\x00\x10', byteorder='big')26916270>>> int.from_bytes(b'\x00\x10', byteorder='little')2714096272>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)273-1024274>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)27564512276>>> int.from_bytes([255, 0, 0], byteorder='big')27716711680278```279280Аргумент *bytes* должен быть либо [bytes-подобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object), либо итерабельным объектом, производящим байты.281282Аргумент *byteorder* определяет порядок байтов для представления целого числа, по умолчанию – `"big"`. Если *byteorder* равен `"big"`, старший байт находится в начале массива байтов. Если *byteorder* равен `"little"`, старший байт находится в конце массива байтов. Чтобы использовать собственный порядок байтов хост-системы, укажите [`sys.byteorder`](https://python-all.ru/3.15/library/sys.html#sys.byteorder) в качестве значения порядка байтов.283284Аргумент *signed* указывает, используется ли дополнительный код для представления целого числа.285286Эквивалентно следующему:287288```python289def from_bytes(bytes, byteorder='big', signed=False):290    if byteorder == 'little':291        little_ordered = list(bytes)292    elif byteorder == 'big':293        little_ordered = list(reversed(bytes))294    else:295        raise ValueError("byteorder must be either 'little' or 'big'")296297    n = sum(b << i*8 for i, b in enumerate(little_ordered))298    if signed and little_ordered and (little_ordered[-1] & 0x80):299        n -= 1 << 8*len(little_ordered)300301    return n302```303304Добавлено в версии 3.2.305306Изменено в версии 3.11: Добавлено значение аргумента по умолчанию для `byteorder`.307308#### `int.as_integer_ratio()`309310Возвращает пару целых чисел, отношение которых равно исходному целому числу, и знаменатель положителен. Целочисленное отношение целых чисел всегда представляет собой само целое число в качестве числителя и `1` в качестве знаменателя.311312Добавлено в версии 3.8.313314#### `int.is_integer()`315316Возвращает `True`. Существует для совместимости с утиной типизацией с [`float.is_integer()`](https://python-all.ru/3.15/library/stdtypes.html#float.is_integer).317318Добавлено в версии 3.12.319320### Дополнительные методы float321322Тип float реализует [`numbers.Real`](https://python-all.ru/3.15/library/numbers.html#numbers.Real) [абстрактный базовый класс](https://python-all.ru/3.15/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.323324#### `classmethod float.from_number(x)`325326Метод класса, возвращающий число с плавающей запятой, построенное из числа *x*.327328Если аргумент является целым числом или числом с плавающей запятой, возвращается число с плавающей запятой с тем же значением (в пределах точности чисел с плавающей запятой Python). Если аргумент выходит за пределы диапазона чисел с плавающей запятой Python, будет вызвано исключение [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError).329330Для произвольного объекта Python `x`, `float.from_number(x)` делегирует вызов `x.__float__()`. Если [`__float__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__float__) не определён, то используется [`__index__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__index__).331332Добавлено в версии 3.14.333334#### `float.as_integer_ratio()`335336Возвращает пару целых чисел, отношение которых точно равно исходному числу с плавающей запятой. Отношение представлено в несократимом виде и имеет положительный знаменатель. Вызывает [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError) для бесконечности и [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError) для NaN.337338#### `float.is_integer()`339340Возвращает `True`, если экземпляр float является конечным и имеет целочисленное значение, и `False` в противном случае:341342```python343>>> (-2.0).is_integer()344True345>>> (3.2).is_integer()346False347```348349Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python внутренне хранятся в двоичном виде, преобразование числа с плавающей запятой в строку *decimal* и обратно обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точно представлять и задавать числа с плавающей запятой. Это может быть полезно при отладке и в численных расчётах.350351#### `float.hex()`352353Возвращает представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой это представление всегда будет содержать ведущий `0x` и завершающий `p` и экспоненту.354355#### `classmethod float.fromhex(s)`356357Метод класса, возвращающий число с плавающей запятой, представленное шестнадцатеричной строкой *s*. Строка *s* может содержать начальные и конечные пробелы.358359Обратите внимание, что [`float.hex()`](https://python-all.ru/3.15/library/stdtypes.html#float.hex) – это метод экземпляра, а [`float.fromhex()`](https://python-all.ru/3.15/library/stdtypes.html#float.fromhex) – метод класса.360361Шестнадцатеричная строка имеет вид:362363```python364[sign] ['0x'] integer ['.' fraction] ['p' exponent]365```366367где необязательный `sign` может быть либо `+`, либо `-`, `integer` и `fraction` – строки шестнадцатеричных цифр, а `exponent` – десятичное целое с необязательным ведущим знаком. Регистр не имеет значения, и должна быть хотя бы одна шестнадцатеричная цифра в целой части либо в дробной. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и выше. В частности, результат [`float.hex()`](https://python-all.ru/3.15/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде C или Java, а шестнадцатеричные строки, созданные символом формата `%a` в C или `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.15/library/stdtypes.html#float.fromhex).368369Обратите внимание, что экспонента записывается в десятичном, а не шестнадцатеричном виде, и что она указывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка `0x3.a7p10` представляет число с плавающей запятой `(3 + 10./16 + 7./16**2) * 2.0**10`, или `3740.0`:370371```python372>>> float.fromhex('0x3.a7p10')3733740.0374```375376Применение обратного преобразования к `3740.0` даёт другую шестнадцатеричную строку, представляющую то же число:377378```python379>>> float.hex(3740.0)380'0x1.d380000000000p+11'381```382383### Дополнительные методы для complex384385Тип `complex` реализует [`numbers.Complex`](https://python-all.ru/3.15/library/numbers.html#numbers.Complex) [абстрактный базовый класс](https://python-all.ru/3.15/glossary.html#term-abstract-base-class). `complex` также имеет следующие дополнительные методы.386387#### `classmethod complex.from_number(x)`388389Метод класса для преобразования числа в комплексное число.390391Для обычного объекта Python `x` метод `complex.from_number(x)` делегирует вызов `x.__complex__()`. Если [`__complex__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__complex__) не определён, то используется [`__float__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__float__). Если `__float__()` не определён, то используется [`__index__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__index__).392393Добавлено в версии 3.14.394395### Хеширование числовых типов396397Для чисел `x` и `y`, возможно разных типов, требуется, чтобы `hash(x) == hash(y)` всякий раз, когда `x == y` (см. документацию метода [`__hash__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__hash__) для подробностей). Для простоты реализации и эффективности для различных числовых типов (включая [`int`](https://python-all.ru/3.15/library/functions.html#int), [`float`](https://python-all.ru/3.15/library/functions.html#float), [`decimal.Decimal`](https://python-all.ru/3.15/library/decimal.html#decimal.Decimal) и [`fractions.Fraction`](https://python-all.ru/3.15/library/fractions.html#fractions.Fraction)) хеш Python для числовых типов основан на одной математической функции, определённой для любого рационального числа, и, следовательно, применим ко всем экземплярам `int` и `fractions.Fraction`, а также ко всем конечным экземплярам `float` и `decimal.Decimal`. По существу, эта функция задаётся приведением по модулю `P` для фиксированного простого числа `P`. Значение `P` доступно в Python как атрибут [`modulus`](https://python-all.ru/3.15/library/sys.html#sys.hash_info.modulus) объекта [`sys.hash_info`](https://python-all.ru/3.15/library/sys.html#sys.hash_info).398399**Деталь реализации CPython:** В настоящее время используется простое число `P = 2**31 - 1` на машинах с 32-битными C longs и `P = 2**61 - 1` на машинах с 64-битными C longs.400401Вот подробные правила:402403- Если `x = m / n` – неотрицательное рациональное число и `n` не делится на `P`, определим `hash(x)` как `m * invmod(n, P) % P`, где `invmod(n, P)` даёт обратное к `n` по модулю `P`.404- Если `x = m / n` – неотрицательное рациональное число и `n` делится на `P` (но `m` не делится), то `n` не имеет обратного по модулю `P`, и вышеуказанное правило не применяется; в этом случае определим `hash(x)` как константу `sys.hash_info.inf`.405- Если `x = m / n` – отрицательное рациональное число, определим `hash(x)` как `-hash(-x)`. Если полученный хеш равен `-1`, заменим его на `-2`.406- Конкретные значения `sys.hash_info.inf` и `-sys.hash_info.inf` используются как хеши для положительной бесконечности и отрицательной бесконечности (соответственно).407- Для комплексного числа [`complex`](https://python-all.ru/3.15/library/functions.html#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`.408409Для пояснения вышеуказанных правил приведём пример кода Python, эквивалентного встроенной функции hash, для вычисления хеша рационального числа, [`float`](https://python-all.ru/3.15/library/functions.html#float) или [`complex`](https://python-all.ru/3.15/library/functions.html#complex):410411```python412import sys, math413414def hash_fraction(m, n):415    """Вычислить хеш рационального числа m / n.416417    Предполагается, что m и n – целые числа, n положительное.418    Эквивалентно hash(fractions.Fraction(m, n)).419420    """421    P = sys.hash_info.modulus422    # Удалить общие делители P.  (Необязательно, если m и n уже взаимно просты.)423    while m % P == n % P == 0:424        m, n = m // P, n // P425426    if n % P == 0:427        hash_value = sys.hash_info.inf428    else:429        # Малая теорема Ферма: pow(n, P-1, P) равно 1, поэтому430        # pow(n, P-2, P) даёт обратный элемент n по модулю P.431        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P432    if m < 0:433        hash_value = -hash_value434    if hash_value == -1:435        hash_value = -2436    return hash_value437438def hash_float(x):439    """Вычислить хеш числа с плавающей запятой x."""440441    if math.isnan(x):442        return object.__hash__(x)443    elif math.isinf(x):444        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf445    else:446        return hash_fraction(*x.as_integer_ratio())447448def hash_complex(z):449    """Вычислить хеш комплексного числа z."""450451    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)452    # выполнить знаковое приведение по модулю 2**sys.hash_info.width453    M = 2**(sys.hash_info.width - 1)454    hash_value = (hash_value & (M - 1)) - (hash_value & M)455    if hash_value == -1:456        hash_value = -2457    return hash_value458```459460## Булев тип - [`bool`](https://python-all.ru/3.15/library/functions.html#bool)461462Булевы значения представляют истинностные значения. Тип [`bool`](https://python-all.ru/3.15/library/functions.html#bool) имеет ровно два константных экземпляра: `True` и `False`.463464Встроенная функция [`bool()`](https://python-all.ru/3.15/library/functions.html#bool) преобразует любое значение в булево, если значение можно интерпретировать как истинностное (см. раздел [Проверка истинности значений](https://python-all.ru/3.15/library/stdtypes.html#truth) выше).465466Для логических операций используйте [логические операторы](https://python-all.ru/3.15/library/stdtypes.html#boolean) `and`, `or` и `not`. При применении побитовых операторов `&`, `|`, `^` к двум булевым значениям они возвращают bool, эквивалентный логическим операциям «and», «or», «xor». Однако логические операторы `and`, `or` и `!=` следует предпочитать `&`, `|` и `^`.467468Устарело с версии 3.12: Использование оператора побитовой инверсии `~` устарело и вызовет ошибку в Python 3.16.469470[`bool`](https://python-all.ru/3.15/library/functions.html#bool) является подклассом [`int`](https://python-all.ru/3.15/library/functions.html#int) (см. [Числовые типы – int, float, complex](https://python-all.ru/3.15/library/stdtypes.html#typesnumeric)). В многих числовых контекстах `False` и `True` ведут себя как целые числа 0 и 1 соответственно. Однако полагаться на это не рекомендуется; вместо этого используйте явное преобразование с помощью [`int()`](https://python-all.ru/3.15/library/functions.html#int).471472## Типы итераторов473474Python поддерживает концепцию итерации по контейнерам. Это реализовано с помощью двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают методы итерации.475476Для контейнерных объектов необходимо определить один метод, чтобы обеспечить поддержку [итерируемости](https://python-all.ru/3.15/glossary.html#term-iterable):477478#### `container.__iter__()`479480Возвращает объект [итератора](https://python-all.ru/3.15/glossary.html#term-iterator). Объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные типы итерации, можно предоставить дополнительные методы для запроса итераторов этих типов. (Пример объекта, поддерживающего несколько форм итерации – древовидная структура, поддерживающая обход как в ширину, так и в глубину.) Этот метод соответствует слоту [`tp_iter`](https://python-all.ru/3.15/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.481482Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:483484#### `iterator.__iter__()`485486Возвращает сам объект [итератора](https://python-all.ru/3.15/glossary.html#term-iterator). Это необходимо, чтобы и контейнеры, и итераторы можно было использовать с операторами [`for`](https://python-all.ru/3.15/reference/compound_stmts.html#for) и [`in`](https://python-all.ru/3.15/reference/expressions.html#in). Этот метод соответствует слоту [`tp_iter`](https://python-all.ru/3.15/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.487488#### `iterator.__next__()`489490Возвращает следующий элемент из [итератора](https://python-all.ru/3.15/glossary.html#term-iterator). Если элементов больше нет, вызывает исключение [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration). Этот метод соответствует слоту [`tp_iternext`](https://python-all.ru/3.15/c-api/typeobj.html#c.PyTypeObject.tp_iternext) структуры типа для объектов Python в Python/C API.491492Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.493494Как только метод [`__next__()`](https://python-all.ru/3.15/library/stdtypes.html#iterator.__next__) итератора вызывает [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.495496### Типы генераторов497498[Генераторы](https://python-all.ru/3.15/glossary.html#term-generator) Python предоставляют удобный способ реализации протокола итератора. Если метод [`__iter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iter__) объекта контейнера реализован как генератор, он автоматически вернет объект итератора (технически объект генератора), предоставляющий методы [`__iter__()`](https://python-all.ru/3.15/library/stdtypes.html#iterator.__iter__) и [`__next__()`](https://python-all.ru/3.15/reference/expressions.html#generator.__next__). Дополнительную информацию о генераторах можно найти в [документации по yield expression](https://python-all.ru/3.15/reference/expressions.html#yieldexpr).499500## Типы последовательностей – [`list`](https://python-all.ru/3.15/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), [`range`](https://python-all.ru/3.15/library/stdtypes.html#range)501502Существуют три основных типа последовательностей: списки, кортежи и объекты range. Дополнительные типы последовательностей, предназначенные для обработки [двоичных данных](https://python-all.ru/3.15/library/stdtypes.html#binaryseq) и [текстовых строк](https://python-all.ru/3.15/library/stdtypes.html#textseq), описаны в отдельных разделах.503504### Общие операции с последовательностями505506Операции, перечисленные в следующей таблице, поддерживаются большинством типов последовательностей, как изменяемых, так и неизменяемых. ABC [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence) предоставляется, чтобы упростить корректную реализацию этих операций в пользовательских типах последовательностей.507508В этой таблице перечислены операции с последовательностями, отсортированные по возрастанию приоритета. В таблице *s* и *t* – последовательности одного типа, *n*, *i*, *j* и *k* – целые числа, а *x* – произвольный объект, удовлетворяющий любым ограничениям на тип и значение, накладываемым *s*.509510Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` (конкатенация) и `*` (повторение) имеют тот же приоритет, что и соответствующие числовые операции. [\[3\]](https://python-all.ru/3.15/library/stdtypes.html#id14)511512| Операция | Результат | Примечания |513| --- | --- | --- |514| `x in s` | `True`, если элемент последовательности *s* равен *x*, иначе `False` | (1) |515| `x not in s` | `False`, если элемент последовательности *s* равен *x*, иначе `True` | (1) |516| `s + t` | конкатенация *s* и *t* | (6)(7) |517| `s * n` или `n * s` | эквивалентно сложению *s* с собой *n* раз | (2)(7) |518| `s[i]` | *i*-й элемент *s*, начиная с 0 | (3)(8) |519| `s[i:j]` | срез *s* от *i* до *j* | (3)(4) |520| `s[i:j:k]` | срез *s* от *i* до *j* с шагом *k* | (3)(5) |521| `len(s)` | длина *s* |  |522| `min(s)` | наименьший элемент *s* |  |523| `max(s)` | наибольший элемент *s* |  |524525Последовательности одного типа также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равен, а две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в [Comparisons](https://python-all.ru/3.15/reference/expressions.html#comparisons) в справочнике по языку.)526527Прямые и обратные итераторы по изменяемым последовательностям обращаются к значениям по индексу. Этот индекс будет продолжать двигаться вперёд (или назад), даже если базовая последовательность изменяется. Итератор завершается только при возникновении [`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError) или [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration) (или когда индекс становится меньше нуля).528529Примечания:5305311. Хотя операции `in` и `not in` в общем случае используются только для простой проверки на вхождение, некоторые специализированные последовательности (например, [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray)) также используют их для проверки на подпоследовательность:532533   ```python534   >>> "gg" in "eggs"535   True536   ```5372. Значения *n* меньше `0` трактуются как `0` (что даёт пустую последовательность того же типа, что и *s*). Обратите внимание: элементы последовательности *s* не копируются; на них ссылаются многократно. Это часто преследует начинающих программистов Python; рассмотрите:538539   ```python540   >>> lists = [[]] * 3541   >>> lists542   [[], [], []]543   >>> lists[0].append(3)544   >>> lists545   [[3], [3], [3]]546   ```547548   Произошло следующее: `[[]]` – это список из одного элемента, содержащего пустой список, поэтому все три элемента `[[]] * 3` являются ссылками на этот единственный пустой список. Изменение любого из элементов `lists` изменяет этот единственный список. Создать список из разных списков можно так:549550   ```python551   >>> lists = [[] for i in range(3)]552   >>> lists[0].append(3)553   >>> lists[1].append(5)554   >>> lists[2].append(7)555   >>> lists556   [[3], [5], [7]]557   ```558559   Подробное объяснение доступно в разделе FAQ [Как создать многомерный список?](https://python-all.ru/3.15/faq/programming.html#faq-multidimensional-list).5603. Если *i* или *j* отрицательное, индекс отсчитывается от конца последовательности *s*: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание: `-0` по-прежнему равно `0`.5614. Срез последовательности *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, для которых выполняется `i <= k < j`.562563   - Если *i* опущено или равно `None`, используется `0`.564   - Если *j* опущено или равно `None`, используется `len(s)`.565   - Если *i* или *j* меньше `-len(s)`, используется `0`.566   - Если *i* или *j* больше `len(s)`, используется `len(s)`.567   - Если *i* больше или равно *j*, срез пуст.5685. The slice of *s* from *i* to *j* with step *k* is defined as the sequence of items with index `x = i + n*k` such that `0 <= n < (j-i)/k`. In other words, the indices are `i`, `i+k`, `i+2*k`, `i+3*k` and so on, stopping when *j* is reached (but never including *j*). When *k* is positive, *i* and *j* are reduced to `len(s)` if they are greater. When *k* is negative, *i* and *j* are reduced to `len(s) - 1` if they are greater. If *i* or *j* are omitted or `None`, they become “end” values (which end depends on the sign of *k*). Note, *k* cannot be zero. If *k* is `None`, it is treated like `1`.5696. Конкатенация неизменяемых последовательностей всегда приводит к созданию нового объекта. Это означает, что построение последовательности путём многократной конкатенации будет иметь квадратичную временную сложность от общей длины последовательности. Чтобы получить линейную сложность, следует перейти к одному из следующих вариантов:570571   - при конкатенации объектов [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) можно собрать список, а затем использовать [`str.join()`](https://python-all.ru/3.15/library/stdtypes.html#str.join) в конце или же записывать данные в экземпляр [`io.StringIO`](https://python-all.ru/3.15/library/io.html#io.StringIO) и получить его значение по завершении572   - при конкатенации объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) можно аналогично использовать [`bytes.join()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.join) или [`io.BytesIO`](https://python-all.ru/3.15/library/io.html#io.BytesIO), либо выполнять конкатенацию на месте с объектом [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray). Объекты `bytearray` являются изменяемыми и обладают эффективным механизмом предварительного выделения памяти573   - при конкатенации объектов [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) лучше расширять объект [`list`](https://python-all.ru/3.15/library/stdtypes.html#list)574   - для других типов – изучите документацию соответствующего класса5757. Некоторые типы последовательностей (например, [`range`](https://python-all.ru/3.15/library/stdtypes.html#range)) поддерживают только такие последовательности элементов, которые подчиняются определённым шаблонам, и поэтому не поддерживают конкатенацию или повторение последовательностей.5768. Исключение [`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError) возникает, если *i* выходит за пределы диапазона последовательности.577578Методы последовательностей579580Типы последовательностей также поддерживают следующие методы:581582#### `sequence.count(value, /)`583584Возвращает общее количество вхождений *value* в последовательности *sequence*.585586#### `sequence.index(value[, start[, stop]])`587588Возвращает индекс первого вхождения *value* в последовательности *sequence*.589590Вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если *value* не найден в *sequence*.591592Аргументы *start* и *stop* позволяют эффективно искать подпоследовательности, начиная с *start* и заканчивая *stop*. Это примерно эквивалентно `start + sequence[start:stop].index(value)`, но без копирования данных.593594> **Внимание**595>596> Не все типы последовательностей поддерживают передачу аргументов *start* и *stop*.597598### Неизменяемые типы последовательностей599600Единственная операция, которую неизменяемые последовательности обычно реализуют, но которой нет у изменяемых, – это поддержка встроенной функции [`hash()`](https://python-all.ru/3.15/library/functions.html#hash).601602Эта поддержка позволяет использовать неизменяемые последовательности, такие как экземпляры [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), в качестве ключей [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict) и хранить их в экземплярах [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset).603604Попытка вычислить хеш неизменяемой последовательности, содержащей нехешируемые значения, приведёт к [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).605606### Изменяемые типы последовательностей607608В следующей таблице приведены операции, определённые для изменяемых типов последовательностей. ABC [`collections.abc.MutableSequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSequence) предоставляется для упрощения корректной реализации этих операций в пользовательских типах последовательностей.609610В таблице *s* – экземпляр изменяемого типа последовательности, *t* – любой итерируемый объект, а *x* – произвольный объект, удовлетворяющий всем ограничениям по типу и значению, накладываемым *s* (например, [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray) принимает только целые числа, удовлетворяющие ограничению по значению `0 <= x <= 255`).611612| Операция | Результат | Примечания |613| --- | --- | --- |614| `s[i] = x` | элемент *i* из *s* заменяется на *x* |  |615| `del s[i]` | удаляет элемент *i* из *s* |  |616| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* |  |617| `del s[i:j]` | удаляет элементы `s[i:j]` из списка (то же, что и `s[i:j] = []`) |  |618| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами из *t* | (1) |619| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка |  |620| `s += t` | расширяет *s* содержимым *t* (в основном то же, что и `s[len(s):len(s)] = t`) |  |621| `s *= n` | обновляет *s*, повторяя его содержимое *n* раз | (2) |622623Примечания:6246251. Если *k* не равно `1`, то *t* должно иметь ту же длину, что и заменяемый срез.6262. Значение *n* – целое число или объект, реализующий [`__index__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__index__). Нулевые и отрицательные значения *n* очищают последовательность. Элементы последовательности не копируются; на них делаются множественные ссылки, как описано для `s * n` в разделе [Общие операции с последовательностями](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common).627628Методы изменяемых последовательностей629630Изменяемые типы последовательностей также поддерживают следующие методы:631632#### `sequence.append(value, /)`633634Добавляет *value* в конец последовательности. Это равносильно записи `seq[len(seq):len(seq)] = [value]`.635636#### `sequence.clear()`637638Добавлено в версии 3.3.639640Удаляет все элементы из *sequence*. Это равносильно записи `del sequence[:]`.641642#### `sequence.copy()`643644Добавлено в версии 3.3.645646Создаёт поверхностную копию *sequence*. Это равносильно записи `sequence[:]`.647648> **Подсказка**649>650> Метод `copy()` не является частью [`MutableSequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSequence) [`ABC`](https://python-all.ru/3.15/library/abc.html#abc.ABC), но большинство конкретных изменяемых типов последовательностей его предоставляют.651652#### `sequence.extend(iterable, /)`653654Расширяет *sequence* содержимым *iterable*. В основном это то же самое, что запись `seq[len(seq):len(seq)] = iterable`.655656#### `sequence.insert(index, value, /)`657658Вставляет *value* в *sequence* по указанному *index*. Это равносильно записи `sequence[index:index] = [value]`.659660#### `sequence.pop(index=-1, /)`661662Извлекает элемент по *index* и также удаляет его из *sequence*. По умолчанию удаляется и возвращается последний элемент *sequence*.663664#### `sequence.remove(value, /)`665666Удаляет первый элемент из *sequence*, для которого `sequence[i] == value`.667668Вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если *value* не найден в *sequence*.669670#### `sequence.reverse()`671672Изменяет порядок элементов *sequence* на обратный на месте. Этот метод обеспечивает экономию памяти при обращении большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он возвращает `None`.673674### Списки675676Списки – это изменяемые последовательности, обычно используемые для хранения коллекций однородных элементов (степень однородности может варьироваться в зависимости от приложения).677678#### `class list(iterable=(), /)`679680Списки можно создать несколькими способами:681682- Используя пару квадратных скобок для обозначения пустого списка: `[]`683- Используя квадратные скобки, разделяя элементы запятыми: `[a]`, `[a, b, c]`684- Используя списковое включение: `[x for x in iterable]`685- Используя конструктор типа: `list()` или `list(iterable)`686687Конструктор создаёт список, элементы которого совпадают с элементами *итерируемого объекта* и располагаются в том же порядке. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *итерируемый объект* уже является списком, создаётся и возвращается его копия (аналогично `iterable[:]`). Например, `list('abc')` возвращает `['a', 'b', 'c']`, а `list( (1, 2, 3) )` возвращает `[1, 2, 3]`. Если аргумент не указан, конструктор создаёт новый пустой список – `[]`.688689Многие другие операции также создают списки, включая встроенную функцию [`sorted()`](https://python-all.ru/3.15/library/functions.html#sorted).690691Списки являются [дженериками](https://python-all.ru/3.15/library/typing.html#generics) по типам своих элементов.692693Списки реализуют все [общие](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common) и [изменяемые](https://python-all.ru/3.15/library/stdtypes.html#typesseq-mutable) операции последовательностей. Списки также предоставляют следующий дополнительный метод:694695#### `sort(*, key=None, reverse=False)`696697Этот метод сортирует список на месте, используя только `<` сравнений между элементами. Исключения не подавляются – если какая-либо операция сравнения завершится ошибкой, вся сортировка завершится ошибкой (и список, скорее всего, останется в частично изменённом состоянии).698699`sort()` принимает два аргумента, которые могут быть переданы только по ключевому слову ([аргументы только по ключевому слову](https://python-all.ru/3.15/glossary.html#keyword-only-parameter)):700701*key* задаёт функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка (например, `key=str.lower`). Ключ для каждого элемента списка вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию `None` означает, что элементы списка сортируются напрямую, без вычисления отдельного ключа.702703Утилита [`functools.cmp_to_key()`](https://python-all.ru/3.15/library/functools.html#functools.cmp_to_key) позволяет преобразовать функцию сравнения *cmp* в стиле 2.x в функцию *key*.704705*reverse* – булево значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.706707Этот метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он не возвращает отсортированную последовательность (используйте [`sorted()`](https://python-all.ru/3.15/library/functions.html#sorted) для явного запроса нового отсортированного списка).708709Метод `sort()` гарантированно устойчив. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые считаются равными – это полезно при многоэтапной сортировке (например, сначала по отделу, затем по уровню зарплаты).710711Примеры сортировки и краткое руководство по сортировке см. в [Методы сортировки](https://python-all.ru/3.15/howto/sorting.html#sortinghowto).712713**Особенность реализации CPython:** Во время сортировки списка результат попыток изменить или даже проверить список не определён. Реализация Python на C делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.714715> **См. также**716>717> Подробную информацию о гарантиях потокобезопасности для объектов [`list`](https://python-all.ru/3.15/library/stdtypes.html#list) см. в [Потокобезопасность объектов списка](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-list).718719### Кортежи720721Кортежи – это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (например, пар, возвращаемых встроенной функцией [`enumerate()`](https://python-all.ru/3.15/library/functions.html#enumerate)). Кортежи также используются в случаях, когда требуется неизменяемая последовательность однородных данных (например, для хранения в экземпляре [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) или [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict)).722723#### `class tuple(iterable=(), /)`724725Кортежи можно создать несколькими способами:726727- Используя пару круглых скобок для обозначения пустого кортежа: `()`728- Используя завершающую запятую для кортежа из одного элемента: `a,` или `(a,)`729- Разделяя элементы запятыми: `a, b, c` или `(a, b, c)`730- Используя встроенную функцию [`tuple()`](https://python-all.ru/3.15/library/stdtypes.html#tuple): `tuple()` или `tuple(iterable)`731732Конструктор создаёт кортеж, элементы которого совпадают с элементами *итерируемого объекта* и располагаются в том же порядке. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *итерируемый объект* уже является кортежем, он возвращается без изменений. Например, `tuple('abc')` возвращает `('a', 'b', 'c')`, а `tuple( [1, 2, 3] )` возвращает `(1, 2, 3)`. Если аргумент не указан, конструктор создаёт новый пустой кортеж – `()`.733734Обратите внимание, что кортеж создаётся запятой, а не круглыми скобками. Скобки необязательны, за исключением пустого кортежа или случаев, когда они необходимы для устранения синтаксической неоднозначности. Например, `f(a, b, c)` – это вызов функции с тремя аргументами, а `f((a, b, c))` – это вызов функции с одним аргументом – кортежем из трёх элементов.735736Кортежи реализуют все [общие](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common) операции последовательностей.737738Кортежи являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по типам своего содержимого. Для получения дополнительной информации обратитесь к [документации по typing, посвящённой аннотированию кортежей](https://python-all.ru/3.15/library/typing.html#annotating-tuples).739740Для гетерогенных коллекций данных, где доступ по имени понятнее, чем доступ по индексу, [`collections.namedtuple()`](https://python-all.ru/3.15/library/collections.html#collections.namedtuple) может быть более подходящим выбором, чем простой объект кортежа.741742### Диапазоны743744Тип [`range`](https://python-all.ru/3.15/library/stdtypes.html#range) представляет собой неизменяемую последовательность чисел и обычно используется для цикла с определённым числом итераций в циклах [`for`](https://python-all.ru/3.15/reference/compound_stmts.html#for).745746#### `class range(stop, /)`747748#### `class range(start, stop, step=1, /)`749750Аргументы конструктора range должны быть целыми числами (либо встроенными [`int`](https://python-all.ru/3.15/library/functions.html#int), либо любым объектом, реализующим специальный метод [`__index__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__index__)). Если аргумент *step* опущен, по умолчанию используется `1`. Если аргумент *start* опущен, по умолчанию используется `0`. Если *step* равен нулю, возбуждается [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError).751752Для положительного *step* содержимое диапазона `r` определяется формулой `r[i] = start + step*i`, где `i >= 0` и `r[i] < stop`.753754Для отрицательного *step* содержимое диапазона по-прежнему определяется формулой `r[i] = start + step*i`, но ограничениями являются `i >= 0` и `r[i] > stop`.755756Объект диапазона будет пустым, если `r[0]` не удовлетворяет ограничению значения. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексация с конца последовательности, определяемой положительными индексами.757758Диапазоны, содержащие абсолютные значения больше [`sys.maxsize`](https://python-all.ru/3.15/library/sys.html#sys.maxsize), допускаются, но некоторые функции (например [`len()`](https://python-all.ru/3.15/library/functions.html#len)) могут возбуждать [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError).759760Примеры диапазонов:761762```python763>>> list(range(10))764[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]765>>> list(range(1, 11))766[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]767>>> list(range(0, 30, 5))768[0, 5, 10, 15, 20, 25]769>>> list(range(0, 10, 3))770[0, 3, 6, 9]771>>> list(range(0, -10, -1))772[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]773>>> list(range(0))774[]775>>> list(range(1, 0))776[]777```778779Диапазоны реализуют все [общие](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common) операции последовательностей, за исключением конкатенации и повторения (ввиду того, что объекты диапазонов могут представлять только последовательности, следующие строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).780781#### `start`782783Значение параметра *start* (или `0`, если параметр не был указан)784785#### `stop`786787Значение параметра *stop*788789#### `step`790791Значение параметра *step* (или `1`, если параметр не был указан)792793Преимущество типа [`range`](https://python-all.ru/3.15/library/stdtypes.html#range) перед обычными [`list`](https://python-all.ru/3.15/library/stdtypes.html#list) или [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) заключается в том, что объект `range` всегда занимает одинаковый (небольшой) объём памяти, независимо от размера диапазона, который он представляет (поскольку он хранит только значения `start`, `stop` и `step`, вычисляя отдельные элементы и поддиапазоны по мере необходимости).794795Объекты диапазонов реализуют абстрактный базовый класс (ABC) [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence) и предоставляет такие возможности, как проверка на вхождение, поиск индекса элемента, срезы и поддержка отрицательных индексов (см. [Типы последовательностей – list, tuple, range](https://python-all.ru/3.15/library/stdtypes.html#typesseq)):796797```python798>>> r = range(0, 20, 2)799>>> r800range(0, 20, 2)801>>> 11 in r802False803>>> 10 in r804True805>>> r.index(10)8065807>>> r[5]80810809>>> r[:5]810range(0, 10, 2)811>>> r[-1]81218813```814815Проверка объектов диапазонов на равенство с `==` и `!=` сравнивает их как последовательности. То есть два объекта диапазонов считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два равных объекта диапазонов могут иметь разные атрибуты [`start`](https://python-all.ru/3.15/library/stdtypes.html#range.start), [`stop`](https://python-all.ru/3.15/library/stdtypes.html#range.stop) и [`step`](https://python-all.ru/3.15/library/stdtypes.html#range.step), например `range(0) == range(2, 1, 3)` или `range(0, 3, 2) == range(0, 4, 2)`.)816817Изменено в версии 3.2: Реализует ABC Sequence. Поддерживает срезы и отрицательные индексы. Проверяет принадлежность объектов [`int`](https://python-all.ru/3.15/library/functions.html#int) за константное время вместо итерации по всем элементам.818819Изменено в версии 3.3: Определяет ‘==’ и ‘!=’ для сравнения объектов диапазонов на основе последовательности значений, которые они определяют (вместо сравнения по идентичности объектов).820821Добавлены атрибуты [`start`](https://python-all.ru/3.15/library/stdtypes.html#range.start), [`stop`](https://python-all.ru/3.15/library/stdtypes.html#range.stop) и [`step`](https://python-all.ru/3.15/library/stdtypes.html#range.step).822823> **См. также**824>825> - Рецепт [linspace](https://python-all.ru/3.15/library/stdtypes.html) показывает, как реализовать ленивую версию диапазона, подходящую для приложений с плавающей запятой.826827## Сводка методов текстовых и двоичных типов последовательностей828829В следующей таблице приведены методы текстовых и двоичных типов последовательностей, сгруппированные по категориям.830831| Категория | Методы [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) | Методы [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray) |  |  |832| --- | --- | --- | --- | --- |833| Форматирование | [`str.format()`](https://python-all.ru/3.15/library/stdtypes.html#str.format) |  |  |  |834| [`str.format_map()`](https://python-all.ru/3.15/library/stdtypes.html#str.format_map) |  |  |  |  |835| [f-строки](https://python-all.ru/3.15/reference/lexical_analysis.html#f-strings) |  |  |  |  |836| [Строковое форматирование в стиле printf](https://python-all.ru/3.15/library/stdtypes.html#old-string-formatting) | [Форматирование байтов в стиле printf](https://python-all.ru/3.15/library/stdtypes.html#bytes-formatting) |  |  |  |837| Поиск и замена | [`str.find()`](https://python-all.ru/3.15/library/stdtypes.html#str.find) | [`str.rfind()`](https://python-all.ru/3.15/library/stdtypes.html#str.rfind) | [`bytes.find()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.find) | [`bytes.rfind()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rfind) |838| [`str.index()`](https://python-all.ru/3.15/library/stdtypes.html#str.index) | [`str.rindex()`](https://python-all.ru/3.15/library/stdtypes.html#str.rindex) | [`bytes.index()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.index) | [`bytes.rindex()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rindex) |  |839| [`str.startswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.startswith) | [`bytes.startswith()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.startswith) |  |  |  |840| [`str.endswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.endswith) | [`bytes.endswith()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.endswith) |  |  |  |841| [`str.count()`](https://python-all.ru/3.15/library/stdtypes.html#str.count) | [`bytes.count()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.count) |  |  |  |842| [`str.replace()`](https://python-all.ru/3.15/library/stdtypes.html#str.replace) | [`bytes.replace()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.replace) |  |  |  |843| Разделение и объединение | [`str.split()`](https://python-all.ru/3.15/library/stdtypes.html#str.split) | [`str.rsplit()`](https://python-all.ru/3.15/library/stdtypes.html#str.rsplit) | [`bytes.split()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.split) | [`bytes.rsplit()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rsplit) |844| [`str.splitlines()`](https://python-all.ru/3.15/library/stdtypes.html#str.splitlines) | [`bytes.splitlines()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.splitlines) |  |  |  |845| [`str.partition()`](https://python-all.ru/3.15/library/stdtypes.html#str.partition) | [`bytes.partition()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.partition) |  |  |  |846| [`str.rpartition()`](https://python-all.ru/3.15/library/stdtypes.html#str.rpartition) | [`bytes.rpartition()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rpartition) |  |  |  |847| [`str.join()`](https://python-all.ru/3.15/library/stdtypes.html#str.join) | [`bytes.join()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.join) |  |  |  |848| Классификация строк | [`str.isalpha()`](https://python-all.ru/3.15/library/stdtypes.html#str.isalpha) | [`bytes.isalpha()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.isalpha) |  |  |849| [`str.isdecimal()`](https://python-all.ru/3.15/library/stdtypes.html#str.isdecimal) |  |  |  |  |850| [`str.isdigit()`](https://python-all.ru/3.15/library/stdtypes.html#str.isdigit) | [`bytes.isdigit()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.isdigit) |  |  |  |851| [`str.isnumeric()`](https://python-all.ru/3.15/library/stdtypes.html#str.isnumeric) |  |  |  |  |852| [`str.isalnum()`](https://python-all.ru/3.15/library/stdtypes.html#str.isalnum) | [`bytes.isalnum()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.isalnum) |  |  |  |853| [`str.isidentifier()`](https://python-all.ru/3.15/library/stdtypes.html#str.isidentifier) |  |  |  |  |854| [`str.islower()`](https://python-all.ru/3.15/library/stdtypes.html#str.islower) | [`bytes.islower()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.islower) |  |  |  |855| [`str.isupper()`](https://python-all.ru/3.15/library/stdtypes.html#str.isupper) | [`bytes.isupper()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.isupper) |  |  |  |856| [`str.istitle()`](https://python-all.ru/3.15/library/stdtypes.html#str.istitle) | [`bytes.istitle()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.istitle) |  |  |  |857| [`str.isspace()`](https://python-all.ru/3.15/library/stdtypes.html#str.isspace) | [`bytes.isspace()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.isspace) |  |  |  |858| [`str.isprintable()`](https://python-all.ru/3.15/library/stdtypes.html#str.isprintable) |  |  |  |  |859| Преобразование регистра | [`str.lower()`](https://python-all.ru/3.15/library/stdtypes.html#str.lower) | [`bytes.lower()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.lower) |  |  |860| [`str.upper()`](https://python-all.ru/3.15/library/stdtypes.html#str.upper) | [`bytes.upper()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.upper) |  |  |  |861| [`str.casefold()`](https://python-all.ru/3.15/library/stdtypes.html#str.casefold) |  |  |  |  |862| [`str.capitalize()`](https://python-all.ru/3.15/library/stdtypes.html#str.capitalize) | [`bytes.capitalize()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.capitalize) |  |  |  |863| [`str.title()`](https://python-all.ru/3.15/library/stdtypes.html#str.title) | [`bytes.title()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.title) |  |  |  |864| [`str.swapcase()`](https://python-all.ru/3.15/library/stdtypes.html#str.swapcase) | [`bytes.swapcase()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.swapcase) |  |  |  |865| Дополнение и удаление символов | [`str.ljust()`](https://python-all.ru/3.15/library/stdtypes.html#str.ljust) | [`str.rjust()`](https://python-all.ru/3.15/library/stdtypes.html#str.rjust) | [`bytes.ljust()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.ljust) | [`bytes.rjust()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rjust) |866| [`str.center()`](https://python-all.ru/3.15/library/stdtypes.html#str.center) | [`bytes.center()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.center) |  |  |  |867| [`str.expandtabs()`](https://python-all.ru/3.15/library/stdtypes.html#str.expandtabs) | [`bytes.expandtabs()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.expandtabs) |  |  |  |868| [`str.strip()`](https://python-all.ru/3.15/library/stdtypes.html#str.strip) | [`bytes.strip()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.strip) |  |  |  |869| [`str.lstrip()`](https://python-all.ru/3.15/library/stdtypes.html#str.lstrip) | [`str.rstrip()`](https://python-all.ru/3.15/library/stdtypes.html#str.rstrip) | [`bytes.lstrip()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.lstrip) | [`bytes.rstrip()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rstrip) |  |870| Преобразование и кодирование | [`str.translate()`](https://python-all.ru/3.15/library/stdtypes.html#str.translate) | [`bytes.translate()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.translate) |  |  |871| [`str.maketrans()`](https://python-all.ru/3.15/library/stdtypes.html#str.maketrans) | [`bytes.maketrans()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.maketrans) |  |  |  |872| [`str.encode()`](https://python-all.ru/3.15/library/stdtypes.html#str.encode) |  |  |  |  |873|  | [`bytes.decode()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.decode) |  |  |  |874875## Тип текстовой последовательности – [`str`](https://python-all.ru/3.15/library/stdtypes.html#str)876877Текстовые данные в Python представлены объектами [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), или *строками*. Строки – неизменяемые [последовательности](https://python-all.ru/3.15/library/stdtypes.html#typesseq) кодовых точек Unicode. Строковые литералы записываются различными способами:878879- Одинарные кавычки: `'allows embedded "double" quotes'`880- Двойные кавычки: `"allows embedded 'single' quotes"`881- Тройные кавычки: `'''Three single quotes'''`, `"""Three double quotes"""`882883Строки в тройных кавычках могут занимать несколько строк – все сопутствующие пробельные символы будут включены в строковый литерал.884885Строковые литералы, являющиеся частью одного выражения и разделённые только пробельными символами, будут неявно объединены в один строковый литерал. То есть `("spam " "eggs") == "spam eggs"`.886887Смотрите [Строковые и байтовые литералы](https://python-all.ru/3.15/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах строковых литералов, включая поддерживаемые [управляющие последовательности](https://python-all.ru/3.15/reference/lexical_analysis.html#escape-sequences) и префикс `r` («сырой»), который отключает обработку большинства управляющих последовательностей.888889Строки также могут быть созданы из других объектов с помощью конструктора [`str`](https://python-all.ru/3.15/library/stdtypes.html#str).890891Поскольку отдельного типа «символ» не существует, индексация строки даёт строку длины 1. То есть для непустой строки *s* выполняется `s[0] == s[0:1]`.892893Также нет изменяемого строкового типа, но [`str.join()`](https://python-all.ru/3.15/library/stdtypes.html#str.join) или [`io.StringIO`](https://python-all.ru/3.15/library/io.html#io.StringIO) можно использовать для эффективного построения строк из нескольких фрагментов.894895Изменено в версии 3.3: Для обратной совместимости с серией Python 2 префикс `u` снова разрешён в строковых литералах. Он не влияет на значение строковых литералов и не может сочетаться с префиксом `r`.896897#### `class str(*, encoding='utf-8', errors='strict')`898899#### `class str(object)`900901#### `class str(object, encoding, errors='strict')`902903#### `class str(object, *, errors)`904905Возвращает [строковое](https://python-all.ru/3.15/library/stdtypes.html#textseq) представление *объекта*. Если *объект* не указан, возвращает пустую строку. В противном случае поведение `str()` зависит от того, указаны ли *encoding* или *errors*, как описано ниже.906907Если не указаны ни *encoding*, ни *errors*, `str(object)` возвращает [`type(object).__str__(object)`](https://python-all.ru/3.15/reference/datamodel.html#object.__str__), которое является «неформальным» или удобным для вывода строковым представлением *объекта*. Для строковых объектов это сама строка. Если *объект* не имеет метода `__str__()`, то [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str) возвращает [`repr(object)`](https://python-all.ru/3.15/library/functions.html#repr).908909Если указан хотя бы один из *encoding* или *errors*, *object* должен быть [байтово-подобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) (например, [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) или [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray)). В этом случае, если *объект* является объектом `bytes` (или `bytearray`), то `str(bytes, encoding, errors)` эквивалентно [`bytes.decode(encoding, errors)`](https://python-all.ru/3.15/library/stdtypes.html#bytes.decode). В противном случае объект bytes, лежащий в основе буферного объекта, получается перед вызовом `bytes.decode()`. Смотрите [Типы двоичных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.15/library/stdtypes.html#binaryseq) и [Протокол буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects) для информации о буферных объектах.910911Передача объекта [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) в [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str) без аргументов *encoding* или *errors* относится к первому случаю возврата неформального строкового представления (см. также параметр командной строки [`-b`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-b) Python). Например:912913```python914>>> str(b'Zoot!')915"b'Zoot!'"916```917918Для получения дополнительной информации о классе `str` и его методах смотрите [Тип текстовой последовательности – str](https://python-all.ru/3.15/library/stdtypes.html#textseq) и раздел [Методы строк](https://python-all.ru/3.15/library/stdtypes.html#string-methods) ниже. Для вывода отформатированных строк смотрите разделы [f-строки](https://python-all.ru/3.15/reference/lexical_analysis.html#f-strings) и [Синтаксис форматной строки](https://python-all.ru/3.15/library/string.html#formatstrings). Кроме того, смотрите раздел [Службы обработки текста](https://python-all.ru/3.15/library/text.html#stringservices).919920### Методы строк921922Строки реализуют все [общие](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common) операции с последовательностями, а также дополнительные методы, описанные ниже.923924Строки также поддерживают два стиля форматирования: один обеспечивает высокую степень гибкости и настройки (см. [`str.format()`](https://python-all.ru/3.15/library/stdtypes.html#str.format), [Синтаксис форматной строки](https://python-all.ru/3.15/library/string.html#formatstrings) и [Пользовательское форматирование строк](https://python-all.ru/3.15/library/string.html#string-formatting)), а другой основан на стиле C `printf`, который работает с более узким набором типов и немного сложнее в правильном использовании, но часто быстрее для тех случаев, с которыми может справиться ([Форматирование строк в стиле printf](https://python-all.ru/3.15/library/stdtypes.html#old-string-formatting)).925926Раздел [Службы обработки текста](https://python-all.ru/3.15/library/text.html#textservices) стандартной библиотеки охватывает ряд других модулей, предоставляющих различные утилиты для работы с текстом (включая поддержку регулярных выражений в модуле [`re`](https://python-all.ru/3.15/library/re.html#module-re)).927928#### `str.capitalize()`929930Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.931932Изменено в версии 3.8: Первый символ теперь переводится в регистр заголовка (titlecase) вместо заглавного. Это означает, что символы типа диграфов будут иметь заглавной только первую букву, а не весь символ.933934#### `str.casefold()`935936Возвращает копию строки, преобразованную для регистронезависимого сравнения. Такие строки могут использоваться для сравнения без учёта регистра.937938Преобразование для регистронезависимого сравнения похоже на приведение к нижнему регистру, но более агрессивно, так как предназначено для удаления всех различий по регистру в строке. Например, немецкая строчная буква `'ß'` эквивалентна `"ss"`. Поскольку она уже в нижнем регистре, [`lower()`](https://python-all.ru/3.15/library/stdtypes.html#str.lower) ничего не сделает с `'ß'`; `casefold()` преобразует её в `"ss"`. Например:939940```pycon941>>> 'straße'.lower()942'straße'943>>> 'straße'.casefold()944'strasse'945```946947Алгоритм приведения к одному регистру [описан в разделе 3.13.3 «Default Case Folding» стандарта Unicode](https://python-all.ru/3.15/library/stdtypes.html).948949Добавлено в версии 3.3.950951#### `str.center(width, fillchar=' ', /)`952953Возвращает строку, выровненную по центру, длины *width*. Заполнение выполняется с помощью указанного *fillchar* (по умолчанию – пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`. Например:954955```python956>>> 'Python'.center(10)957'  Python  '958>>> 'Python'.center(10, '-')959'--Python--'960>>> 'Python'.center(4)961'Python'962```963964#### `str.count(sub[, start[, end]])`965966Возвращает количество непересекающихся вхождений подстроки *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов.967968Если *sub* пуста, возвращает количество пустых строк между символами, что равно длине строки плюс один. Например:969970```python971>>> 'spam, spam, spam'.count('spam')9723973>>> 'spam, spam, spam'.count('spam', 5)9742975>>> 'spam, spam, spam'.count('spam', 5, 10)9761977>>> 'spam, spam, spam'.count('eggs')9780979>>> 'spam, spam, spam'.count('')98017981```982983#### `str.encode(encoding='utf-8', errors='strict')`984985Возвращает строку, закодированную в [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes).986987*encoding* по умолчанию равен `'utf-8'`; список возможных значений см. в [Стандартные кодировки](https://python-all.ru/3.15/library/codecs.html#standard-encodings).988989*errors* управляет обработкой ошибок кодирования. Если `'strict'` (по умолчанию), возбуждается исключение [`UnicodeError`](https://python-all.ru/3.15/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.15/library/codecs.html#codecs.register_error). Подробности см. в [Обработчики ошибок](https://python-all.ru/3.15/library/codecs.html#error-handlers).990991По соображениям производительности значение *errors* не проверяется на корректность, пока не произойдёт ошибка кодирования, не будет включён [Режим разработки Python](https://python-all.ru/3.15/library/devmode.html#devmode) или не будет использована [отладочная сборка](https://python-all.ru/3.15/using/configure.html#debug-build). Например:992993```python994>>> encoded_str_to_bytes = 'Python'.encode()995>>> type(encoded_str_to_bytes)996<class 'bytes'>997>>> encoded_str_to_bytes998b'Python'999```10001001Изменено в версии 3.1: Добавлена поддержка именованных аргументов.10021003Изменено в версии 3.9: Значение аргумента *errors* теперь проверяется в [Режиме разработки Python](https://python-all.ru/3.15/library/devmode.html#devmode) и в [режиме отладки](https://python-all.ru/3.15/using/configure.html#debug-build).10041005#### `str.endswith(suffix[, start[, end]])`10061007Возвращает `True`, если строка заканчивается указанным *suffix*, иначе возвращает `False`. *suffix* также может быть кортежем суффиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение прекращается на этой позиции. Использование *start* и *end* эквивалентно `str[start:end].endswith(suffix)`. Например:10081009```python1010>>> 'Python'.endswith('on')1011True1012>>> 'a tuple of suffixes'.endswith(('at', 'in'))1013False1014>>> 'a tuple of suffixes'.endswith(('at', 'es'))1015True1016>>> 'Python is amazing'.endswith('is', 0, 9)1017True1018```10191020См. также [`startswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.startswith) и [`removesuffix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removesuffix).10211022#### `str.expandtabs(tabsize=8)`10231024Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами в зависимости от текущей позиции и заданного размера табуляции. Позиции табуляции располагаются через каждые *tabsize* символов (по умолчанию 8, что даёт позиции табуляции на колонках 0, 8, 16 и так далее). Для разворачивания строки текущая колонка устанавливается в ноль и строка просматривается посимвольно. Если символ является табуляцией (`\t`), в результат вставляется один или несколько пробелов, пока текущая колонка не станет равна следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символ – перевод строки (`\n`) или возврат каретки (`\r`), он копируется, а текущая колонка сбрасывается в ноль. Любой другой символ копируется без изменений, а текущая колонка увеличивается на единицу независимо от того, как символ представлен при печати. Например:10251026```python1027>>> '01\t012\t0123\t01234'.expandtabs()1028'01      012     0123    01234'1029>>> '01\t012\t0123\t01234'.expandtabs(4)1030'01  012 0123    01234'1031>>> print('01\t012\n0123\t01234'.expandtabs(4))103201  01210330123    012341034```10351036#### `str.find(sub[, start[, end]])`10371038Возвращает наименьший индекс в строке, где подстрока *sub* найдена в пределах среза `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена. Например:10391040```python1041>>> 'spam, spam, spam'.find('sp')104201043>>> 'spam, spam, spam'.find('sp', 5)104461045```10461047См. также [`rfind()`](https://python-all.ru/3.15/library/stdtypes.html#str.rfind) и [`index()`](https://python-all.ru/3.15/library/stdtypes.html#str.index).10481049> **Примечание**1050>1051> Метод `find()` следует использовать только если нужно знать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.15/reference/expressions.html#in):1052>1053> ```python1054> >>> 'Py' in 'Python'1055> True1056> ```10571058#### `str.format(*args, **kwargs)`10591060Выполняет операцию форматирования строки. Строка, для которой вызывается этот метод, может содержать литеральный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию строки, в которой каждое поле замены заменено строковым значением соответствующего аргумента. Например:10611062```pycon1063>>> "The sum of 1 + 2 is {0}".format(1+2)1064'The sum of 1 + 2 is 3'1065>>> "The sum of {a} + {b} is {answer}".format(answer=1+2, a=1, b=2)1066'The sum of 1 + 2 is 3'1067>>> "{1} expects the {0} Inquisition!".format("Spanish", "Nobody")1068'Nobody expects the Spanish Inquisition!'1069```10701071См. [Синтаксис строк формата](https://python-all.ru/3.15/library/string.html#formatstrings) для описания различных опций форматирования, которые можно указать в строках формата.10721073> **Примечание**1074>1075> При форматировании числа ([`int`](https://python-all.ru/3.15/library/functions.html#int), [`float`](https://python-all.ru/3.15/library/functions.html#float), [`complex`](https://python-all.ru/3.15/library/functions.html#complex), [`decimal.Decimal`](https://python-all.ru/3.15/library/decimal.html#decimal.Decimal) и подклассов) с типом `n` (например: `'{:n}'.format(1234)`) функция временно устанавливает локаль `LC_CTYPE` в локаль `LC_NUMERIC` для декодирования полей `decimal_point` и `thousands_sep` объекта `localeconv()`, если они не ASCII или длиннее 1 байта, и локаль `LC_NUMERIC` отличается от локали `LC_CTYPE`. Это временное изменение влияет на другие потоки.10761077Изменено в версии 3.7: При форматировании числа с типом `n` функция временно устанавливает локаль `LC_CTYPE` в локаль `LC_NUMERIC` в некоторых случаях.10781079#### `str.format_map(mapping, /)`10801081Аналогично `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую, а не копируется в [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict). Это полезно, если, например, `mapping` является подклассом словаря:10821083```python1084>>> class Default(dict):1085...     def __missing__(self, key):1086...         return key1087...1088>>> '{name} was born in {country}'.format_map(Default(name='Guido'))1089'Guido was born in country'1090```10911092Добавлено в версии 3.2.10931094#### `str.index(sub[, start[, end]])`10951096Как [`find()`](https://python-all.ru/3.15/library/stdtypes.html#str.find), но возбуждает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если подстрока не найдена. Например:10971098```pycon1099>>> 'spam, spam, spam'.index('spam')110001101>>> 'spam, spam, spam'.index('eggs')1102Traceback (most recent call last):1103  File "<python-input-0>", line 1, in <module>1104    'spam, spam, spam'.index('eggs')1105    ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^1106ValueError: substring not found1107```11081109См. также [`rindex()`](https://python-all.ru/3.15/library/stdtypes.html#str.rindex).11101111#### `str.isalnum()`11121113Возвращает `True`, если все символы строки являются буквенно-цифровыми и в строке есть хотя бы один символ, иначе `False`. Символ `c` считается буквенно-цифровым, если один из следующих вызовов возвращает `True`: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()` или `c.isnumeric()`. Например:11141115```pycon1116>>> 'abc123'.isalnum()1117True1118>>> 'abc123!@#'.isalnum()1119False1120>>> ''.isalnum()1121False1122>>> ' '.isalnum()1123False1124```11251126#### `str.isalpha()`11271128Возвращает `True`, если все символы строки являются буквенными и в строке есть хотя бы один символ, иначе `False`. Буквенными считаются символы, определённые в базе данных символов Юникода как «Letter», т.е. с категорией общего назначения «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства [Alphabetic, определённого в разделе 4.10 «Letters, Alphabetic, and Ideographic» стандарта Юникода](https://python-all.ru/3.15/library/stdtypes.html). Например:11291130```pycon1131>>> 'Letters and spaces'.isalpha()1132False1133>>> 'LettersOnly'.isalpha()1134True1135>>> 'µ'.isalpha()  # не-ASCII символы также могут считаться буквенными1136True1137```11381139См. [Unicode Properties](https://python-all.ru/3.15/howto/unicode.html#unicode-properties).11401141#### `str.isascii()`11421143Возвращает `True`, если строка пуста или все символы строки являются ASCII, иначе `False`. Символы ASCII имеют кодовые точки в диапазоне U+0000-U+007F. Например:11441145```pycon1146>>> 'ASCII characters'.isascii()1147True1148>>> 'µ'.isascii()1149False1150```11511152Добавлено в версии 3.7.11531154#### `str.isdecimal()`11551156Возвращает `True`, если все символы строки являются десятичными цифрами и в строке есть хотя бы один символ, иначе `False`. Десятичные цифры – это символы, которые можно использовать для формирования чисел по основанию 10, например U+0660, ARABIC-INDIC DIGIT ZERO. Формально десятичный символ – это символ из общей категории Юникода «Nd». Например:11571158```pycon1159>>> '0123456789'.isdecimal()1160True1161>>> '٠١٢٣٤٥٦٧٨٩'.isdecimal()  # арабо-индийские цифры от нуля до девяти1162True1163>>> 'alphabetic'.isdecimal()1164False1165```11661167#### `str.isdigit()`11681169Возвращает `True`, если все символы строки являются цифрами и в строке есть хотя бы один символ, иначе `False`. Цифры включают десятичные символы и цифры, требующие специальной обработки, например надстрочные цифры совместимости. Это охватывает цифры, которые не могут использоваться для формирования чисел по основанию 10, такие как [Kharosthi numbers](https://python-all.ru/3.15/library/stdtypes.html). Формально цифра – это символ, имеющий значение свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.11701171Например:11721173```pycon1174>>> '0123456789'.isdigit()1175True1176>>> '٠١٢٣٤٥٦٧٨٩'.isdigit()  # арабо-индийские цифры от нуля до девяти1177True1178>>> '⅕'.isdigit()  # обыкновенная дробь одна пятая1179False1180>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()1181(False, True, True)1182```11831184См. также [`isdecimal()`](https://python-all.ru/3.15/library/stdtypes.html#str.isdecimal) и [`isnumeric()`](https://python-all.ru/3.15/library/stdtypes.html#str.isnumeric).11851186#### `str.isidentifier()`11871188Возвращает `True`, если строка является корректным идентификатором согласно определению языка, раздел [Names (идентификаторы и ключевые слова)](https://python-all.ru/3.15/reference/lexical_analysis.html#identifiers).11891190[`keyword.iskeyword()`](https://python-all.ru/3.15/library/keyword.html#keyword.iskeyword) можно использовать для проверки, является ли строка `s` зарезервированным идентификатором, например [`def`](https://python-all.ru/3.15/reference/compound_stmts.html#def) и [`class`](https://python-all.ru/3.15/reference/compound_stmts.html#class).11911192Пример:11931194```python1195>>> from keyword import iskeyword11961197>>> 'hello'.isidentifier(), iskeyword('hello')1198(True, False)1199>>> 'def'.isidentifier(), iskeyword('def')1200(True, True)1201```12021203#### `str.islower()`12041205Возвращает `True`, если все буквенные символы [\[4\]](https://python-all.ru/3.15/library/stdtypes.html#id15) в строке являются строчными и в строке есть хотя бы один буквенный символ, иначе `False`.12061207#### `str.isnumeric()`12081209Возвращает `True`, если все символы строки являются числовыми символами и в строке есть хотя бы один символ, иначе `False`. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовыми считаются символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric. Например:12101211```pycon1212>>> '0123456789'.isnumeric()1213True1214>>> '٠١٢٣٤٥٦٧٨٩'.isnumeric()  # арабо-индийские цифры от нуля до девяти1215True1216>>> '⅕'.isnumeric()  # обыкновенная дробь одна пятая1217True1218>>> '²'.isdecimal(), '²'.isdigit(),  '²'.isnumeric()1219(False, True, True)1220```12211222См. также [`isdecimal()`](https://python-all.ru/3.15/library/stdtypes.html#str.isdecimal) и [`isdigit()`](https://python-all.ru/3.15/library/stdtypes.html#str.isdigit).12231224#### `str.isprintable()`12251226Возвращает `True`, если все символы строки являются печатными, `False`, если в ней есть хотя бы один непечатный символ.12271228Здесь «печатный» означает, что символ подходит для использования [`repr()`](https://python-all.ru/3.15/library/functions.html#repr) в своём выводе; «непечатный» означает, что `repr()` на встроенных типах будет экранировать символ шестнадцатеричным кодом. Это не влияет на обработку строк, записываемых в [`sys.stdout`](https://python-all.ru/3.15/library/sys.html#sys.stdout) или [`sys.stderr`](https://python-all.ru/3.15/library/sys.html#sys.stderr).12291230Печатные символы – это те, которые в базе данных символов Unicode (см. [`unicodedata`](https://python-all.ru/3.15/library/unicodedata.html#module-unicodedata)) имеют общую категорию из группы Letter, Mark, Number, Punctuation или Symbol (L, M, N, P или S); плюс пробел ASCII 0x20. Непечатные символы – это символы из группы Separator или Other (Z или C), за исключением пробела ASCII.12311232Например:12331234```pycon1235>>> ''.isprintable(), ' '.isprintable()1236(True, True)1237>>> '\t'.isprintable(), '\n'.isprintable()1238(False, False)1239```12401241См. также [`isspace()`](https://python-all.ru/3.15/library/stdtypes.html#str.isspace).12421243#### `str.isspace()`12441245Возвращает `True`, если в строке есть только пробельные символы и в ней есть хотя бы один символ, иначе `False`.12461247Например:12481249```pycon1250>>> ''.isspace()1251False1252>>> ' '.isspace()1253True1254>>> '\t\n'.isspace() # TAB и перевод строки1255True1256>>> '\u3000'.isspace() # Идеографический пробел1257True1258```12591260Символ считается *пробельным*, если в базе данных символов Unicode (см. [`unicodedata`](https://python-all.ru/3.15/library/unicodedata.html#module-unicodedata)) его общая категория – `Zs` («Separator, space») или его двунаправленный класс – один из `WS`, `B` или `S`.12611262См. также [`isprintable()`](https://python-all.ru/3.15/library/stdtypes.html#str.isprintable).12631264#### `str.istitle()`12651266Возвращает `True`, если строка записана в заголовочном регистре и содержит хотя бы один символ. Например, прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. В противном случае возвращает `False`.12671268Например:12691270```pycon1271>>> 'Spam, Spam, Spam'.istitle()1272True1273>>> 'spam, spam, spam'.istitle()1274False1275>>> 'SPAM, SPAM, SPAM'.istitle()1276False1277```12781279См. также [`title()`](https://python-all.ru/3.15/library/stdtypes.html#str.title).12801281#### `str.isupper()`12821283Возвращает `True`, если все буквенные символы [\[4\]](https://python-all.ru/3.15/library/stdtypes.html#id15) в строке являются прописными и в строке есть хотя бы один буквенный символ, иначе `False`.12841285```python1286>>> 'BANANA'.isupper()1287True1288>>> 'banana'.isupper()1289False1290>>> 'baNana'.isupper()1291False1292>>> ' '.isupper()1293False1294```12951296#### `str.join(iterable, /)`12971298Возвращает строку, полученную объединением строк в *iterable*. Если в *iterable* есть значения, не являющиеся строками, включая объекты [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes), возбуждается [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError). Разделитель между элементами – это строка, предоставляющая данный метод. Например:12991300```pycon1301>>> ', '.join(['spam', 'spam', 'spam'])1302'spam, spam, spam'1303>>> '-'.join('Python')1304'P-y-t-h-o-n'1305```13061307См. также [`split()`](https://python-all.ru/3.15/library/stdtypes.html#str.split).13081309#### `str.ljust(width, fillchar=' ', /)`13101311Возвращает строку, выровненную по левому краю в строке длины *width*. Заполнение выполняется с использованием указанного *fillchar* (по умолчанию пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`.13121313Например:13141315```pycon1316>>> 'Python'.ljust(10)1317'Python    '1318>>> 'Python'.ljust(10, '.')1319'Python....'1320>>> 'Monty Python'.ljust(10, '.')1321'Monty Python'1322```13231324См. также [`rjust()`](https://python-all.ru/3.15/library/stdtypes.html#str.rjust).13251326#### `str.lower()`13271328Возвращает копию строки, в которой все буквенные символы [\[4\]](https://python-all.ru/3.15/library/stdtypes.html#id15) преобразованы в нижний регистр. Например:13291330```pycon1331>>> 'Lower Method Example'.lower()1332'lower method example'1333```13341335Используемый алгоритм приведения к нижнему регистру [описан в разделе 3.13.2 «Default Case Conversion» стандарта Unicode](https://python-all.ru/3.15/library/stdtypes.html).13361337#### `str.lstrip(chars=None, /)`13381339Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* – это не префикс; удаляются все комбинации входящих в него символов:13401341```python1342>>> '   spacious   '.lstrip()1343'spacious   '1344>>> 'www.example.com'.lstrip('cmowz.')1345'example.com'1346```13471348См. [`str.removeprefix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removeprefix) для метода, который удаляет один строковый префикс, а не набор символов. Например:13491350```python1351>>> 'Arthur: three!'.lstrip('Arthur: ')1352'ee!'1353>>> 'Arthur: three!'.removeprefix('Arthur: ')1354'three!'1355```13561357#### `static str.maketrans(dict, /)`13581359#### `static str.maketrans(from, to, remove='', /)`13601361Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.15/library/stdtypes.html#str.translate).13621363Если указан только один аргумент, он должен быть словарём, отображающим коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или `None`. Ключи-символы при этом преобразуются в коды.13641365Если указано два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ из *from* будет отображаться на символ на той же позиции в *to*. Если есть третий аргумент, он должен быть строкой, символы которой в результате будут отображаться на `None`.13661367Изменено в версии 3.15: *dict* теперь может быть [`frozendict`](https://python-all.ru/3.15/library/stdtypes.html#frozendict).13681369#### `str.partition(sep, /)`13701371Разделяет строку по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.13721373Например:13741375```pycon1376>>> 'Monty Python'.partition(' ')1377('Monty', ' ', 'Python')1378>>> "Monty Python's Flying Circus".partition(' ')1379('Monty', ' ', "Python's Flying Circus")1380>>> 'Monty Python'.partition('-')1381('Monty Python', '', '')1382```13831384См. также [`rpartition()`](https://python-all.ru/3.15/library/stdtypes.html#str.rpartition).13851386#### `str.removeprefix(prefix, /)`13871388Если строка начинается с подстроки *prefix*, возвращается `string[len(prefix):]`. В противном случае возвращается копия исходной строки:13891390```pycon1391>>> 'TestHook'.removeprefix('Test')1392'Hook'1393>>> 'BaseTestCase'.removeprefix('Test')1394'BaseTestCase'1395```13961397Добавлено в версии 3.9.13981399См. также [`removesuffix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removesuffix) и [`startswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.startswith).14001401#### `str.removesuffix(suffix, /)`14021403Если строка заканчивается подстрокой *suffix* и эта *suffix* не пуста, возвращается `string[:-len(suffix)]`. В противном случае возвращается копия исходной строки:14041405```pycon1406>>> 'MiscTests'.removesuffix('Tests')1407'Misc'1408>>> 'TmpDirMixin'.removesuffix('Tests')1409'TmpDirMixin'1410```14111412Добавлено в версии 3.9.14131414См. также [`removeprefix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removeprefix) и [`endswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.endswith).14151416#### `str.replace(old, new, /, count=-1)`14171418Возвращает копию строки, в которой все вхождения подстроки *old* заменены на *new*. Если указан *count*, заменяются только первые *count* вхождений. Если *count* не указан или равен `-1`, заменяются все вхождения. Например:14191420```pycon1421>>> 'spam, spam, spam'.replace('spam', 'eggs')1422'eggs, eggs, eggs'1423>>> 'spam, spam, spam'.replace('spam', 'eggs', 1)1424'eggs, spam, spam'1425```14261427Изменено в версии 3.13: *count* теперь поддерживается в качестве именованного аргумента.14281429#### `str.rfind(sub[, start[, end]])`14301431Возвращает наибольший индекс в строке, по которому встречается подстрока *sub*, при условии, что *sub* находится в пределах `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в записи среза. Возвращает `-1`, если подстрока не найдена. Например:14321433```pycon1434>>> 'spam, spam, spam'.rfind('sp')1435121436>>> 'spam, spam, spam'.rfind('sp', 0, 10)143761438```14391440См. также [`find()`](https://python-all.ru/3.15/library/stdtypes.html#str.find) и [`rindex()`](https://python-all.ru/3.15/library/stdtypes.html#str.rindex).14411442#### `str.rindex(sub[, start[, end]])`14431444Действует как [`rfind()`](https://python-all.ru/3.15/library/stdtypes.html#str.rfind), но возбуждает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если подстрока *sub* не найдена. Например:14451446```pycon1447>>> 'spam, spam, spam'.rindex('spam')1448121449>>> 'spam, spam, spam'.rindex('eggs')1450Traceback (most recent call last):1451  File "<stdin-0>", line 1, in <module>1452    'spam, spam, spam'.rindex('eggs')1453    ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^1454ValueError: substring not found1455```14561457См. также [`index()`](https://python-all.ru/3.15/library/stdtypes.html#str.index) и [`find()`](https://python-all.ru/3.15/library/stdtypes.html#str.find).14581459#### `str.rjust(width, fillchar=' ', /)`14601461Возвращает строку, выровненную по правому краю в строке длины *width*. Заполнение выполняется с использованием указанного *fillchar* (по умолчанию пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`.14621463Например:14641465```pycon1466>>> 'Python'.rjust(10)1467'    Python'1468>>> 'Python'.rjust(10, '.')1469'....Python'1470>>> 'Monty Python'.rjust(10, '.')1471'Monty Python'1472```14731474См. также [`ljust()`](https://python-all.ru/3.15/library/stdtypes.html#str.ljust) и [`zfill()`](https://python-all.ru/3.15/library/stdtypes.html#str.zfill).14751476#### `str.rpartition(sep, /)`14771478Разделяет строку по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.14791480Например:14811482```pycon1483>>> 'Monty Python'.rpartition(' ')1484('Monty', ' ', 'Python')1485>>> "Monty Python's Flying Circus".rpartition(' ')1486("Monty Python's Flying", ' ', 'Circus')1487>>> 'Monty Python'.rpartition('-')1488('', '', 'Monty Python')1489```14901491См. также [`partition()`](https://python-all.ru/3.15/library/stdtypes.html#str.partition).14921493#### `str.rsplit(sep=None, maxsplit=-1)`14941495Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, причём *самых правых*. Если *sep* не указан или равен `None`, в качестве разделителя используется любая строка из пробельных символов. За исключением разбиения справа, `rsplit()` ведёт себя как [`split()`](https://python-all.ru/3.15/library/stdtypes.html#str.split), подробно описанный ниже.14961497#### `str.rstrip(chars=None, /)`14981499Возвращает копию строки с удалёнными завершающими символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* является не суффиксом, а набором символов, все комбинации значений которого удаляются. Например:15001501```pycon1502>>> '   spacious   '.rstrip()1503'   spacious'1504>>> 'mississippi'.rstrip('ipz')1505'mississ'1506```15071508См. [`removesuffix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removesuffix) – метод, который удаляет одну строку-суффикс, а не все символы из набора. Например:15091510```python1511>>> 'Monty Python'.rstrip(' Python')1512'M'1513>>> 'Monty Python'.removesuffix(' Python')1514'Monty'1515```15161517См. также [`strip()`](https://python-all.ru/3.15/library/stdtypes.html#str.strip).15181519#### `str.split(sep=None, maxsplit=-1)`15201521Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (следовательно, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, ограничения на количество разбиений нет (выполняются все возможные разбиения).15221523Если *sep* задан, последовательные разделители не группируются и считаются разделяющими пустые строки (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов, используемых как один разделитель (для разбиения по нескольким разделителям используйте [`re.split()`](https://python-all.ru/3.15/library/re.html#re.split)). Разбиение пустой строки с указанным разделителем возвращает `['']`.15241525Например:15261527```pycon1528>>> '1,2,3'.split(',')1529['1', '2', '3']1530>>> '1,2,3'.split(',', maxsplit=1)1531['1', '2,3']1532>>> '1,2,,3,'.split(',')1533['1', '2', '', '3', '']1534>>> '1<>2<>3<4'.split('<>')1535['1', '2', '3<4']1536```15371538Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если строка содержит начальные или завершающие пробелы. Следовательно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.15391540Например:15411542```pycon1543>>> '1 2 3'.split()1544['1', '2', '3']1545>>> '1 2 3'.split(maxsplit=1)1546['1', '2 3']1547>>> '   1   2   3   '.split()1548['1', '2', '3']1549```15501551Если *sep* не указан или равен `None`, а *maxsplit* равен `0`, учитываются только начальные последовательности пробельных символов.15521553Например:15541555```pycon1556>>> "".split(None, 0)1557[]1558>>> "   ".split(None, 0)1559[]1560>>> "   foo   ".split(maxsplit=0)1561['foo   ']1562```15631564См. также [`join()`](https://python-all.ru/3.15/library/stdtypes.html#str.join) и [`rsplit()`](https://python-all.ru/3.15/library/stdtypes.html#str.rsplit).15651566#### `str.splitlines(keepends=False)`15671568Возвращает список строк в строке, разбивая её по границам строк. Символы перевода строки не включаются в результирующий список, если только *keepends* не задан и не равен true.15691570Этот метод разбивает строку по следующим границам строк. В частности, эти границы являются расширенным набором [универсальных символов перевода строки](https://python-all.ru/3.15/glossary.html#term-universal-newlines).15711572| Представление | Описание |1573| --- | --- |1574| `\n` | Перевод строки (LF) |1575| `\r` | Возврат каретки (CR) |1576| `\r\n` | Возврат каретки + перевод строки (CR+LF) |1577| `\v` или `\x0b` | Линейная табуляция |1578| `\f` или `\x0c` | Перевод страницы |1579| `\x1c` | Разделитель файлов |1580| `\x1d` | Разделитель групп |1581| `\x1e` | Разделитель записей |1582| `\x85` | Следующая строка (управляющий код C1) |1583| `\u2028` | Разделитель строк |1584| `\u2029` | Разделитель абзацев |15851586Изменено в версии 3.2: `\v` и `\f` добавлены в список границ строк.15871588Например:15891590```python1591>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()1592['ab c', '', 'de fg', 'kl']1593>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)1594['ab c\n', '\n', 'de fg\r', 'kl\r\n']1595```15961597В отличие от [`split()`](https://python-all.ru/3.15/library/stdtypes.html#str.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и концевой разрыв строки не приводит к появлению дополнительной строки:15981599```python1600>>> "".splitlines()1601[]1602>>> "One line\n".splitlines()1603['One line']1604```16051606Для сравнения, `split('\n')` возвращает:16071608```python1609>>> ''.split('\n')1610['']1611>>> 'Two lines\n'.split('\n')1612['Two lines', '']1613```16141615#### `str.startswith(prefix[, start[, end]])`16161617Возвращает `True`, если строка начинается с *prefix*, иначе возвращает `False`. *prefix* также может быть кортежем префиксов для поиска. При указании необязательного *start* строка проверяется начиная с этой позиции. При указании необязательного *end* сравнение строки прекращается на этой позиции.16181619Например:16201621```pycon1622>>> 'Python'.startswith('Py')1623True1624>>> 'a tuple of prefixes'.startswith(('at', 'a'))1625True1626>>> 'Python is amazing'.startswith('is', 7)1627True1628```16291630См. также [`endswith()`](https://python-all.ru/3.15/library/stdtypes.html#str.endswith) и [`removeprefix()`](https://python-all.ru/3.15/library/stdtypes.html#str.removeprefix).16311632#### `str.strip(chars=None, /)`16331634Возвращает копию строки с удалёнными начальными и завершающими символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* является не префиксом или суффиксом, а набором символов, все комбинации значений которого удаляются.16351636Символы пробела определяются с помощью [`str.isspace()`](https://python-all.ru/3.15/library/stdtypes.html#str.isspace).16371638Например:16391640```pycon1641>>> '   spacious   '.strip()1642'spacious'1643>>> 'www.example.com'.strip('cmowz.')1644'example'1645```16461647Значения аргумента *chars* в начале и конце строки удаляются. Символы удаляются с начала до тех пор, пока не встретится символ строки, не входящий в набор символов из *chars*. Аналогичное действие выполняется в конце строки.16481649Например:16501651```pycon1652>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'1653>>> comment_string.strip('.#! ')1654'Section 3.2.1 Issue #32'1655```16561657См. также [`rstrip()`](https://python-all.ru/3.15/library/stdtypes.html#str.rstrip).16581659#### `str.swapcase()`16601661Возвращает копию строки, в которой прописные буквы преобразуются в строчные и наоборот. Например:16621663```pycon1664>>> 'Hello World'.swapcase()1665'hELLO wORLD'1666```16671668Следует учитывать, что `s.swapcase().swapcase() == s` не обязательно истинно. Например:16691670```pycon1671>>> 'straße'.swapcase().swapcase()1672'strasse'1673```16741675См. также [`str.lower()`](https://python-all.ru/3.15/library/stdtypes.html#str.lower) и [`str.upper()`](https://python-all.ru/3.15/library/stdtypes.html#str.upper).16761677#### `str.title()`16781679Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.16801681Например:16821683```python1684>>> 'Hello world'.title()1685'Hello World'1686```16871688Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:16891690```python1691>>> "they're bill's friends from the UK".title()1692"They'Re Bill'S Friends From The Uk"1693```16941695Функция [`string.capwords()`](https://python-all.ru/3.15/library/string.html#string.capwords) не имеет этой проблемы, поскольку разбивает слова только по пробелам.16961697В качестве альтернативы можно создать обходной путь для апострофов с помощью регулярных выражений:16981699```python1700>>> import re1701>>> def titlecase(s):1702...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",1703...                   lambda mo: mo.group(0).capitalize(),1704...                   s)1705...1706>>> titlecase("they're bill's friends.")1707"They're Bill's Friends."1708```17091710См. также [`istitle()`](https://python-all.ru/3.15/library/stdtypes.html#str.istitle).17111712#### `str.translate(table, /)`17131714Возвращает копию строки, в которой каждый символ преобразован с помощью заданной таблицы трансляции. Таблица должна быть объектом, поддерживающим индексацию по [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), обычно это [отображение](https://python-all.ru/3.15/glossary.html#term-mapping) или [последовательность](https://python-all.ru/3.15/glossary.html#term-sequence). При индексации по коду Unicode (целое число) объект таблицы может выполнить одно из следующих действий: вернуть код Unicode или строку, чтобы сопоставить символ одному или нескольким другим символам; вернуть `None` для удаления символа из результирующей строки; или возбудить исключение [`LookupError`](https://python-all.ru/3.15/library/exceptions.html#LookupError), чтобы оставить символ без изменений.17151716Можно использовать [`str.maketrans()`](https://python-all.ru/3.15/library/stdtypes.html#str.maketrans) для создания таблицы трансляции на основе сопоставлений символов в различных форматах.17171718В следующем примере используется отображение для замены `'a'` на `'X'`, `'b'` на `'Y'` и удаления `'c'`:17191720```pycon1721>>> 'abc123'.translate({ord('a'): 'X', ord('b'): 'Y', ord('c'): None})1722'XY123'1723```17241725См. также модуль [`codecs`](https://python-all.ru/3.15/library/codecs.html#module-codecs) для более гибкого подхода к настраиваемым сопоставлениям символов.17261727#### `str.upper()`17281729Возвращает копию строки, в которой все буквенные символы [\[4\]](https://python-all.ru/3.15/library/stdtypes.html#id15) преобразованы в верхний регистр. Обратите внимание, что `s.upper().isupper()` может быть `False`, если `s` содержит символы без регистра или если категория Unicode результирующего символа не «Lu» (буква, верхний регистр), а, например, «Lt» (буква, заглавный регистр).17301731Используемый алгоритм преобразования в верхний регистр [описан в разделе 3.13.2 «Default Case Conversion» стандарта Unicode](https://python-all.ru/3.15/library/stdtypes.html).17321733#### `str.zfill(width, /)`17341735Возвращает копию строки, дополненную слева символами `'0'` (цифра ASCII) до длины *width*. Ведущий знак (`'+'`/`'-'`) обрабатывается так: заполнение вставляется *после* символа знака, а не перед ним. Исходная строка возвращается, если *width* меньше или равно `len(s)`.17361737Например:17381739```pycon1740>>> "42".zfill(5)1741'00042'1742>>> "-42".zfill(5)1743'-0042'1744```17451746См. также [`rjust()`](https://python-all.ru/3.15/library/stdtypes.html#str.rjust).17471748### Форматированные строковые литералы (f-строки)17491750Добавлено в версии 3.6.17511752Изменено в версии 3.7: В выражениях внутри f-строк теперь можно использовать [`await`](https://python-all.ru/3.15/reference/expressions.html#await) и [`async for`](https://python-all.ru/3.15/reference/compound_stmts.html#async-for).17531754Изменено в версии 3.8: Добавлен спецификатор отладки (`=`)17551756Изменено в версии 3.12: Снято множество ограничений на выражения внутри f-строк. В частности, теперь разрешены вложенные строки, комментарии и обратные косые черты.17571758*F-строка* (формально *форматированный строковый литерал*) – это строковый литерал с префиксом `f` или `F`. Такой строковый литерал позволяет встраивать результаты произвольных выражений Python в *поля подстановки*, которые ограничены фигурными скобками (`{}`). Каждое поле подстановки должно содержать выражение, за которым необязательно может следовать:17591760- *спецификатор отладки* – знак равенства (`=`);1761- *спецификатор преобразования* – `!s`, `!r` или `!a`; и/или1762- *спецификатор формата* с префиксом в виде двоеточия (`:`).17631764Подробнее о синтаксисе этих полей см. [раздел «Лексический анализ» про f-строки](https://python-all.ru/3.15/reference/lexical_analysis.html#f-strings).17651766#### Спецификатор отладки17671768Добавлено в версии 3.8.17691770Если после выражения поля подстановки указан спецификатор отладки – знак равенства (`=`), то результирующая f-строка будет содержать исходный код выражения, знак равенства и значение выражения. Это часто полезно для отладки:17711772```python1773>>> number = 14.31774>>> f'{number=}'1775'number=14.3'1776```17771778Пробелы до, внутри и после выражения, а также пробелы после знака равенства учитываются – они сохраняются в результате:17791780```python1781>>> f'{ number  -  4  = }'1782' number  -  4  = 10.3'1783```17841785#### Спецификатор преобразования17861787По умолчанию значение выражения поля подстановки преобразуется в строку с помощью [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str):17881789```python1790>>> from fractions import Fraction1791>>> one_third = Fraction(1, 3)1792>>> f'{one_third}'1793'1/3'1794```17951796Если указан спецификатор отладки, но не указан спецификатор формата, преобразование по умолчанию вместо этого использует [`repr()`](https://python-all.ru/3.15/library/functions.html#repr):17971798```python1799>>> f'{one_third = }'1800'one_third = Fraction(1, 3)'1801```18021803Преобразование можно явно указать с помощью одного из следующих спецификаторов:18041805- `!s` для [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str)1806- `!r` для [`repr()`](https://python-all.ru/3.15/library/functions.html#repr)1807- `!a` для [`ascii()`](https://python-all.ru/3.15/library/functions.html#ascii)18081809Например:18101811```python1812>>> str(one_third)1813'1/3'1814>>> repr(one_third)1815'Fraction(1, 3)'18161817>>> f'{one_third!s} is {one_third!r}'1818'1/3 is Fraction(1, 3)'18191820>>> string = "¡kočka 😸!"1821>>> ascii(string)1822"'\\xa1ko\\u010dka \\U0001f638!'"18231824>>> f'{string = !a}'1825"string = '\\xa1ko\\u010dka \\U0001f638!'"1826```18271828#### Спецификатор формата18291830После вычисления выражения и, возможно, преобразования с помощью явного спецификатора преобразования, оно форматируется с помощью функции [`format()`](https://python-all.ru/3.15/library/functions.html#format). Если поле подстановки содержит *спецификатор формата*, вводимый двоеточием (`:`), то спецификатор передаётся в `format()` в качестве второго аргумента. Результат `format()` затем используется как окончательное значение для поля подстановки. Например:18311832```python1833>>> from fractions import Fraction1834>>> one_third = Fraction(1, 3)1835>>> f'{one_third:.6f}'1836'0.333333'1837>>> f'{one_third:_^+10}'1838'___+1/3___'1839>>> >>> f'{one_third!r:_^20}'1840'___Fraction(1, 3)___'1841>>> f'{one_third = :~>10}~'1842'one_third = ~~~~~~~1/3~'1843```18441845### Шаблонные строковые литералы (t-строки)18461847*T-строка* (официально *шаблонный строковый литерал*) – это строковый литерал, начинающийся с префикса `t` или `T`.18481849Эти строки следуют тому же синтаксису и правилам вычисления, что и [форматированные строковые литералы](https://python-all.ru/3.15/library/stdtypes.html#stdtypes-fstrings), со следующими отличиями:18501851- Вместо вычисления в объект `str`, шаблонные строковые литералы вычисляются в объект [`string.templatelib.Template`](https://python-all.ru/3.15/library/string.templatelib.html#string.templatelib.Template).1852- Протокол [`format()`](https://python-all.ru/3.15/library/functions.html#format) не используется. Вместо этого спецификатор формата и преобразования (если они есть) передаются новому объекту [`Interpolation`](https://python-all.ru/3.15/library/string.templatelib.html#string.templatelib.Interpolation), который создаётся для каждого вычисленного выражения. Код, обрабатывающий полученный объект [`Template`](https://python-all.ru/3.15/library/string.templatelib.html#string.templatelib.Template), решает, как обрабатывать спецификаторы формата и преобразования.1853- Спецификаторы формата, содержащие вложенные поля подстановки, вычисляются заранее, до передачи объекту [`Interpolation`](https://python-all.ru/3.15/library/string.templatelib.html#string.templatelib.Interpolation). Например, интерполяция вида `{amount:.{precision}f}` вычислит внутреннее выражение `{precision}`, чтобы определить значение атрибута `format_spec`. Если бы `precision` было равно `2`, результирующий спецификатор формата был бы `'.2f'`.1854- Если в выражении интерполяции указан знак равенства `'='`, текст выражения добавляется к литеральной строке, предшествующей соответствующей интерполяции. Сюда входят знак равенства и окружающие пробелы. Экземпляр `Interpolation` для выражения создаётся обычным образом, за исключением того, что [`conversion`](https://python-all.ru/3.15/library/string.templatelib.html#string.templatelib.Interpolation.conversion) по умолчанию устанавливается в ‘`r`’ ([`repr()`](https://python-all.ru/3.15/library/functions.html#repr)). Если указаны явное преобразование или спецификатор формата, это переопределяет поведение по умолчанию.18551856### Форматирование строк в стиле `printf`18571858> **Примечание**1859>1860> Описанные здесь операции форматирования имеют ряд особенностей, которые приводят к распространённым ошибкам (например, некорректное отображение кортежей и словарей).1861>1862> Использование [форматированных строковых литералов](https://python-all.ru/3.15/reference/lexical_analysis.html#f-strings), интерфейса [`str.format()`](https://python-all.ru/3.15/library/stdtypes.html#str.format) или [`string.Template`](https://python-all.ru/3.15/library/string.html#string.Template) может помочь избежать этих ошибок. Каждая из этих альтернатив имеет свои компромиссы и преимущества с точки зрения простоты, гибкости и/или расширяемости.18631864Строковые объекты имеют одну уникальную встроенную операцию: оператор `%` (остаток от деления). Он также известен как оператор *форматирования* или *интерполяции* строк. Для `format % values` (где *format* – строка) спецификации преобразования `%` в *format* заменяются нулём или более элементами из *values*. Эффект аналогичен использованию функции `sprintf()` в языке C. Например:18651866```pycon1867>>> print('%s has %d quote types.' % ('Python', 2))1868Python has 2 quote types.1869```18701871Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [\[5\]](https://python-all.ru/3.15/library/stdtypes.html#id16) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).18721873Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:187418751. Символ `'%'`, обозначающий начало спецификатора.18762. Ключ отображения (необязательно), состоящий из последовательности символов в круглых скобках (например, `(somename)`).18773. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.18784. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.18795. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.18806. Модификатор длины (необязательно).18817. Тип преобразования.18821883Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:18841885```python1886>>> print('%(language)s has %(number)03d quote types.' %1887...       {'language': "Python", "number": 2})1888Python has 002 quote types.1889```18901891В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).18921893Символы флагов преобразования:18941895| Флаг | Значение |1896| --- | --- |1897| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |1898| `'0'` | Для числовых значений преобразование будет дополняться нулями. |1899| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |1900| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |1901| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |19021903Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, поскольку он не нужен для Python – так, например, `%ld` идентично `%d`.19041905Типы преобразования:19061907| Преобразование | Значение | Примечания |1908| --- | --- | --- |1909| `'d'` | Десятичное целое со знаком. |  |1910| `'i'` | Десятичное целое со знаком. |  |1911| `'o'` | Восьмеричное значение со знаком. | (1) |1912| `'u'` | Устаревший тип – идентичен `'d'`. | (6) |1913| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |1914| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |1915| `'e'` | Экспоненциальный формат с плавающей запятой (строчные буквы). | (3) |1916| `'E'` | Экспоненциальный формат с плавающей запятой (заглавные буквы). | (3) |1917| `'f'` | Десятичный формат с плавающей запятой. | (3) |1918| `'F'` | Десятичный формат с плавающей запятой. | (3) |1919| `'g'` | Формат с плавающей запятой. Использует экспоненциальный формат со строчными буквами если показатель степени меньше -4 или не меньше точности, в противном случае – десятичный формат. | (4) |1920| `'G'` | Формат с плавающей запятой. Использует экспоненциальный формат с заглавными буквами если показатель степени меньше -4 или не меньше точности, в противном случае – десятичный формат. | (4) |1921| `'c'` | Один символ (принимает целое число или строку из одного символа). |  |1922| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.15/library/functions.html#repr)). | (5) |1923| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str)). | (5) |1924| `'a'` | Строка (преобразует любой объект Python с помощью [`ascii()`](https://python-all.ru/3.15/library/functions.html#ascii)). | (5) |1925| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |19261927Для форматов с плавающей точкой результат должен быть правильно округлён до заданной точности `p` – количества знаков после десятичной точки. Режим округления совпадает с режимом встроенной функции [`round()`](https://python-all.ru/3.15/library/functions.html#round).19281929Примечания:193019311. Альтернативная форма вставляет ведущий восьмеричный спецификатор (`'0o'`) перед первой цифрой.19322. Альтернативная форма вставляет перед первой цифрой ведущий `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`).19333. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.19341935   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.19364. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.19371938   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.19395. Если точность равна `N`, вывод усекается до `N` символов.19406. См. [**PEP 237**](https://python-all.ru/3.15/library/stdtypes.html).19411942Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.19431944Изменено в версии 3.1: `%f` преобразования для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.19451946## Типы бинарных последовательностей – [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes), [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray), [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview)19471948Основные встроенные типы для работы с бинарными данными – [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray). Они поддерживаются [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview), который использует [протокол буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects) для доступа к памяти других бинарных объектов без необходимости создания копии.19491950Модуль [`array`](https://python-all.ru/3.15/library/array.html#module-array) поддерживает эффективное хранение основных типов данных, таких как 32-битные целые числа и числа с плавающей точкой двойной точности IEEE754.19511952### Объекты bytes19531954Объекты bytes – это неизменяемые последовательности отдельных байтов. Поскольку многие основные бинарные протоколы основаны на текстовой кодировке ASCII, объекты bytes предоставляют несколько методов, которые действительны только при работе с данными, совместимыми с ASCII, и тесно связаны со строковыми объектами во многих других отношениях.19551956#### `class bytes(source=b'')`19571958#### `class bytes(source, encoding, errors='strict')`19591960Во-первых, синтаксис литералов bytes в основном такой же, как для строковых литералов, за исключением того, что добавляется префикс `b`:19611962- Одинарные кавычки: `b'still allows embedded "double" quotes'`1963- Двойные кавычки: `b"still allows embedded 'single' quotes"`1964- Тройные кавычки: `b'''3 single quotes'''`, `b"""3 double quotes"""`19651966В литералах bytes допускаются только символы ASCII (независимо от объявленной кодировки исходного кода). Любые двоичные значения больше 127 должны вводиться в литералы bytes с помощью соответствующей управляющей последовательности.19671968Как и строковые литералы, литералы bytes также могут использовать префикс `r` для отключения обработки управляющих последовательностей. См. [Строковые литералы и литералы bytes](https://python-all.ru/3.15/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах литералов bytes, включая поддерживаемые управляющие последовательности.19691970Хотя литералы bytes и их представления основаны на тексте ASCII, объекты bytes на самом деле ведут себя как неизменяемые последовательности целых чисел, где каждое значение в последовательности ограничено так, что `0 <= x < 256` (попытки нарушить это ограничение вызовут [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError)). Это сделано намеренно, чтобы подчеркнуть, что хотя многие двоичные форматы содержат элементы на основе ASCII и могут быть полезно обработаны некоторыми текстовыми алгоритмами, в общем случае это не так для произвольных двоичных данных (слепое применение алгоритмов обработки текста к двоичным форматам, несовместимым с ASCII, обычно приводит к повреждению данных).19711972Помимо литералов, объекты bytes могут быть созданы несколькими другими способами:19731974- Объект bytes, заполненный нулями заданной длины: `bytes(10)`1975- Из итерируемого объекта целых чисел: `bytes(range(20))`1976- Копирование существующих двоичных данных через буферный протокол: `bytes(obj)`19771978См. также встроенную функцию [bytes](https://python-all.ru/3.15/library/functions.html#func-bytes).19791980Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа являются широко используемым форматом для описания двоичных данных. Соответственно, тип bytes имеет дополнительный метод класса для чтения данных в этом формате:19811982#### `classmethod fromhex(string, /)`19831984Этот метод класса `bytes` возвращает объект bytes, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробельные символы ASCII игнорируются.19851986```python1987>>> bytes.fromhex('2Ef0 F1f2  ')1988b'.\xf0\xf1\xf2'1989```19901991Изменено в версии 3.7: `bytes.fromhex()` теперь пропускает все пробельные символы ASCII в строке, а не только пробелы.19921993Изменено в версии 3.14: `bytes.fromhex()` теперь принимает ASCII `bytes` и [байтоподобные объекты](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) в качестве входных данных.19941995Существует обратная функция преобразования для превращения объекта bytes в его шестнадцатеричное представление.19961997#### `hex(*, bytes_per_sep=1)`19981999#### `hex(sep, bytes_per_sep=1)`20002001Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в экземпляре.20022003```python2004>>> b'\xf0\xf1\xf2'.hex()2005'f0f1f2'2006```20072008Чтобы сделать шестнадцатеричную строку более читаемой, можно указать параметр *sep* – односимвольный разделитель, который будет включён в вывод. По умолчанию этот разделитель будет вставляться между каждым байтом. Второй необязательный параметр *bytes\_per\_sep* управляет интервалом. Положительные значения вычисляют позицию разделителя справа, отрицательные – слева.20092010```python2011>>> value = b'\xf0\xf1\xf2'2012>>> value.hex('-')2013'f0-f1-f2'2014>>> value.hex('_', 2)2015'f0_f1f2'2016>>> b'UUDDLRLRAB'.hex(' ', -4)2017'55554444 4c524c52 4142'2018```20192020Добавлено в версии 3.5.20212022Изменено в версии 3.8: `bytes.hex()` теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.20232024Поскольку объекты bytes являются последовательностями целых чисел (похожими на кортеж), для объекта bytes *b* `b[0]` будет целым числом, а `b[0:1]` – объектом bytes длины 1. (Это отличается от текстовых строк, где и индексация, и извлечение среза дают строку длины 1).20252026Представление объектов bytes использует литеральный формат (`b'...'`), поскольку он часто более полезен, чем, например, `bytes([46, 46, 46])`. Всегда можно преобразовать объект bytes в список целых чисел с помощью `list(b)`.20272028### Объекты Bytearray20292030Объекты [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray) являются изменяемым аналогом объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) .20312032#### `class bytearray(source=b'')`20332034#### `class bytearray(source, encoding, errors='strict')`20352036Для объектов bytearray не существует специального литерального синтаксиса, вместо этого они всегда создаются вызовом конструктора:20372038- Создание пустого экземпляра: `bytearray()`2039- Создание экземпляра, заполненного нулями заданной длины: `bytearray(10)`2040- Из итерируемого объекта целых чисел: `bytearray(range(20))`2041- Копирование существующих двоичных данных через буферный протокол: `bytearray(b'Hi!')`20422043Поскольку объекты bytearray являются изменяемыми, они поддерживают [изменяемые](https://python-all.ru/3.15/library/stdtypes.html#typesseq-mutable) операции последовательности в дополнение к общим операциям bytes и bytearray, описанным в [Операции с bytes и bytearray](https://python-all.ru/3.15/library/stdtypes.html#bytes-methods).20442045См. также встроенную функцию [bytearray](https://python-all.ru/3.15/library/functions.html#func-bytearray).20462047Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа часто используются для описания двоичных данных. Соответственно, тип bytearray имеет дополнительный метод класса для чтения данных в этом формате:20482049#### `classmethod fromhex(string, /)`20502051Этот метод класса `bytearray` возвращает объект bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробельные символы ASCII игнорируются.20522053```python2054>>> bytearray.fromhex('2Ef0 F1f2  ')2055bytearray(b'.\xf0\xf1\xf2')2056```20572058Изменено в версии 3.7: `bytearray.fromhex()` теперь пропускает все пробельные символы ASCII в строке, а не только пробелы.20592060Изменено в версии 3.14: `bytearray.fromhex()` теперь принимает ASCII [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [байтоподобные объекты](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) в качестве входных данных.20612062Существует обратная функция преобразования для превращения объекта bytearray в его шестнадцатеричное представление.20632064#### `hex(*, bytes_per_sep=1)`20652066#### `hex(sep, bytes_per_sep=1)`20672068Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в экземпляре.20692070```python2071>>> bytearray(b'\xf0\xf1\xf2').hex()2072'f0f1f2'2073```20742075Добавлено в версии 3.5.20762077Изменено в версии 3.8: Аналогично [`bytes.hex()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.hex), `bytearray.hex()` теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.20782079#### `resize(size, /)`20802081Изменяет размер `bytearray` так, чтобы он содержал *size* байт. *size* должен быть больше или равен 0.20822083Если `bytearray` нужно уменьшить, байты за пределами *size* отбрасываются.20842085Если `bytearray` нужно увеличить, все новые байты, находящиеся за пределами *size*, будут установлены в нулевые байты.20862087Это эквивалентно:20882089```python2090>>> def resize(ba, size):2091...     if len(ba) > size:2092...         del ba[size:]2093...     else:2094...         ba += b'\0' * (size - len(ba))2095```20962097Примеры:20982099```python2100>>> shrink = bytearray(b'abc')2101>>> shrink.resize(1)2102>>> (shrink, len(shrink))2103(bytearray(b'a'), 1)2104>>> grow = bytearray(b'abc')2105>>> grow.resize(5)2106>>> (grow, len(grow))2107(bytearray(b'abc\x00\x00'), 5)2108```21092110Добавлено в версии 3.14.21112112#### `take_bytes(n=None, /)`21132114Удаляет первые *n* байт из bytearray и возвращает их как неизменяемый объект [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes). По умолчанию (если *n* равно `None`) возвращает все байты и очищает bytearray.21152116Если *n* отрицательно, то индекс считается с конца, и берутся первые [`len()`](https://python-all.ru/3.15/library/functions.html#len) плюс *n* байт. Если *n* выходит за границы, вызывается [`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError).21172118Если взять меньше полной длины, оставшиеся байты останутся в `bytearray`, что требует копирования. Если оставшиеся байты нужно отбросить, используйте [`resize()`](https://python-all.ru/3.15/library/stdtypes.html#bytearray.resize) или [`del`](https://python-all.ru/3.15/reference/simple_stmts.html#del) для усечения, а затем `take_bytes()` без указания размера.21192120**Особенности реализации CPython:** Взятие всех байтов – это операция без копирования.21212122Добавлено в версии 3.15: См. статью [Что нового](https://python-all.ru/3.15/whatsnew/3.15.html#whatsnew315-bytearray-take-bytes) с примерами типовых шаблонов кода, которые можно оптимизировать с помощью `bytearray.take_bytes()`.21232124Поскольку объекты bytearray являются последовательностями целых чисел (подобно списку), для объекта bytearray *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytearray длиной 1. (Это отличается от текстовых строк, где и индексирование, и срез возвращают строку длиной 1)21252126Представление объектов bytearray использует литеральный формат bytes (`bytearray(b'...')`), поскольку он часто более полезен, чем, например, `bytearray([46, 46, 46])`. Объект bytearray всегда можно преобразовать в список целых чисел с помощью `list(b)`.21272128> **См. также**2129>2130> Подробную информацию о гарантиях потокобезопасности для объектов [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray) см. в разделе [Потокобезопасность объектов bytearray](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-bytearray).21312132### Операции с bytes и bytearray21332134Объекты bytes и bytearray поддерживают [общие](https://python-all.ru/3.15/library/stdtypes.html#typesseq-common) операции последовательности. Они взаимодействуют не только с операндами того же типа, но и с любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object). Благодаря такой гибкости их можно свободно смешивать в операциях, не вызывая ошибок. Однако тип возвращаемого результата может зависеть от порядка операндов.21352136> **Примечание**2137>2138> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать:2139>2140> ```python2141> a = "abc"2142> b = a.replace("a", "f")2143> ```2144>2145> и:2146>2147> ```python2148> a = b"abc"2149> b = a.replace(b"a", b"f")2150> ```21512152Некоторые операции с bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и поэтому их следует избегать при работе с произвольными двоичными данными. Эти ограничения описаны ниже.21532154> **Примечание**2155>2156> Использование этих операций на основе ASCII для манипуляции двоичными данными, которые не хранятся в формате на основе ASCII, может привести к повреждению данных.21572158Следующие методы объектов bytes и bytearray могут использоваться с произвольными двоичными данными.21592160#### `bytes.count(sub[, start[, end]])`21612162#### `bytearray.count(sub[, start[, end]])`21632164Возвращает количество непересекающихся вхождений подпоследовательности *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации среза.21652166Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.21672168Если *sub* пуст, возвращает количество пустых срезов между символами, равное длине объекта bytes плюс один.21692170Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.21712172#### `bytes.removeprefix(prefix, /)`21732174#### `bytearray.removeprefix(prefix, /)`21752176Если двоичные данные начинаются со строки *prefix*, возвращается `bytes[len(prefix):]`. В противном случае возвращается копия исходных двоичных данных:21772178```python2179>>> b'TestHook'.removeprefix(b'Test')2180b'Hook'2181>>> b'BaseTestCase'.removeprefix(b'Test')2182b'BaseTestCase'2183```21842185Значением *prefix* может быть любой [байтоподобный объект](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).21862187> **Примечание**2188>2189> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.21902191Добавлено в версии 3.9.21922193#### `bytes.removesuffix(suffix, /)`21942195#### `bytearray.removesuffix(suffix, /)`21962197Если двоичные данные оканчиваются строкой *suffix* и эта *suffix* не пуста, возвращается `bytes[:-len(suffix)]`. В противном случае возвращается копия исходных двоичных данных:21982199```python2200>>> b'MiscTests'.removesuffix(b'Tests')2201b'Misc'2202>>> b'TmpDirMixin'.removesuffix(b'Tests')2203b'TmpDirMixin'2204```22052206Значением *suffix* может быть любой [байтоподобный объект](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).22072208> **Примечание**2209>2210> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.22112212Добавлено в версии 3.9.22132214#### `bytes.decode(encoding='utf-8', errors='strict')`22152216#### `bytearray.decode(encoding='utf-8', errors='strict')`22172218Возвращает байты, декодированные в [`str`](https://python-all.ru/3.15/library/stdtypes.html#str).22192220*encoding* по умолчанию равен `'utf-8'`; список возможных значений см. в [Стандартные кодировки](https://python-all.ru/3.15/library/codecs.html#standard-encodings).22212222Параметр *errors* управляет обработкой ошибок декодирования. Если `'strict'` (по умолчанию), возбуждается исключение [`UnicodeError`](https://python-all.ru/3.15/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'`, и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.15/library/codecs.html#codecs.register_error). Подробнее см. в [Обработчики ошибок](https://python-all.ru/3.15/library/codecs.html#error-handlers).22232224По соображениям производительности значение *errors* не проверяется на корректность, пока не произойдёт ошибка декодирования, не будет включён [Режим разработки Python](https://python-all.ru/3.15/library/devmode.html#devmode) или не будет использована [отладочная сборка](https://python-all.ru/3.15/using/configure.html#debug-build).22252226> **Примечание**2227>2228> Передача аргумента *encoding* в [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) позволяет декодировать любой [байтоподобный объект](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) напрямую, без необходимости создавать временный объект `bytes` или `bytearray`.22292230Изменено в версии 3.1: Добавлена поддержка именованных аргументов.22312232Изменено в версии 3.9: Значение аргумента *errors* теперь проверяется в [Режиме разработки Python](https://python-all.ru/3.15/library/devmode.html#devmode) и в [режиме отладки](https://python-all.ru/3.15/using/configure.html#debug-build).22332234#### `bytes.endswith(suffix[, start[, end]])`22352236#### `bytearray.endswith(suffix[, start[, end]])`22372238Возвращает `True`, если двоичные данные оканчиваются указанным *suffix*, в противном случае возвращает `False`. *suffix* также может быть кортежем суффиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение прекращается на этой позиции.22392240Искомый суффикс (или суффиксы) может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).22412242#### `bytes.find(sub[, start[, end]])`22432244#### `bytearray.find(sub[, start[, end]])`22452246Возвращает наименьший индекс в данных, на котором найдена подпоследовательность *sub*, при условии, что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.22472248Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.22492250> **Примечание**2251>2252> Метод `find()` следует использовать только если нужно знать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.15/reference/expressions.html#in):2253>2254> ```python2255> >>> b'Py' in b'Python'2256> True2257> ```22582259Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.22602261#### `bytes.index(sub[, start[, end]])`22622263#### `bytearray.index(sub[, start[, end]])`22642265Как [`find()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.find), но возбуждает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если подпоследовательность не найдена.22662267Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.22682269Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.22702271#### `bytes.join(iterable, /)`22722273#### `bytearray.join(iterable, /)`22742275Возвращает объект bytes или bytearray, представляющий собой конкатенацию последовательностей двоичных данных из *iterable*. Исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) возникнет, если в *iterable* окажутся значения, не являющиеся [байтоподобными объектами](https://python-all.ru/3.15/glossary.html#term-bytes-like-object), включая объекты [`str`](https://python-all.ru/3.15/library/stdtypes.html#str). Разделителем между элементами служит содержимое объекта bytes или bytearray, предоставляющего этот метод.22762277#### `static bytes.maketrans(from, to, /)`22782279#### `static bytearray.maketrans(from, to, /)`22802281Этот статический метод возвращает таблицу перевода, пригодную для использования с [`bytes.translate()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* оба должны быть [байтоподобными объектами](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) и иметь одинаковую длину.22822283Добавлено в версии 3.1.22842285#### `bytes.partition(sep, /)`22862287#### `bytearray.partition(sep, /)`22882289Разделяет последовательность по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель (или его копию bytearray) и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий копию исходной последовательности, за которой следуют два пустых объекта bytes или bytearray.22902291Разделитель для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).22922293#### `bytes.replace(old, new, /, count=-1)`22942295#### `bytearray.replace(old, new, /, count=-1)`22962297Возвращает копию последовательности, в которой все вхождения подпоследовательности *old* заменены на *new*. Если указан *count*, заменяются только первые *count* вхождений. Если *count* не задан или равен `-1`, заменяются все вхождения.22982299Искомая подпоследовательность и её замена могут быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).23002301> **Примечание**2302>2303> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.23042305Изменено в версии 3.15: *count* теперь поддерживается как именованный аргумент.23062307#### `bytes.rfind(sub[, start[, end]])`23082309#### `bytearray.rfind(sub[, start[, end]])`23102311Возвращает наибольший индекс в последовательности, на котором найдена подпоследовательность *sub*, так что *sub* находится в пределах `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в записи среза. В случае отсутствия возвращает `-1`.23122313Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.23142315Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.23162317#### `bytes.rindex(sub[, start[, end]])`23182319#### `bytearray.rindex(sub[, start[, end]])`23202321Действует как [`rfind()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.rfind), но вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если подпоследовательность *sub* не найдена.23222323Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.23242325Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.23262327#### `bytes.rpartition(sep, /)`23282329#### `bytearray.rpartition(sep, /)`23302331Разделяет последовательность по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель (или его копию bytearray) и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий два пустых объекта bytes или bytearray, за которыми следует копия исходной последовательности.23322333Разделитель для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).23342335#### `bytes.startswith(prefix[, start[, end]])`23362337#### `bytearray.startswith(prefix[, start[, end]])`23382339Возвращает `True`, если двоичные данные начинаются с указанного *префикса*, иначе возвращает `False`. *Префикс* также может быть кортежем префиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение останавливается на этой позиции.23402341Префикс(ы) для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).23422343#### `bytes.translate(table, /, delete=b'')`23442345#### `bytearray.translate(table, /, delete=b'')`23462347Возвращает копию объекта bytes или bytearray, из которой удалены все байты, встречающиеся в необязательном аргументе *delete*, а оставшиеся байты преобразованы через заданную таблицу перекодировки, которая должна быть объектом bytes длиной 256.23482349Для создания таблицы перекодировки можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.maketrans).23502351Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:23522353```python2354>>> b'read this short text'.translate(None, b'aeiou')2355b'rd ths shrt txt'2356```23572358Изменено в версии 3.6: *delete* теперь поддерживается как именованный аргумент.23592360Следующие методы объектов bytes и bytearray имеют поведение по умолчанию, предполагающее использование бинарных форматов, совместимых с ASCII, но их можно использовать с произвольными двоичными данными, передав соответствующие аргументы. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а вместо этого создают новые объекты.23612362#### `bytes.center(width, fillbyte=b' ', /)`23632364#### `bytearray.center(width, fillbyte=b' ', /)`23652366Возвращает копию объекта, выровненную по центру в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.23672368> **Примечание**2369>2370> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.23712372#### `bytes.ljust(width, fillbyte=b' ', /)`23732374#### `bytearray.ljust(width, fillbyte=b' ', /)`23752376Возвращает копию объекта, выровненную по левому краю в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.23772378> **Примечание**2379>2380> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.23812382#### `bytes.lstrip(bytes=None, /)`23832384#### `bytearray.lstrip(bytes=None, /)`23852386Возвращает копию последовательности с удалёнными указанными начальными байтами. Аргумент *bytes* – это двоичная последовательность, задающая набор значений байтов, которые нужно удалить. Если он опущен или равен `None`, аргумент *bytes* по умолчанию удаляет пробельные символы ASCII. Аргумент *bytes* не является префиксом; вместо этого удаляются все комбинации его значений:23872388```python2389>>> b'   spacious   '.lstrip()2390b'spacious   '2391>>> b'www.example.com'.lstrip(b'cmowz.')2392b'example.com'2393```23942395Двоичная последовательность значений байтов для удаления может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object). См. [`removeprefix()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.removeprefix) для метода, который удаляет одну строку-префикс, а не набор символов. Например:23962397```python2398>>> b'Arthur: three!'.lstrip(b'Arthur: ')2399b'ee!'2400>>> b'Arthur: three!'.removeprefix(b'Arthur: ')2401b'three!'2402```24032404> **Примечание**2405>2406> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.24072408#### `bytes.rjust(width, fillbyte=b' ', /)`24092410#### `bytearray.rjust(width, fillbyte=b' ', /)`24112412Возвращает копию объекта, выровненную по правому краю в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.24132414> **Примечание**2415>2416> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.24172418#### `bytes.rsplit(sep=None, maxsplit=-1)`24192420#### `bytearray.rsplit(sep=None, maxsplit=-1)`24212422Разделяет двоичную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разделений, а именно *крайних справа*. Если *sep* не указан или равен `None`, любая подпоследовательность, состоящая только из пробельных символов ASCII, считается разделителем. За исключением разделения справа, `rsplit()` ведёт себя как [`split()`](https://python-all.ru/3.15/library/stdtypes.html#bytearray.split), который подробно описан ниже.24232424#### `bytes.rstrip(bytes=None, /)`24252426#### `bytearray.rstrip(bytes=None, /)`24272428Возвращает копию последовательности с удалёнными указанными завершающими байтами. Аргумент *bytes* – это двоичная последовательность, задающая набор удаляемых байтов. Если он опущен или равен `None`, то по умолчанию аргумент *bytes* удаляет пробельные символы ASCII. Аргумент *bytes* – это не суффикс; скорее, удаляются все комбинации его значений:24292430```python2431>>> b'   spacious   '.rstrip()2432b'   spacious'2433>>> b'mississippi'.rstrip(b'ipz')2434b'mississ'2435```24362437Двоичная последовательность удаляемых байтов может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object). См. [`removesuffix()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.removesuffix) для метода, который удаляет одну строку-суффикс, а не весь набор символов. Например:24382439```python2440>>> b'Monty Python'.rstrip(b' Python')2441b'M'2442>>> b'Monty Python'.removesuffix(b' Python')2443b'Monty'2444```24452446> **Примечание**2447>2448> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.24492450#### `bytes.split(sep=None, maxsplit=-1)`24512452#### `bytearray.split(sep=None, maxsplit=-1)`24532454Разделяет двоичную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit* и он неотрицателен, то выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то ограничения на количество разбиений нет (выполняются все возможные разбиения).24552456Если указан *sep*, то последовательные разделители не группируются и считаются разграничивающими пустые подпоследовательности (например, `b'1,,2'.split(b',')` возвращает `[b'1', b'', b'2']`). Аргумент *sep* может состоять из многобайтовой последовательности как единого разделителя. Разбиение пустой последовательности с указанным разделителем возвращает `[b'']` или `[bytearray(b'')]` в зависимости от типа разбиваемого объекта. Аргумент *sep* может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).24572458Например:24592460```python2461>>> b'1,2,3'.split(b',')2462[b'1', b'2', b'3']2463>>> b'1,2,3'.split(b',', maxsplit=1)2464[b'1', b'2,3']2465>>> b'1,2,,3,'.split(b',')2466[b'1', b'2', b'', b'3', b'']2467>>> b'1<>2<>3<4'.split(b'<>')2468[b'1', b'2', b'3<4']2469```24702471Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов ASCII считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если последовательность имеет начальные или завершающие пробелы. Следовательно, разбиение пустой последовательности или последовательности, состоящей только из пробельных символов ASCII, без указанного разделителя возвращает `[]`.24722473Например:24742475```python2476>>> b'1 2 3'.split()2477[b'1', b'2', b'3']2478>>> b'1 2 3'.split(maxsplit=1)2479[b'1', b'2 3']2480>>> b'   1   2   3   '.split()2481[b'1', b'2', b'3']2482```24832484#### `bytes.strip(bytes=None, /)`24852486#### `bytearray.strip(bytes=None, /)`24872488Возвращает копию последовательности с удалёнными указанными начальными и завершающими байтами. Аргумент *bytes* – это двоичная последовательность, задающая набор удаляемых байтов. Если он опущен или равен `None`, то по умолчанию аргумент *bytes* удаляет пробельные символы ASCII. Аргумент *bytes* – это не префикс или суффикс; скорее, удаляются все комбинации его значений:24892490```python2491>>> b'   spacious   '.strip()2492b'spacious'2493>>> b'www.example.com'.strip(b'cmowz.')2494b'example'2495```24962497Двоичная последовательность удаляемых байтов может быть любым [байтоподобным объектом](https://python-all.ru/3.15/glossary.html#term-bytes-like-object).24982499> **Примечание**2500>2501> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.25022503Следующие методы для объектов bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и не должны применяться к произвольным двоичным данным. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а создают новые объекты.25042505#### `bytes.capitalize()`25062507#### `bytearray.capitalize()`25082509Возвращает копию последовательности, где каждый байт интерпретируется как символ ASCII, первый байт преобразуется в верхний регистр, а остальные – в нижний. Не-ASCII байты передаются без изменений.25102511> **Примечание**2512>2513> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.25142515#### `bytes.expandtabs(tabsize=8)`25162517#### `bytearray.expandtabs(tabsize=8)`25182519Возвращает копию последовательности, в которой все символы табуляции ASCII заменяются одним или несколькими пробелами ASCII, в зависимости от текущей позиции столбца и заданного размера табуляции. Позиции табуляции находятся каждые *tabsize* байт (по умолчанию 8, что даёт позиции табуляции на столбцах 0, 8, 16 и так далее). Для расширения последовательности текущий столбец устанавливается в ноль, и последовательность просматривается побайтно. Если байт является символом табуляции ASCII (`b'\t'`), в результат вставляется один или несколько пробелов, пока текущий столбец не сравняется со следующей позицией табуляции. (Сам символ табуляции не копируется.) Если текущий байт является символом новой строки ASCII (`b'\n'`) или возврата каретки (`b'\r'`), он копируется, а текущий столбец сбрасывается в ноль. Любое другое значение байта копируется без изменений, а текущий столбец увеличивается на единицу независимо от того, как представляется значение байта при печати:25202521```python2522>>> b'01\t012\t0123\t01234'.expandtabs()2523b'01      012     0123    01234'2524>>> b'01\t012\t0123\t01234'.expandtabs(4)2525b'01  012 0123    01234'2526```25272528> **Примечание**2529>2530> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.25312532#### `bytes.isalnum()`25332534#### `bytearray.isalnum()`25352536Возвращает `True`, если все байты в последовательности являются буквенными символами ASCII или десятичными цифрами ASCII и последовательность непуста, иначе `False`. Буквенные символы ASCII – это значения байтов из диапазона `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Десятичные цифры ASCII – это значения байтов из диапазона `b'0123456789'`.25372538Например:25392540```python2541>>> b'ABCabc1'.isalnum()2542True2543>>> b'ABC abc1'.isalnum()2544False2545```25462547#### `bytes.isalpha()`25482549#### `bytearray.isalpha()`25502551Возвращает `True`, если все байты в последовательности являются буквенными символами ASCII и последовательность непуста, иначе `False`. Буквенные символы ASCII – это значения байтов из диапазона `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`.25522553Например:25542555```python2556>>> b'ABCabc'.isalpha()2557True2558>>> b'ABCabc1'.isalpha()2559False2560```25612562#### `bytes.isascii()`25632564#### `bytearray.isascii()`25652566Возвращает `True`, если последовательность пуста или все байты в последовательности являются ASCII, иначе `False`. Байты ASCII находятся в диапазоне 0-0x7F.25672568Добавлено в версии 3.7.25692570#### `bytes.isdigit()`25712572#### `bytearray.isdigit()`25732574Возвращает `True`, если все байты последовательности являются десятичными цифрами ASCII и последовательность не пуста, и `False` в противном случае. Десятичные цифры ASCII – это значения байтов из диапазона `b'0123456789'`.25752576Например:25772578```python2579>>> b'1234'.isdigit()2580True2581>>> b'1.23'.isdigit()2582False2583```25842585#### `bytes.islower()`25862587#### `bytearray.islower()`25882589Возвращает `True`, если в последовательности есть хотя бы один символ ASCII в нижнем регистре и нет символов ASCII в верхнем регистре, и `False` в противном случае.25902591Например:25922593```python2594>>> b'hello world'.islower()2595True2596>>> b'Hello world'.islower()2597False2598```25992600Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.26012602#### `bytes.isspace()`26032604#### `bytearray.isspace()`26052606Возвращает `True`, если все байты последовательности являются пробельными символами ASCII и последовательность не пуста, и `False` в противном случае. Пробельные символы ASCII – это значения байтов из диапазона `b' \t\n\r\x0b\f'` (пробел, табуляция, перевод строки, возврат каретки, вертикальная табуляция, перевод страницы).26072608#### `bytes.istitle()`26092610#### `bytearray.istitle()`26112612Возвращает `True`, если последовательность находится в регистре заголовка (titlecase) ASCII и не пуста, и `False` в противном случае. См. [`bytes.title()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.title) для подробностей об определении «titlecase».26132614Например:26152616```python2617>>> b'Hello World'.istitle()2618True2619>>> b'Hello world'.istitle()2620False2621```26222623#### `bytes.isupper()`26242625#### `bytearray.isupper()`26262627Возвращает `True`, если в последовательности есть хотя бы один алфавитный символ ASCII в верхнем регистре и нет символов ASCII в нижнем регистре, и `False` в противном случае.26282629Например:26302631```python2632>>> b'HELLO WORLD'.isupper()2633True2634>>> b'Hello world'.isupper()2635False2636```26372638Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.26392640#### `bytes.lower()`26412642#### `bytearray.lower()`26432644Возвращает копию последовательности, в которой все символы ASCII в верхнем регистре преобразованы в соответствующие символы нижнего регистра.26452646Например:26472648```python2649>>> b'Hello World'.lower()2650b'hello world'2651```26522653Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.26542655> **Примечание**2656>2657> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.26582659#### `bytes.splitlines(keepends=False)`26602661#### `bytearray.splitlines(keepends=False)`26622663Возвращает список строк в двоичной последовательности, разбивая по границам строк ASCII. Этот метод использует подход [универсального перевода строк](https://python-all.ru/3.15/glossary.html#term-universal-newlines) для разделения строк. Разрывы строк не включаются в итоговый список, если только *keepends* не задано и не равно true.26642665Например:26662667```python2668>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()2669[b'ab c', b'', b'de fg', b'kl']2670>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)2671[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']2672```26732674В отличие от [`split()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и концевой разрыв строки не приводит к появлению дополнительной строки:26752676```python2677>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')2678([b''], [b'Two lines', b''])2679>>> b"".splitlines(), b"One line\n".splitlines()2680([], [b'One line'])2681```26822683#### `bytes.swapcase()`26842685#### `bytearray.swapcase()`26862687Возвращает копию последовательности, в которой все символы ASCII в нижнем регистре преобразованы в соответствующие символы верхнего регистра и наоборот.26882689Например:26902691```python2692>>> b'Hello World'.swapcase()2693b'hELLO wORLD'2694```26952696Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.26972698В отличие от [`str.swapcase()`](https://python-all.ru/3.15/library/stdtypes.html#str.swapcase), для двоичных версий всегда выполняется `bin.swapcase().swapcase() == bin`. Преобразования регистра симметричны в ASCII, хотя это не всегда верно для произвольных кодовых точек Unicode.26992700> **Примечание**2701>2702> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.27032704#### `bytes.title()`27052706#### `bytearray.title()`27072708Возвращает версию двоичной последовательности, в которой каждое слово начинается с заглавной буквы ASCII, а остальные символы – строчные. Байтовые значения без регистра остаются без изменений.27092710Например:27112712```python2713>>> b'Hello world'.title()2714b'Hello World'2715```27162717Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Все остальные байтовые значения не имеют регистра.27182719Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:27202721```python2722>>> b"they're bill's friends from the UK".title()2723b"They'Re Bill'S Friends From The Uk"2724```27252726Обходной путь для апострофов можно построить с помощью регулярных выражений:27272728```python2729>>> import re2730>>> def titlecase(s):2731...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",2732...                   lambda mo: mo.group(0)[0:1].upper() +2733...                              mo.group(0)[1:].lower(),2734...                   s)2735...2736>>> titlecase(b"they're bill's friends.")2737b"They're Bill's Friends."2738```27392740> **Примечание**2741>2742> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.27432744#### `bytes.upper()`27452746#### `bytearray.upper()`27472748Возвращает копию последовательности, в которой все строчные ASCII-символы преобразованы в соответствующие заглавные.27492750Например:27512752```python2753>>> b'Hello World'.upper()2754b'HELLO WORLD'2755```27562757Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.27582759> **Примечание**2760>2761> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.27622763#### `bytes.zfill(width, /)`27642765#### `bytearray.zfill(width, /)`27662767Возвращает копию последовательности, дополненную слева цифрами `b'0'` ASCII, чтобы получить последовательность длины *width*. Ведущий знак (`b'+'`/ `b'-'`) обрабатывается путём вставки дополнения *после* знака, а не до него. Для объектов [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(seq)`.27682769Например:27702771```python2772>>> b"42".zfill(5)2773b'00042'2774>>> b"-42".zfill(5)2775b'-0042'2776```27772778> **Примечание**2779>2780> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.27812782### `printf`-стиль форматирования байтов27832784> **Примечание**2785>2786> Описанные здесь операции форматирования обладают рядом особенностей, которые приводят ко многим распространённым ошибкам (например, неправильное отображение кортежей и словарей). Если выводимое значение может быть кортежем или словарём, оберните его в кортеж.27872788Объекты bytes (`bytes`/`bytearray`) имеют одну уникальную встроенную операцию: оператор `%` (modulo). Он также известен как оператор *форматирования* или *интерполяции* байтов. Для выражения `format % values` (где *format* – это объект bytes) спецификации преобразования `%` в *format* заменяются на ноль или более элементов из *values*. Эффект аналогичен использованию `sprintf()` в языке C.27892790Если *format* требует один аргумент, *values* может быть одним объектом, не являющимся кортежем. [\[5\]](https://python-all.ru/3.15/library/stdtypes.html#id16) В противном случае *values* должен быть кортежем с точным числом элементов, указанным в форматном объекте bytes, или одним отображающим объектом (например, словарём).27912792Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:279327941. Символ `'%'`, обозначающий начало спецификатора.27952. Ключ отображения (необязательно), состоящий из последовательности символов в круглых скобках (например, `(somename)`).27963. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.27974. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.27985. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.27996. Модификатор длины (необязательно).28007. Тип преобразования.28012802Когда правый аргумент является словарём (или другим типом отображения), то форматы в объекте bytes *должны* включать ключ отображения в круглых скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:28032804```python2805>>> print(b'%(language)s has %(number)03d quote types.' %2806...       {b'language': b"Python", b"number": 2})2807b'Python has 002 quote types.'2808```28092810В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).28112812Символы флагов преобразования:28132814| Флаг | Значение |2815| --- | --- |2816| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |2817| `'0'` | Для числовых значений преобразование будет дополняться нулями. |2818| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |2819| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |2820| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |28212822Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, поскольку он не нужен для Python – так, например, `%ld` идентично `%d`.28232824Типы преобразования:28252826| Преобразование | Значение | Примечания |2827| --- | --- | --- |2828| `'d'` | Десятичное целое со знаком. |  |2829| `'i'` | Десятичное целое со знаком. |  |2830| `'o'` | Восьмеричное значение со знаком. | (1) |2831| `'u'` | Устаревший тип – идентичен `'d'`. | (8) |2832| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |2833| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |2834| `'e'` | Экспоненциальный формат с плавающей запятой (строчные буквы). | (3) |2835| `'E'` | Экспоненциальный формат с плавающей запятой (заглавные буквы). | (3) |2836| `'f'` | Десятичный формат с плавающей запятой. | (3) |2837| `'F'` | Десятичный формат с плавающей запятой. | (3) |2838| `'g'` | Формат с плавающей запятой. Использует экспоненциальный формат со строчными буквами если показатель степени меньше -4 или не меньше точности, в противном случае – десятичный формат. | (4) |2839| `'G'` | Формат с плавающей запятой. Использует экспоненциальный формат с заглавными буквами если показатель степени меньше -4 или не меньше точности, в противном случае – десятичный формат. | (4) |2840| `'c'` | Один байт (принимает целое число или объект из одного байта). |  |2841| `'b'` | Байты (любой объект, следующий [протоколу буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects) или имеющий [`__bytes__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__bytes__)). | (5) |2842| `'s'` | `'s'` – псевдоним для `'b'` и должен использоваться только в кодовых базах Python2/3. | (6) |2843| `'a'` | Байты (преобразует любой объект Python с помощью `repr(obj).encode('ascii', 'backslashreplace')`). | (5) |2844| `'r'` | `'r'` – псевдоним для `'a'` и должен использоваться только в кодовых базах Python2/3. | (7) |2845| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |28462847Примечания:284828491. Альтернативная форма вставляет ведущий восьмеричный спецификатор (`'0o'`) перед первой цифрой.28502. Альтернативная форма вставляет перед первой цифрой ведущий `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`).28513. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.28522853   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.28544. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.28552856   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.28575. Если точность равна `N`, вывод усекается до `N` символов.28586. `b'%s'` устарело, но не будет удалено в серии 3.x.28597. `b'%r'` устарело, но не будет удалено в серии 3.x.28608. См. [**PEP 237**](https://python-all.ru/3.15/library/stdtypes.html).28612862> **Примечание**2863>2864> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.28652866> **См. также**2867>2868> [**PEP 461**](https://python-all.ru/3.15/library/stdtypes.html) – добавление форматирования % для bytes и bytearray28692870Добавлено в версии 3.5.28712872### Представления памяти28732874Объекты [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [протокол буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects), без копирования.28752876#### `class memoryview(object)`28772878Создаёт `memoryview`, ссылающийся на *объект*. *Объект* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray).28792880`memoryview` имеет понятие *элемента*, который является атомарной единицей памяти, обрабатываемой исходным *объектом*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray), элемент – это один байт, но другие типы, например [`array.array`](https://python-all.ru/3.15/library/array.html#array.array), могут иметь более крупные элементы.28812882`memoryview` являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по типу своих базовых данных.28832884`len(view)` равно длине [`tolist()`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.tolist), которая является вложенным списком, представляющим представление. Если `view.ndim = 1`, то это равно количеству элементов в представлении.28852886Изменено в версии 3.12: Если `view.ndim == 0`, `len(view)` теперь вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) вместо возврата 1.28872888Атрибут [`itemsize`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.itemsize) возвращает количество байт в одном элементе.28892890`memoryview` поддерживает срезы и индексацию для доступа к своим данным. Одномерный срез приводит к подпредставлению:28912892```python2893>>> v = memoryview(b'abcefg')2894>>> v[1]2895982896>>> v[-1]28971032898>>> v[1:4]2899<memory at 0x7f3ddc9f4350>2900>>> bytes(v[1:4])2901b'bce'2902```29032904Если [`format`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.format) – один из собственных спецификаторов формата из модуля [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct), то также поддерживается индексация целым числом или кортежем целых чисел, которая возвращает отдельный *элемент* с правильным типом. Одномерные memoryview можно индексировать целым числом или кортежем из одного целого. Многомерные memoryview можно индексировать кортежами ровно из *ndim* целых чисел, где *ndim* – количество измерений. Нулевые memoryview можно индексировать пустым кортежем.29052906Вот пример с небайтовым форматом:29072908```python2909>>> import array2910>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])2911>>> m = memoryview(a)2912>>> m[0]2913-111111112914>>> m[-1]2915444444442916>>> m[::2].tolist()2917[-11111111, -33333333]2918```29192920Если базовый объект доступен для записи, memoryview поддерживает одномерное присваивание среза. Изменение размера не допускается:29212922```python2923>>> data = bytearray(b'abcefg')2924>>> v = memoryview(data)2925>>> v.readonly2926False2927>>> v[0] = ord(b'z')2928>>> data2929bytearray(b'zbcefg')2930>>> v[1:4] = b'123'2931>>> data2932bytearray(b'z123fg')2933>>> v[2:3] = b'spam'2934Traceback (most recent call last):2935  File "<stdin>", line 1, in <module>2936ValueError: memoryview assignment: lvalue and rvalue have different structures2937>>> v[2:6] = b'spam'2938>>> data2939bytearray(b'z1spam')2940```29412942Одномерные memoryview [хэшируемых](https://python-all.ru/3.15/glossary.html#term-hashable) (только для чтения) типов с форматами 'B', 'b' или 'c' также хэшируемы. Хэш определяется как `hash(m) == hash(m.tobytes())`:29432944```python2945>>> v = memoryview(b'abcefg')2946>>> hash(v) == hash(b'abcefg')2947True2948>>> hash(v[2:4]) == hash(b'ce')2949True2950>>> hash(v[::-2]) == hash(b'abcefg'[::-2])2951True2952```29532954Изменено в версии 3.3: Одномерные memoryview теперь можно разрезать. Одномерные memoryview с форматами 'B', 'b' или 'c' теперь [хэшируемы](https://python-all.ru/3.15/glossary.html#term-hashable).29552956Изменено в версии 3.4: memoryview теперь автоматически регистрируется с помощью [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence)29572958Изменено в версии 3.5: memoryview теперь можно индексировать кортежем целых чисел.29592960Изменено в версии 3.14: memoryview теперь является [обобщённым типом](https://python-all.ru/3.15/glossary.html#term-generic-type).29612962`memoryview` имеет несколько методов:29632964#### `__eq__(exporter)`29652966Memoryview и [**PEP 3118**](https://python-all.ru/3.15/library/stdtypes.html) экспортёр равны, если их формы эквивалентны и если все соответствующие значения равны при интерпретации кодов формата операндов с использованием синтаксиса [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct).29672968Для подмножества строк формата [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct), поддерживаемых в настоящее время [`tolist()`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.tolist), `v` и `w` равны, если `v.tolist() == w.tolist()`:29692970```python2971>>> import array2972>>> a = array.array('I', [1, 2, 3, 4, 5])2973>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])2974>>> c = array.array('b', [5, 3, 1])2975>>> x = memoryview(a)2976>>> y = memoryview(b)2977>>> x == a == y == b2978True2979>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()2980True2981>>> z = y[::-2]2982>>> z == c2983True2984>>> z.tolist() == c.tolist()2985True2986```29872988Если какая-либо строка формата не поддерживается модулем [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct), то объекты всегда будут сравниваться как неравные (даже если строки формата и содержимое буфера одинаковы):29892990```python2991>>> from ctypes import BigEndianStructure, c_long2992>>> class BEPoint(BigEndianStructure):2993...     _fields_ = [("x", c_long), ("y", c_long)]2994...2995>>> point = BEPoint(100, 200)2996>>> a = memoryview(point)2997>>> b = memoryview(point)2998>>> a == point2999False3000>>> a == b3001False3002```30033004Обратите внимание, что, как и для чисел с плавающей точкой, `v is w` *не* подразумевает `v == w` для объектов memoryview.30053006Изменено в версии 3.3: В предыдущих версиях сравнивалась необработанная память без учёта формата элемента и логической структуры массива.30073008#### `tobytes(order='C')`30093010Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) для memoryview.30113012```python3013>>> m = memoryview(b"abc")3014>>> m.tobytes()3015b'abc'3016>>> bytes(m)3017b'abc'3018```30193020Для несплошных массивов результат равен плоскому списку, представляющему данные, со всеми элементами, преобразованными в байты. `tobytes()` поддерживает все строки формата, включая те, которые не соответствуют синтаксису модуля [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct).30213022Добавлено в версии 3.8: *order* может быть {‘C’, ‘F’, ‘A’}. Когда *order* равен ‘C’ или ‘F’, данные исходного массива преобразуются в порядок C или Fortran. Для сплошных представлений ‘A’ возвращает точную копию физической памяти. В частности, порядок Fortran в памяти сохраняется. Для несплошных представлений данные сначала преобразуются в C. *order=None* то же самое, что *order='C'*.30233024#### `hex(*, bytes_per_sep=1)`30253026#### `hex(sep, bytes_per_sep=1)`30273028Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в буфере.30293030```python3031>>> m = memoryview(b"abc")3032>>> m.hex()3033'616263'3034```30353036Добавлено в версии 3.5.30373038Изменено в версии 3.8: Аналогично [`bytes.hex()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.hex), `memoryview.hex()` теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.30393040#### `tolist()`30413042Возвращает данные в буфере в виде списка элементов.30433044```python3045>>> memoryview(b'abc').tolist()3046[97, 98, 99]3047>>> import array3048>>> a = array.array('d', [1.1, 2.2, 3.3])3049>>> m = memoryview(a)3050>>> m.tolist()3051[1.1, 2.2, 3.3]3052```30533054Изменено в версии 3.3: `tolist()` теперь поддерживает все односимвольные нативные форматы в синтаксисе модуля [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct), а также многомерные представления.30553056#### `toreadonly()`30573058Возвращает версию объекта memoryview, доступную только для чтения. Исходный объект memoryview остаётся неизменным.30593060```python3061>>> m = memoryview(bytearray(b'abc'))3062>>> mm = m.toreadonly()3063>>> mm.tolist()3064[97, 98, 99]3065>>> mm[0] = 423066Traceback (most recent call last):3067  File "<stdin>", line 1, in <module>3068TypeError: cannot modify read-only memory3069>>> m[0] = 433070>>> mm.tolist()3071[43, 98, 99]3072```30733074Добавлено в версии 3.8.30753076#### `release()`30773078Освобождает буфер, предоставляемый объектом memoryview. Многие объекты выполняют специальные действия, когда на них удерживается представление (например, [`bytearray`](https://python-all.ru/3.15/library/stdtypes.html#bytearray) временно запрещает изменение размера); поэтому вызов release() удобен для снятия этих ограничений (и освобождения любых зависших ресурсов) как можно скорее.30793080После вызова этого метода любая дальнейшая операция над представлением вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError) (за исключением самого `release()`, который может быть вызван несколько раз):30813082```python3083>>> m = memoryview(b'abc')3084>>> m.release()3085>>> m[0]3086Traceback (most recent call last):3087  File "<stdin>", line 1, in <module>3088ValueError: operation forbidden on released memoryview object3089```30903091Протокол управления контекстом может использоваться для аналогичного эффекта с помощью оператора `with`:30923093```python3094>>> with memoryview(b'abc') as m:3095...     m[0]3096...3097973098>>> m[0]3099Traceback (most recent call last):3100  File "<stdin>", line 1, in <module>3101ValueError: operation forbidden on released memoryview object3102```31033104Добавлено в версии 3.2.31053106#### `cast(format, /)`31073108#### `cast(format, shape, /)`31093110Преобразует memoryview в новый формат или форму. *shape* по умолчанию равен `[byte_length//new_itemsize]`, что означает, что результирующее представление будет одномерным. Возвращаемое значение – новый memoryview, но сам буфер не копируется. Поддерживаемые преобразования: 1D -\> C-[contiguous](https://python-all.ru/3.15/glossary.html#term-contiguous) и C-contiguous -\> 1D.31113112Целевой формат ограничен одноэлементным нативным форматом в синтаксисе [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct). Один из форматов должен быть байтовым ('B', 'b' или 'c'). Байтовая длина результата должна совпадать с исходной длиной. Обратите внимание, что все байтовые длины могут зависеть от операционной системы.31133114Преобразование 1D/long в 1D/unsigned bytes:31153116```python3117>>> import array3118>>> a = array.array('l', [1,2,3])3119>>> x = memoryview(a)3120>>> x.format3121'l'3122>>> x.itemsize312383124>>> len(x)312533126>>> x.nbytes3127243128>>> y = x.cast('B')3129>>> y.format3130'B'3131>>> y.itemsize313213133>>> len(y)3134243135>>> y.nbytes3136243137```31383139Преобразование 1D/unsigned bytes в 1D/char:31403141```python3142>>> b = bytearray(b'zyz')3143>>> x = memoryview(b)3144>>> x[0] = b'a'3145Traceback (most recent call last):3146  ...3147TypeError: memoryview: invalid type for format 'B'3148>>> y = x.cast('c')3149>>> y[0] = b'a'3150>>> b3151bytearray(b'ayz')3152```31533154Преобразование 1D/bytes в 3D/ints в 1D/signed char:31553156```python3157>>> import struct3158>>> buf = struct.pack("i"*12, *list(range(12)))3159>>> x = memoryview(buf)3160>>> y = x.cast('i', shape=[2,2,3])3161>>> y.tolist()3162[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]3163>>> y.format3164'i'3165>>> y.itemsize316643167>>> len(y)316823169>>> y.nbytes3170483171>>> z = y.cast('b')3172>>> z.format3173'b'3174>>> z.itemsize317513176>>> len(z)3177483178>>> z.nbytes3179483180```31813182Преобразование 1D/unsigned long в 2D/unsigned long:31833184```python3185>>> buf = struct.pack("L"*6, *list(range(6)))3186>>> x = memoryview(buf)3187>>> y = x.cast('L', shape=[2,3])3188>>> len(y)318923190>>> y.nbytes3191483192>>> y.tolist()3193[[0, 1, 2], [3, 4, 5]]3194```31953196Добавлено в версии 3.3.31973198Изменено в версии 3.5: Исходный формат больше не ограничен при преобразовании в байтовое представление.31993200#### `count(value, /)`32013202Подсчитывает количество вхождений *value*.32033204Добавлено в версии 3.14.32053206#### `index(value, start=0, stop=sys.maxsize, /)`32073208Возвращает индекс первого вхождения *value* (начиная с индекса *start* и до индекса *stop*).32093210Вызывает [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError), если *value* не найден.32113212Добавлено в версии 3.14.32133214Также доступно несколько атрибутов только для чтения:32153216#### `obj`32173218Базовый объект memoryview:32193220```python3221>>> b  = bytearray(b'xyz')3222>>> m = memoryview(b)3223>>> m.obj is b3224True3225```32263227Добавлено в версии 3.3.32283229#### `nbytes`32303231`nbytes == product(shape) * itemsize == len(m.tobytes())`. Это объём в байтах, который массив занимал бы в непрерывном представлении. Он не обязательно равен `len(m)`:32323233```python3234>>> import array3235>>> a = array.array('i', [1,2,3,4,5])3236>>> m = memoryview(a)3237>>> len(m)323853239>>> m.nbytes3240203241>>> y = m[::2]3242>>> len(y)324333244>>> y.nbytes3245123246>>> len(y.tobytes())3247123248```32493250Многомерные массивы:32513252```python3253>>> import struct3254>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])3255>>> x = memoryview(buf)3256>>> y = x.cast('d', shape=[3,4])3257>>> y.tolist()3258[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]3259>>> len(y)326033261>>> y.nbytes3262963263```32643265Добавлено в версии 3.3.32663267#### `readonly`32683269Логическое значение bool, указывающее, доступна ли память только для чтения.32703271#### `format`32723273Строка, содержащая формат (в стиле модуля [`struct`](https://python-all.ru/3.15/library/struct.html#module-struct)) для каждого элемента в представлении. Memoryview может быть создан из экспортёров с произвольными строками формата, но некоторые методы (например, [`tolist()`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.tolist)) ограничены нативными одноэлементными форматами.32743275Изменено в версии 3.3: формат `'B'` теперь обрабатывается в соответствии с синтаксисом модуля struct. Это означает, что `memoryview(b'abc')[0] == b'abc'[0] == 97`.32763277#### `itemsize`32783279Размер в байтах каждого элемента memoryview:32803281```python3282>>> import array, struct3283>>> m = memoryview(array.array('H', [32000, 32001, 32002]))3284>>> m.itemsize328523286>>> m[0]3287320003288>>> struct.calcsize('H') == m.itemsize3289True3290```32913292#### `ndim`32933294Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.32953296#### `shape`32973298Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.ndim), задающий форму памяти как N-мерного массива.32993300Изменено в версии 3.3: пустой кортеж вместо `None`, когда ndim = 0.33013302#### `strides`33033304Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.15/library/stdtypes.html#memoryview.ndim), задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.33053306Изменено в версии 3.3: пустой кортеж вместо `None`, когда ndim = 0.33073308#### `suboffsets`33093310Используется внутри для массивов в стиле PIL. Значение носит только информационный характер.33113312#### `c_contiguous`33133314Логическое значение (bool), указывающее, является ли память C-[непрерывной](https://python-all.ru/3.15/glossary.html#term-contiguous).33153316Добавлено в версии 3.3.33173318#### `f_contiguous`33193320Логическое значение (bool), указывающее, является ли память [непрерывной](https://python-all.ru/3.15/glossary.html#term-contiguous) по Фортрану.33213322Добавлено в версии 3.3.33233324#### `contiguous`33253326Логическое значение (bool), указывающее, является ли память [непрерывной](https://python-all.ru/3.15/glossary.html#term-contiguous).33273328Добавлено в версии 3.3.33293330Информацию о потокобезопасности объектов [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview) в [сборке со свободной многопоточностью](https://python-all.ru/3.15/glossary.html#term-free-threaded-build) см. в [Потокобезопасность объектов memoryview](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-memoryview).33313332## Типы множеств – [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset)33333334Объект *set* – это неупорядоченная коллекция уникальных [хэшируемых](https://python-all.ru/3.15/glossary.html#term-hashable) объектов. Обычно используется для проверки принадлежности, удаления дубликатов из последовательности и выполнения математических операций, таких как пересечение, объединение, разность и симметрическая разность. (О других контейнерах см. встроенные классы [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.15/library/stdtypes.html#list) и [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), а также модуль [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections).)33353336Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множество не запоминает положение элементов или порядок вставки. Поэтому множества не поддерживают индексацию, срезы и другое поведение, свойственное последовательностям.33373338В настоящее время существует два встроенных типа множеств: [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset). Тип `set` является изменяемым – содержимое можно менять с помощью методов вроде [`add()`](https://python-all.ru/3.15/library/stdtypes.html#set.add) и [`remove()`](https://python-all.ru/3.15/library/stdtypes.html#set.remove). Поскольку он изменяемый, у него нет хэш-значения, и его нельзя использовать ни как ключ словаря, ни как элемент другого множества. Тип `frozenset` является неизменяемым и [хэшируемым](https://python-all.ru/3.15/glossary.html#term-hashable) – его содержимое нельзя изменить после создания; поэтому его можно использовать как ключ словаря или как элемент другого множества.33393340Непустые множества (кроме frozenset) можно создать, поместив список элементов, разделённый запятыми, в фигурные скобки, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.15/library/stdtypes.html#set).33413342Конструкторы обоих классов работают одинаково:33433344#### `class set(iterable=(), /)`33453346#### `class frozenset(iterable=(), /)`33473348Возвращает новый объект set или frozenset, элементы которого берутся из *iterable*. Элементы множества должны быть [хэшируемыми](https://python-all.ru/3.15/glossary.html#term-hashable). Чтобы представлять множества множеств, внутренние множества должны быть `frozenset` объектами. Если *iterable* не указан, возвращается новое пустое множество.33493350Множества можно создать несколькими способами:33513352- Используйте разделённый запятыми список элементов в фигурных скобках: `{'jack', 'sjoerd'}`3353- Используйте абстракцию множества: `{c for c in 'abracadabra' if c not in 'abc'}`3354- Используйте конструктор типа: `set()`, `set('foobar')`, `set(['a', 'b', 'foo'])`33553356Экземпляры [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset) предоставляют следующие операции:33573358#### `len(s)`33593360Возвращает количество элементов в множестве *s* (мощность *s*).33613362#### `x in s`33633364Проверяет принадлежность *x* множеству *s*.33653366#### `x not in s`33673368Проверяет отсутствие *x* в множестве *s*.33693370#### `frozenset.isdisjoint(other, /)`33713372#### `set.isdisjoint(other, /)`33733374Возвращает `True`, если у множества нет общих элементов с *other*. Множества не пересекаются тогда и только тогда, когда их пересечение – пустое множество.33753376#### `frozenset.issubset(other, /)`33773378#### `set.issubset(other, /)`33793380#### `set <= other`33813382Проверяет, принадлежит ли каждый элемент множества множеству *other*.33833384#### `set < other`33853386Проверяет, является ли множество строгим подмножеством *other*, то есть `set <= other and set != other`.33873388#### `frozenset.issuperset(other, /)`33893390#### `set.issuperset(other, /)`33913392#### `set >= other`33933394Проверяет, принадлежит ли каждый элемент *other* множеству.33953396#### `set > other`33973398Проверяет, является ли множество строгим надмножеством *other*, то есть `set >= other and set != other`.33993400#### `frozenset.union(*others)`34013402#### `set.union(*others)`34033404#### `set | other | ...`34053406Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.34073408#### `frozenset.intersection(*others)`34093410#### `set.intersection(*others)`34113412#### `set & other & ...`34133414Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.34153416#### `frozenset.difference(*others)`34173418#### `set.difference(*others)`34193420#### `set - other - ...`34213422Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.34233424#### `frozenset.symmetric_difference(other, /)`34253426#### `set.symmetric_difference(other, /)`34273428#### `set ^ other`34293430Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в *other*, но не в обоих.34313432#### `frozenset.copy()`34333434#### `set.copy()`34353436Возвращает поверхностную копию множества.34373438Обратите внимание: не-операторные версии методов [`union()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.union), [`intersection()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.intersection), [`difference()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.difference), [`symmetric_difference()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.symmetric_difference), [`issubset()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.issubset) и [`issuperset()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset.issuperset) принимают в качестве аргумента любой итерируемый объект. В отличие от них, их аналоги на основе операторов требуют, чтобы аргументы были множествами. Это устраняет подверженные ошибкам конструкции вроде `set('abc') & 'cbs'` в пользу более читаемой `set('abc').intersection('cbs')`.34393440И [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), и [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset) поддерживают сравнение множеств. Два множества равны тогда и только тогда, когда каждый элемент одного содержится в другом (каждое является подмножеством другого). Множество меньше другого тогда и только тогда, когда первое является собственным подмножеством второго (является подмножеством, но не равным). Множество больше другого тогда и только тогда, когда первое является собственным надмножеством второго (является надмножеством, но не равным).34413442Экземпляры [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) сравниваются с экземплярами [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset) на основе их элементов. Например, `set('abc') == frozenset('abc')` возвращает `True`, и то же самое делает `set('abc') in set([frozenset('abc')])`.34433444Сравнения на подмножество и равенство не обобщаются до функции полного упорядочения. Например, любые два непустых непересекающихся множества не равны и не являются подмножествами друг друга, поэтому *все* из следующих возвращают `False`: `a<b`, `a==b` или `a>b`.34453446Поскольку множества определяют лишь частичное упорядочение (отношения подмножеств), результат метода [`list.sort()`](https://python-all.ru/3.15/library/stdtypes.html#list.sort) для списков множеств не определён.34473448Элементы множества, как и ключи словаря, должны быть [хэшируемыми](https://python-all.ru/3.15/glossary.html#term-hashable).34493450Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр `frozenset`.34513452В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), которые не применимы к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset):34533454#### `set.update(*others)`34553456#### `set |= other | ...`34573458Обновляет множество, добавляя элементы из всех других.34593460#### `set.intersection_update(*others)`34613462#### `set &= other & ...`34633464Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.34653466#### `set.difference_update(*others)`34673468#### `set -= other | ...`34693470Обновляет множество, удаляя элементы, найденные в других.34713472#### `set.symmetric_difference_update(other, /)`34733474#### `set ^= other`34753476Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.34773478#### `set.add(elem, /)`34793480Добавляет элемент *elem* в множество.34813482#### `set.remove(elem, /)`34833484Удаляет элемент *elem* из множества. Вызывает [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError), если *elem* отсутствует в множестве.34853486#### `set.discard(elem, /)`34873488Удаляет элемент *elem* из множества, если он присутствует.34893490#### `set.pop()`34913492Удаляет и возвращает произвольный элемент множества. Вызывает [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError), если множество пусто.34933494#### `set.clear()`34953496Удаляет все элементы из множества.34973498Обратите внимание: не-операторные версии методов [`update()`](https://python-all.ru/3.15/library/stdtypes.html#set.update), [`intersection_update()`](https://python-all.ru/3.15/library/stdtypes.html#set.intersection_update), [`difference_update()`](https://python-all.ru/3.15/library/stdtypes.html#set.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.15/library/stdtypes.html#set.symmetric_difference_update) принимают любой итерируемый объект в качестве аргумента.34993500Обратите внимание: аргумент *elem* методов [`__contains__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.15/library/stdtypes.html#set.remove) и [`discard()`](https://python-all.ru/3.15/library/stdtypes.html#set.discard) может быть множеством. Для поддержки поиска эквивалентного frozenset создаётся временное множество из *elem*.35013502set и frozenset являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по типу своих элементов.35033504> **См. также**3505>3506> Подробную информацию о гарантиях потокобезопасности для объектов [`set`](https://python-all.ru/3.15/library/stdtypes.html#set) см. в [Потокобезопасность для объектов set](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-set).35073508## Типы отображений – `dict`, `frozendict`35093510A [mapping](https://python-all.ru/3.15/glossary.html#term-mapping) object maps [hashable](https://python-all.ru/3.15/glossary.html#term-hashable) values to arbitrary objects. There are currently two standard mapping types, the *dictionary* and [`frozendict`](https://python-all.ru/3.15/library/stdtypes.html#frozendict). (For other containers see the built-in [`list`](https://python-all.ru/3.15/library/stdtypes.html#list), [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), and [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) classes, and the [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections) module.)35113512Ключами словаря могут быть *почти* любые значения. Значения, которые не являются [хэшируемыми](https://python-all.ru/3.15/glossary.html#term-hashable), то есть содержащие списки, словари или другие изменяемые типы (сравниваемые по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Значения, которые сравниваются как равные (например, `1`, `1.0` и `True`), могут взаимозаменяемо использоваться для индексации одной и той же записи словаря.35133514#### `class dict(**kwargs)`35153516#### `class dict(mapping, /, **kwargs)`35173518#### `class dict(iterable, /, **kwargs)`35193520Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.35213522Словари могут быть созданы несколькими способами:35233524- Используйте разделённый запятыми список пар `key: value` в фигурных скобках: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`3525- Используйте словарное включение: `{}`, `{x: x ** 2 for x in range(10)}`3526- Используйте конструктор типа: `dict()`, `dict([('foo', 100), ('bar', 200)])`, `dict(foo=100, bar=200)`35273528Если позиционный аргумент не передан, создаётся пустой словарь. Если позиционный аргумент передан и определяет метод `keys()`, словарь создаётся вызовом [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) для аргумента с каждым возвращённым ключом из этого метода. В противном случае позиционный аргумент должен быть объектом [итерируемый объект](https://python-all.ru/3.15/glossary.html#term-iterable). Каждый элемент итерируемого объекта также должен быть итерируемым ровно с двумя элементами. Первый элемент каждой пары становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.35293530Если переданы именованные аргументы, они и их значения добавляются в словарь, созданный из позиционного аргумента. Если добавляемый ключ уже присутствует, значение из именованного аргумента заменяет значение из позиционного аргумента.35313532Словари считаются равными тогда и только тогда, когда они содержат одинаковые пары `(key, value)` (независимо от порядка). Операции сравнения порядка (‘\<’, ‘\<=’, ‘\>=’, ‘\>’) вызывают [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError). Чтобы проиллюстрировать создание словарей и равенство, следующие примеры возвращают словарь, равный `{"one": 1, "two": 2, "three": 3}`:35333534```python3535>>> a = dict(one=1, two=2, three=3)3536>>> b = {'one': 1, 'two': 2, 'three': 3}3537>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))3538>>> d = dict([('two', 2), ('one', 1), ('three', 3)])3539>>> e = dict({'three': 3, 'one': 1, 'two': 2})3540>>> f = dict({'one': 1, 'three': 3}, two=2)3541>>> a == b == c == d == e == f3542True3543```35443545Передача именованных аргументов, как в первом примере, работает только для ключей, являющихся допустимыми идентификаторами Python. В противном случае можно использовать любые допустимые ключи.35463547Словари сохраняют порядок вставки. Обратите внимание, что обновление ключа не влияет на порядок. Ключи, добавленные после удаления, вставляются в конец.35483549```python3550>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}3551>>> d3552{'one': 1, 'two': 2, 'three': 3, 'four': 4}3553>>> list(d)3554['one', 'two', 'three', 'four']3555>>> list(d.values())3556[1, 2, 3, 4]3557>>> d["one"] = 423558>>> d3559{'one': 42, 'two': 2, 'three': 3, 'four': 4}3560>>> del d["two"]3561>>> d["two"] = None3562>>> d3563{'one': 42, 'three': 3, 'four': 4, 'two': None}3564```35653566Изменено в версии 3.7: Порядок словарей гарантированно соответствует порядку вставки. Это поведение было деталью реализации CPython начиная с версии 3.6.35673568Словари являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по двум типам, обозначающим (соответственно) типы ключей и значений словаря.35693570Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):35713572#### `list(d)`35733574Возвращает список всех ключей, используемых в словаре *d*.35753576#### `len(d)`35773578Возвращает количество элементов в словаре *d*.35793580#### `d[key]`35813582Возвращает элемент словаря *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError), если *key* отсутствует в отображении.35833584Если подкласс dict определяет метод [`__missing__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__missing__), а *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает результат вызова `__missing__(key)`. Никакие другие операции или методы не вызывают `__missing__()`. Если `__missing__()` не определён, возбуждается [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError). `__missing__()` должен быть методом; он не может быть переменной экземпляра:35853586```python3587>>> class Counter(dict):3588...     def __missing__(self, key):3589...         return 03590...3591>>> c = Counter()3592>>> c['red']359303594>>> c['red'] += 13595>>> c['red']359613597```35983599Пример выше показывает часть реализации [`collections.Counter`](https://python-all.ru/3.15/library/collections.html#collections.Counter). Другой метод `__missing__()` используется в [`collections.defaultdict`](https://python-all.ru/3.15/library/collections.html#collections.defaultdict).36003601#### `d[key] = value`36023603Устанавливает `d[key]` в значение *value*.36043605#### `del d[key]`36063607Удаляет `d[key]` из *d*. Вызывает [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError), если *key* отсутствует в отображении.36083609#### `key in d`36103611Возвращает `True`, если *d* содержит ключ *key*, иначе `False`.36123613#### `key not in d`36143615Эквивалентно `not key in d`.36163617#### `iter(d)`36183619Возвращает итератор по ключам словаря. Это краткая форма записи для `iter(d.keys())`.36203621#### `clear()`36223623Удаляет все элементы из словаря.36243625#### `copy()`36263627Возвращает поверхностную копию словаря.36283629#### `classmethod fromkeys(iterable, value=None, /)`36303631Создаёт новый словарь с ключами из *iterable* и значениями, установленными в *value*.36323633`fromkeys()` – это метод класса, возвращающий новый словарь. *value* по умолчанию равен `None`. Все значения ссылаются на один и тот же экземпляр, поэтому обычно не имеет смысла делать *value* изменяемым объектом, например пустым списком. Чтобы получить разные значения, используйте вместо этого [dict comprehension](https://python-all.ru/3.15/reference/expressions.html#dict).36343635#### `get(key, default=None, /)`36363637Возвращает значение для *key*, если *key* присутствует в словаре, иначе *default*. Если *default* не указан, по умолчанию принимается `None`, поэтому этот метод никогда не вызывает исключение [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError).36383639#### `items()`36403641Возвращает новое представление элементов словаря (пары `(key, value)`). См. [документацию по объектам-представлениям](https://python-all.ru/3.15/library/stdtypes.html#dict-views).36423643#### `keys()`36443645Возвращает новое представление ключей словаря. См. [документацию по объектам-представлениям](https://python-all.ru/3.15/library/stdtypes.html#dict-views).36463647#### `pop(key, /)`36483649#### `pop(key, default, /)`36503651Если *key* присутствует в словаре, удаляет его и возвращает значение, иначе возвращает *default*. Если *default* не указан и *key* отсутствует в словаре, возбуждается [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError).36523653#### `popitem()`36543655Удаляет и возвращает пару `(key, value)` из словаря. Пары возвращаются в порядке LIFO.36563657`popitem()` полезен для разрушающего обхода словаря, как часто используется в алгоритмах над множествами. Если словарь пуст, вызов `popitem()` вызывает исключение [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError).36583659Изменено в версии 3.7: Теперь гарантируется порядок LIFO. В предыдущих версиях `popitem()` мог вернуть произвольную пару ключ/значение.36603661#### `reversed(d)`36623663Возвращает обратный итератор по ключам словаря. Это сокращение для `reversed(d.keys())`.36643665Добавлено в версии 3.8.36663667#### `setdefault(key, default=None, /)`36683669Если *key* есть в словаре, возвращает его значение. Если нет, вставляет *key* со значением *default* и возвращает *default*. *default* по умолчанию равен `None`.36703671#### `update(**kwargs)`36723673#### `update(mapping, /, **kwargs)`36743675#### `update(iterable, /, **kwargs)`36763677Обновляет словарь парами ключ/значение из *mapping* или *iterable* и *kwargs*, перезаписывая существующие ключи. Возвращает `None`.36783679`update()` принимает либо другой объект с методом `keys()` (в этом случае [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) вызывается для каждого ключа, возвращённого этим методом), либо итерируемый объект пар ключ/значение (кортежи или другие итерабельные объекты длины два). Если указаны именованные аргументы, словарь затем обновляется этими парами: `d.update(red=1, blue=2)`.36803681#### `values()`36823683Возвращает новое представление (view) значений словаря. См. [документацию по объектам-представлениям](https://python-all.ru/3.15/library/stdtypes.html#dict-views).36843685Сравнение на равенство между двумя представлениями `dict.values()` всегда возвращает `False`. Это также относится к сравнению `dict.values()` с самим собой:36863687```python3688>>> d = {'a': 1}3689>>> d.values() == d.values()3690False3691```36923693#### `d | other`36943695Создаёт новый словарь, содержащий объединённые ключи и значения из *d* и *other*; оба должны быть словарями. Значения из *other* имеют приоритет, если *d* и *other* имеют одинаковые ключи.36963697Добавлено в версии 3.9.36983699#### `d |= other`37003701Обновляет словарь *d* ключами и значениями из *other*, который может быть либо [отображением](https://python-all.ru/3.15/glossary.html#term-mapping), либо [итерируемым объектом](https://python-all.ru/3.15/glossary.html#term-iterable) пар ключ/значение. Значения из *other* имеют приоритет, если *d* и *other* имеют одинаковые ключи.37023703Добавлено в версии 3.9.37043705Словари и их представления обратимы.37063707```python3708>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}3709>>> d3710{'one': 1, 'two': 2, 'three': 3, 'four': 4}3711>>> list(reversed(d))3712['four', 'three', 'two', 'one']3713>>> list(reversed(d.values()))3714[4, 3, 2, 1]3715>>> list(reversed(d.items()))3716[('four', 4), ('three', 3), ('two', 2), ('one', 1)]3717```37183719Изменено в версии 3.8: Теперь словари обратимы.37203721> **См. также**3722>3723> [`frozendict`](https://python-all.ru/3.15/library/stdtypes.html#frozendict) и [`types.MappingProxyType`](https://python-all.ru/3.15/library/types.html#types.MappingProxyType) можно использовать для создания представления `dict` только для чтения.37243725> **См. также**3726>3727> Подробную информацию о гарантиях безопасности потоков для объектов [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict) см. в [Thread safety for dict objects](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-dict).37283729### Объекты представления словаря37303731Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.15/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.15/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.15/library/stdtypes.html#dict.items), являются *объектами-представлениями*. Они предоставляют динамическое представление записей словаря, то есть при изменении словаря представление отражает эти изменения.37323733Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:37343735#### `len(dictview)`37363737Возвращает количество записей в словаре.37383739#### `iter(dictview)`37403741Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) в словаре.37423743Ключи и значения обходятся в порядке вставки. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.15/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать такой же список – `pairs = [(v, k) for (k, v) in d.items()]`.37443745Обход представлений во время добавления или удаления записей из словаря может вызвать [`RuntimeError`](https://python-all.ru/3.15/library/exceptions.html#RuntimeError) или не позволить обойти все записи.37463747Изменено в версии 3.7: Теперь гарантируется, что порядок словаря соответствует порядку вставки.37483749#### `x in dictview`37503751Возвращает `True`, если *x* находится в ключах, значениях или элементах (items) базового словаря (в последнем случае *x* должен быть кортежем `(key, value)`).37523753#### `reversed(dictview)`37543755Возвращает реверсивный итератор по ключам, значениям или элементам словаря. Представление (view) будет обходиться в порядке, обратном порядку вставки.37563757Изменено в версии 3.8: Представления словарей теперь можно обходить в обратном порядке.37583759#### `dictview.mapping`37603761Возвращает [`types.MappingProxyType`](https://python-all.ru/3.15/library/types.html#types.MappingProxyType), который оборачивает исходный словарь, на который ссылается представление.37623763Добавлено в версии 3.10.37643765Представления ключей (keys views) ведут себя как множества, поскольку их элементы уникальны и [хешируемы](https://python-all.ru/3.15/glossary.html#term-hashable). Представления элементов (items views) также поддерживают операции, подобные множествам, так как пары (ключ, значение) уникальны, а ключи хешируемы. Если все значения в представлении элементов также хешируемы, то такое представление может взаимодействовать с другими множествами. (Представления значений (values views) не рассматриваются как множества, поскольку элементы обычно не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса [`collections.abc.Set`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Set) (например, `==`, `<` или `^`). При использовании операторов множеств представления, подобные множествам, принимают любой итерируемый объект в качестве второго операнда, в отличие от множеств, которые принимают только множества.37663767Пример использования представления словаря:37683769```python3770>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}3771>>> keys = dishes.keys()3772>>> values = dishes.values()37733774>>> # итерация3775>>> n = 03776>>> for val in values:3777...     n += val3778...3779>>> print(n)378050437813782>>> # ключи и значения перебираются в одном порядке (порядок вставки)3783>>> list(keys)3784['eggs', 'sausage', 'bacon', 'spam']3785>>> list(values)3786[2, 1, 1, 500]37873788>>> # объекты представления динамичны и отражают изменения словаря3789>>> del dishes['eggs']3790>>> del dishes['sausage']3791>>> list(keys)3792['bacon', 'spam']37933794>>> # операции над множествами3795>>> keys & {'eggs', 'bacon', 'salad'}3796{'bacon'}3797>>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}3798True3799>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}3800True38013802>>> # получить прокси только для чтения исходного словаря3803>>> values.mapping3804mappingproxy({'bacon': 1, 'spam': 500})3805>>> values.mapping['spam']38065003807```38083809### Замороженные словари38103811#### `class frozendict(**kwargs)`38123813#### `class frozendict(mapping, /, **kwargs)`38143815#### `class frozendict(iterable, /, **kwargs)`38163817Возвращает новый замороженный словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.38183819`frozendict` имеет API, схожий с API [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict), со следующими отличиями:38203821- `dict` имеет больше методов, чем `frozendict`:38223823  > - `__delitem__()`3824  > - `__setitem__()`3825  > - [`clear()`](https://python-all.ru/3.15/library/stdtypes.html#dict.clear)3826  > - [`pop()`](https://python-all.ru/3.15/library/stdtypes.html#dict.pop)3827  > - [`popitem()`](https://python-all.ru/3.15/library/stdtypes.html#dict.popitem)3828  > - [`setdefault()`](https://python-all.ru/3.15/library/stdtypes.html#dict.setdefault)3829  > - [`update()`](https://python-all.ru/3.15/library/stdtypes.html#dict.update)3830- `frozendict` может быть хеширован с помощью `hash(frozendict)`, если все ключи и значения могут быть хешированы.3831- `frozendict |= other` не изменяет `frozendict` на месте, а создаёт новый замороженный словарь.38323833`frozendict` не является подклассом `dict`, а наследует напрямую от `object`.38343835Как и словари, frozendicts являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по двум типам, обозначающим (соответственно) типы ключей и значений frozendict.38363837#### `classmethod fromkeys(iterable, value=None, /)`38383839Аналогично [`dict.fromkeys()`](https://python-all.ru/3.15/library/stdtypes.html#dict.fromkeys), но повторно вызывает конструктор типа с инициализированным `frozendict`, если тип является подклассом `frozendict` или если конструктор вернул `frozendict`.38403841Добавлено в версии 3.15.38423843## Типы контекстных менеджеров38443845Оператор [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with) в Python поддерживает понятие контекста выполнения, определяемого контекстным менеджером. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который входит в действие до выполнения тела оператора и выходит из него по завершении оператора:38463847#### `contextmanager.__enter__()`38483849Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, связывается с идентификатором в предложении `as` оператора [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with), использующего данный контекстный менеджер.38503851Примером контекстного менеджера, который возвращает сам себя, является [файловый объект](https://python-all.ru/3.15/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить использовать [`open()`](https://python-all.ru/3.15/library/functions.html#open) в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with).38523853Примером контекстного менеджера, возвращающего связанный объект, является менеджер, возвращаемый [`decimal.localcontext()`](https://python-all.ru/3.15/library/decimal.html#decimal.localcontext). Такие менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста и затем возвращают эту копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with), не затрагивая код за пределами оператора `with`.38543855#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`38563857Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если исключение возникло при выполнении тела оператора [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with), аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.38583859Возврат истинного значения из этого метода приведёт к тому, что оператор [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with) подавит исключение и продолжит выполнение с оператора, следующего сразу за оператором `with`. В противном случае исключение продолжит распространяться после завершения выполнения этого метода.38603861Если этот метод вызывает исключение при обработке предыдущего исключения из блока [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with), то возбуждается новое исключение, а исходное исключение сохраняется в его атрибуте [`__context__`](https://python-all.ru/3.15/library/exceptions.html#BaseException.__context__).38623863Переданное исключение никогда не должно явно возбуждаться повторно – вместо этого метод должен вернуть ложное значение, чтобы указать, что метод завершился успешно и не хочет подавлять возникшее исключение. Это позволяет коду управления контекстом легко определить, произошёл ли на самом деле сбой метода [`__exit__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__exit__).38643865Python определяет несколько контекстных менеджеров для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов, а также более простого управления активным контекстом десятичной арифметики. Конкретные типы не рассматриваются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.15/library/contextlib.html#module-contextlib) для примеров.38663867[Генераторы](https://python-all.ru/3.15/glossary.html#term-generator) Python и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если генераторная функция декорирована декоратором `contextlib.contextmanager`, она вернёт контекстный менеджер, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.15/library/stdtypes.html#contextmanager.__enter__) и [`__exit__()`](https://python-all.ru/3.15/library/stdtypes.html#contextmanager.__exit__), вместо итератора, который производит недекорированная генераторная функция.38683869Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.38703871## Типы аннотаций типов – [Generic Alias](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias), [Union](https://python-all.ru/3.15/library/stdtypes.html#types-union)38723873Основными встроенными типами для [аннотаций типов](https://python-all.ru/3.15/glossary.html#term-annotation) являются [Generic Alias](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias) и [Union](https://python-all.ru/3.15/library/stdtypes.html#types-union).38743875### Тип Generic Alias38763877Объекты `GenericAlias` обычно создаются путём [индексации (subscripting)](https://python-all.ru/3.15/reference/expressions.html#subscriptions) класса. Чаще всего они используются с [классами-контейнерами](https://python-all.ru/3.15/reference/datamodel.html#sequence-types), такими как [`list`](https://python-all.ru/3.15/library/stdtypes.html#list) или [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict). Например, `list[int]` – это объект `GenericAlias`, созданный индексацией класса `list` с аргументом [`int`](https://python-all.ru/3.15/library/functions.html#int). Объекты `GenericAlias` предназначены в первую очередь для использования с [аннотациями типов](https://python-all.ru/3.15/glossary.html#term-annotation).38783879> **Примечание**3880>3881> Обычно индексировать (subscript) класс можно только в том случае, если класс реализует специальный метод [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__).38823883Объект `GenericAlias` действует как прокси для [обобщённого типа](https://python-all.ru/3.15/glossary.html#term-generic-type), реализуя *параметризованные обобщённые типы (parameterized generics)*.38843885Для класса-контейнера аргумент(ы), передаваемые при [индексации (subscription)](https://python-all.ru/3.15/reference/expressions.html#subscriptions) класса, могут указывать тип(ы) элементов, которые содержит объект. Например, `set[bytes]` можно использовать в аннотациях типов для обозначения [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), в котором все элементы имеют тип [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes).38863887Для класса, который определяет [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__), но не является контейнером, аргумент(ы), передаваемые при индексации класса, часто указывают тип(ы) возвращаемого значения одного или нескольких методов, определённых для объекта. Например, [`regular expressions`](https://python-all.ru/3.15/library/re.html#module-re) можно использовать как для типа данных [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), так и для типа данных [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes):38883889- Если `x = re.search('foo', 'foo')`, то `x` будет объектом [re.Match](https://python-all.ru/3.15/library/re.html#match-objects), в котором возвращаемые значения `x.group(0)` и `x[0]` будут иметь тип [`str`](https://python-all.ru/3.15/library/stdtypes.html#str). Такой объект можно представить в аннотациях типов с помощью `GenericAlias` `re.Match[str]`.3890- Если `y = re.search(b'bar', b'bar')` (обратите внимание на `b` для [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes)), `y` также будет экземпляром `re.Match`, но возвращаемые значения `y.group(0)` и `y[0]` будут оба иметь тип `bytes`. В аннотациях типов эта разновидность объектов [re.Match](https://python-all.ru/3.15/library/re.html#match-objects) обозначается с помощью `re.Match[bytes]`.38913892Объекты `GenericAlias` являются экземплярами класса [`types.GenericAlias`](https://python-all.ru/3.15/library/types.html#types.GenericAlias), который также можно использовать для непосредственного создания объектов `GenericAlias`. Специализации определённых пользователем [обобщённых классов](https://python-all.ru/3.15/reference/compound_stmts.html#generic-classes) могут не быть экземплярами `types.GenericAlias`, но они предоставляют аналогичную функциональность.38933894#### `T[X, Y, ...]`38953896Создаёт `GenericAlias`, представляющий тип `T`, параметризованный типами *X*, *Y* и другими в зависимости от используемого `T`. Например, функция, ожидающая [`list`](https://python-all.ru/3.15/library/stdtypes.html#list), содержащий элементы [`float`](https://python-all.ru/3.15/library/functions.html#float):38973898```python3899def average(values: list[float]) -> float:3900    return sum(values) / len(values)3901```39023903Ещё один пример для [отображений](https://python-all.ru/3.15/glossary.html#term-mapping) с использованием [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict), который является обобщённым типом, принимающим два параметра типа, представляющих тип ключа и тип значения. В этом примере функция ожидает `dict` с ключами типа [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) и значениями типа [`int`](https://python-all.ru/3.15/library/functions.html#int):39043905```python3906def send_post_request(url: str, body: dict[str, int]) -> None:3907    ...3908```39093910Встроенные функции [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) не принимают типы `GenericAlias` для второго аргумента:39113912```python3913>>> isinstance([1, 2], list[str])3914Traceback (most recent call last):3915  File "<stdin>", line 1, in <module>3916TypeError: isinstance() argument 2 cannot be a parameterized generic3917```39183919Среда выполнения Python не принуждает к соблюдению [аннотаций типов](https://python-all.ru/3.15/glossary.html#term-annotation). Это распространяется на обобщённые типы и их параметры типа. При создании объекта-контейнера из `GenericAlias` элементы контейнера не проверяются на соответствие их типу. Например, следующий код не рекомендуется, но будет выполнен без ошибок:39203921```python3922>>> t = list[str]3923>>> t([1, 2, 3])3924[1, 2, 3]3925```39263927Кроме того, параметризованные обобщённые типы стирают параметры типа при создании объекта:39283929```python3930>>> t = list[str]3931>>> type(t)3932<class 'types.GenericAlias'>39333934>>> l = t()3935>>> type(l)3936<class 'list'>3937```39383939Экземпляры `GenericAlias` не являются классами во время выполнения, хотя они ведут себя как классы (их можно инстанцировать и наследовать от них):39403941```python3942>>> import inspect3943>>> inspect.isclass(list[int])3944False3945```39463947Это верно и для [определённых пользователем обобщённых типов](https://python-all.ru/3.15/library/typing.html#user-defined-generics).39483949Вызов [`repr()`](https://python-all.ru/3.15/library/functions.html#repr) или [`str()`](https://python-all.ru/3.15/library/stdtypes.html#str) для обобщённого типа показывает параметризованный тип:39503951```python3952>>> repr(list[int])3953'list[int]'39543955>>> str(list[int])3956'list[int]'3957```39583959Метод [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) обобщённых контейнеров возбудит исключение, чтобы предотвратить ошибки вроде `dict[str][str]`:39603961```python3962>>> dict[str][str]3963Traceback (most recent call last):3964  ...3965TypeError: dict[str] is not a generic class3966```39673968Однако такие выражения допустимы, когда используются [переменные типа](https://python-all.ru/3.15/library/typing.html#generics). Индекс должен содержать столько же элементов, сколько элементов переменных типа в [`__args__`](https://python-all.ru/3.15/library/stdtypes.html#genericalias.__args__) объекта `GenericAlias`.39693970```python3971>>> from typing import TypeVar3972>>> Y = TypeVar('Y')3973>>> dict[str, Y][int]3974dict[str, int]3975```39763977#### Стандартные обобщённые классы39783979Следующие классы стандартной библиотеки поддерживают параметризованные обобщённые типы. Этот список не является исчерпывающим.39803981- [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple)3982- [`list`](https://python-all.ru/3.15/library/stdtypes.html#list)3983- [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict)3984- [`set`](https://python-all.ru/3.15/library/stdtypes.html#set)3985- [`frozendict`](https://python-all.ru/3.15/library/stdtypes.html#frozendict)3986- [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset)3987- [`type`](https://python-all.ru/3.15/library/functions.html#type)3988- [`asyncio.Future`](https://python-all.ru/3.15/library/asyncio-future.html#asyncio.Future)3989- [`asyncio.Task`](https://python-all.ru/3.15/library/asyncio-task.html#asyncio.Task)3990- [`collections.deque`](https://python-all.ru/3.15/library/collections.html#collections.deque)3991- [`collections.defaultdict`](https://python-all.ru/3.15/library/collections.html#collections.defaultdict)3992- [`collections.OrderedDict`](https://python-all.ru/3.15/library/collections.html#collections.OrderedDict)3993- [`collections.Counter`](https://python-all.ru/3.15/library/collections.html#collections.Counter)3994- [`collections.ChainMap`](https://python-all.ru/3.15/library/collections.html#collections.ChainMap)3995- [`collections.abc.Awaitable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Awaitable)3996- [`collections.abc.Coroutine`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Coroutine)3997- [`collections.abc.AsyncIterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterable)3998- [`collections.abc.AsyncIterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncIterator)3999- [`collections.abc.AsyncGenerator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.AsyncGenerator)4000- [`collections.abc.Iterable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterable)4001- [`collections.abc.Iterator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Iterator)4002- [`collections.abc.Generator`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Generator)4003- [`collections.abc.Reversible`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Reversible)4004- [`collections.abc.Container`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Container)4005- [`collections.abc.Collection`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Collection)4006- [`collections.abc.Callable`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Callable)4007- [`collections.abc.Set`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Set)4008- [`collections.abc.MutableSet`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSet)4009- [`collections.abc.Mapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Mapping)4010- [`collections.abc.MutableMapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableMapping)4011- [`collections.abc.Sequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Sequence)4012- [`collections.abc.MutableSequence`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableSequence)4013- [`collections.abc.ByteString`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ByteString)4014- [`collections.abc.MappingView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MappingView)4015- [`collections.abc.KeysView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.KeysView)4016- [`collections.abc.ItemsView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ItemsView)4017- [`collections.abc.ValuesView`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.ValuesView)4018- [`contextlib.AbstractContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractContextManager)4019- [`contextlib.AbstractAsyncContextManager`](https://python-all.ru/3.15/library/contextlib.html#contextlib.AbstractAsyncContextManager)4020- [`dataclasses.Field`](https://python-all.ru/3.15/library/dataclasses.html#dataclasses.Field)4021- [`functools.cached_property`](https://python-all.ru/3.15/library/functools.html#functools.cached_property)4022- [`functools.partialmethod`](https://python-all.ru/3.15/library/functools.html#functools.partialmethod)4023- [`os.PathLike`](https://python-all.ru/3.15/library/os.html#os.PathLike)4024- [`queue.LifoQueue`](https://python-all.ru/3.15/library/queue.html#queue.LifoQueue)4025- [`queue.Queue`](https://python-all.ru/3.15/library/queue.html#queue.Queue)4026- [`queue.PriorityQueue`](https://python-all.ru/3.15/library/queue.html#queue.PriorityQueue)4027- [`queue.SimpleQueue`](https://python-all.ru/3.15/library/queue.html#queue.SimpleQueue)4028- [re.Pattern](https://python-all.ru/3.15/library/re.html#re-objects)4029- [re.Match](https://python-all.ru/3.15/library/re.html#match-objects)4030- [`shelve.BsdDbShelf`](https://python-all.ru/3.15/library/shelve.html#shelve.BsdDbShelf)4031- [`shelve.DbfilenameShelf`](https://python-all.ru/3.15/library/shelve.html#shelve.DbfilenameShelf)4032- [`shelve.Shelf`](https://python-all.ru/3.15/library/shelve.html#shelve.Shelf)4033- [`types.MappingProxyType`](https://python-all.ru/3.15/library/types.html#types.MappingProxyType)4034- [`weakref.WeakKeyDictionary`](https://python-all.ru/3.15/library/weakref.html#weakref.WeakKeyDictionary)4035- [`weakref.WeakMethod`](https://python-all.ru/3.15/library/weakref.html#weakref.WeakMethod)4036- [`weakref.WeakSet`](https://python-all.ru/3.15/library/weakref.html#weakref.WeakSet)4037- [`weakref.WeakValueDictionary`](https://python-all.ru/3.15/library/weakref.html#weakref.WeakValueDictionary)40384039#### Специальные атрибуты объектов `GenericAlias`40404041Все параметризованные обобщённые типы реализуют специальные атрибуты только для чтения.40424043#### `genericalias.__origin__`40444045Этот атрибут указывает на непараметризованный обобщённый класс:40464047```python4048>>> list[int].__origin__4049<class 'list'>4050```40514052#### `genericalias.__args__`40534054Этот атрибут представляет собой [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) (возможно, длины 1) обобщённых типов, переданных исходному [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__) обобщённого класса:40554056```python4057>>> dict[str, list[int]].__args__4058(<class 'str'>, list[int])4059```40604061#### `genericalias.__parameters__`40624063Этот атрибут представляет собой лениво вычисляемый кортеж (возможно, пустой) уникальных переменных типа, найденных в `__args__`:40644065```python4066>>> from typing import TypeVar40674068>>> T = TypeVar('T')4069>>> list[T].__parameters__4070(~T,)4071```40724073> **Примечание**4074>4075> Объект `GenericAlias` с параметрами [`typing.ParamSpec`](https://python-all.ru/3.15/library/typing.html#typing.ParamSpec) может не иметь корректного `__parameters__` после подстановки, поскольку `typing.ParamSpec` предназначен в первую очередь для статической проверки типов.40764077#### `genericalias.__unpacked__`40784079Логическое значение, которое истинно, если псевдоним был распакован с помощью оператора `*` (см. [`TypeVarTuple`](https://python-all.ru/3.15/library/typing.html#typing.TypeVarTuple)).40804081Добавлено в версии 3.12.40824083> **См. также**4084>4085> **[**PEP 484**](https://python-all.ru/3.15/library/stdtypes.html) – Аннотации типов**4086>4087> Представление инфраструктуры Python для аннотаций типов.4088>4089> **[**PEP 585**](https://python-all.ru/3.15/library/stdtypes.html) – Аннотации обобщённых типов в стандартных коллекциях**4090>4091> Представление возможности нативно параметризовать классы стандартной библиотеки при условии, что они реализуют специальный метод класса [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__).4092>4093> **[Дженерики](https://python-all.ru/3.15/library/typing.html#generics), [пользовательские дженерики](https://python-all.ru/3.15/library/typing.html#user-defined-generics) и [`typing.Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic)**4094>4095> Документация по реализации обобщённых классов, которые можно параметризовать во время выполнения и которые понятны статическим анализаторам типов.40964097Добавлено в версии 3.9.40984099### Тип объединения41004101Объект объединения хранит значение операции `|` (побитовое ИЛИ) над несколькими [объектами типов](https://python-all.ru/3.15/library/stdtypes.html#bltin-type-objects). Эти типы предназначены в первую очередь для [аннотаций типов](https://python-all.ru/3.15/glossary.html#term-annotation). Выражение типа объединения обеспечивает более чистый синтаксис подсказок типов по сравнению с индексированием [`typing.Union`](https://python-all.ru/3.15/library/typing.html#typing.Union).41024103#### `X | Y | ...`41044105Определяет объект объединения, который содержит типы *X*, *Y* и так далее. `X | Y` означает либо X, либо Y. Это эквивалентно `typing.Union[X, Y]`. Например, следующая функция ожидает аргумент типа [`int`](https://python-all.ru/3.15/library/functions.html#int) или [`float`](https://python-all.ru/3.15/library/functions.html#float):41064107```python4108def square(number: int | float) -> int | float:4109    return number ** 24110```41114112> **Примечание**4113>4114> Оператор `|` не может использоваться во время выполнения для определения объединений, в которых один или несколько членов являются прямой ссылкой. Например, `int | "Foo"`, где `"Foo"` является ссылкой на ещё не определённый класс, вызовет ошибку во время выполнения. Для объединений, содержащих прямые ссылки, всё выражение следует задавать в виде строки, например `"int | Foo"`.41154116#### `union_object == other`41174118Объекты объединения можно проверять на равенство с другими объектами объединения. Подробнее:41194120- Объединения объединений уплощаются:41214122  ```python4123  (int | str) | float == int | str | float4124  ```4125- Избыточные типы удаляются:41264127  ```python4128  int | str | int == int | str4129  ```4130- При сравнении объединений порядок не учитывается:41314132  ```python4133  int | str == str | int4134  ```4135- Создаёт экземпляры [`typing.Union`](https://python-all.ru/3.15/library/typing.html#typing.Union):41364137  ```python4138  int | str == typing.Union[int, str]4139  type(int | str) is typing.Union4140  ```4141- Опциональные типы можно записать как объединение с `None`:41424143  ```python4144  str | None == typing.Optional[str]4145  ```41464147#### `isinstance(obj, union_object)`41484149#### `issubclass(obj, union_object)`41504151Вызовы [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) также поддерживаются с объектом объединения:41524153```python4154>>> isinstance("", int | str)4155True4156```41574158Однако [параметризованные дженерики](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias) в объектах объединения проверить нельзя:41594160```python4161>>> isinstance(1, int | list[int])  # вычисление по короткой схеме4162True4163>>> isinstance([1], int | list[int])4164Traceback (most recent call last):4165  ...4166TypeError: isinstance() argument 2 cannot be a parameterized generic4167```41684169Тип объекта объединения, доступный пользователю, можно получить через [`typing.Union`](https://python-all.ru/3.15/library/typing.html#typing.Union) и использовать для проверок [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance):41704171```python4172>>> import typing4173>>> isinstance(int | str, typing.Union)4174True4175>>> typing.Union()4176Traceback (most recent call last):4177  File "<stdin>", line 1, in <module>4178TypeError: cannot create 'typing.Union' instances4179```41804181> **Примечание**4182>4183> Метод `__or__()` для объектов типов был добавлен для поддержки синтаксиса `X | Y`. Если метакласс реализует `__or__()`, Union может переопределить его:4184>4185> ```pycon4186> >>> class M(type):4187> ...     def __or__(self, other):4188> ...         return "Hello"4189> ...4190> >>> class C(metaclass=M):4191> ...     pass4192> ...4193> >>> C | int4194> 'Hello'4195> >>> int | C4196> int | C4197> ```41984199> **См. также**4200>4201> [**PEP 604**](https://python-all.ru/3.15/library/stdtypes.html) – PEP proposing the `X | Y` syntax and the Union type.42024203Добавлено в версии 3.10.42044205Изменено в версии 3.14: Объекты объединения теперь являются экземплярами [`typing.Union`](https://python-all.ru/3.15/library/typing.html#typing.Union). Ранее они были экземплярами [`types.UnionType`](https://python-all.ru/3.15/library/types.html#types.UnionType), который остаётся псевдонимом для `typing.Union`.42064207## Другие встроенные типы42084209Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.42104211### Модули42124213Единственная специальная операция над модулем – это доступ к атрибутам: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов модуля *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.15/reference/simple_stmts.html#import) строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, а требует (внешнего) *определения* для модуля с именем *foo* где-то.)42144215Специальным атрибутом каждого модуля является [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__). Это словарь, содержащий таблицу символов модуля. Изменение этого словаря действительно изменит таблицу символов модуля, но прямое присваивание атрибуту `__dict__` невозможно (можно написать `m.__dict__['a'] = 1`, что определит `m.a` как `1`, но нельзя написать `m.__dict__ = {}`). Изменять `__dict__` напрямую не рекомендуется.42164217Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.42184219### Классы и экземпляры классов42204221См. [Объекты, значения и типы](https://python-all.ru/3.15/reference/datamodel.html#objects) и [Определения классов](https://python-all.ru/3.15/reference/compound_stmts.html#class).42224223### Функции42244225Объекты-функции создаются определениями функций. Единственная операция над объектом-функцией – это вызов: `func(argument-list)`.42264227На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.42284229Дополнительную информацию см. в разделе [Определения функций](https://python-all.ru/3.15/reference/compound_stmts.html#function).42304231### Методы42324233Методы – это функции, которые вызываются с использованием точечной нотации. Существует две разновидности: [встроенные методы](https://python-all.ru/3.15/reference/datamodel.html#builtin-methods) (такие как [`append()`](https://python-all.ru/3.15/library/stdtypes.html#list.append) у списков) и [методы экземпляров классов](https://python-all.ru/3.15/reference/datamodel.html#instance-methods). Встроенные методы описываются вместе с типами, которые их поддерживают.42344235Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, возвращается специальный объект: *связанный метод* (также называемый [метод экземпляра](https://python-all.ru/3.15/reference/datamodel.html#instance-methods)). При вызове он добавляет аргумент `self` в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: [`m.__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__) – объект, над которым выполняется метод, а [`m.__func__`](https://python-all.ru/3.15/reference/datamodel.html#method.__func__) – функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.42364237Как и [объекты функций](https://python-all.ru/3.15/reference/datamodel.html#user-defined-funcs), объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции ([`method.__func__`](https://python-all.ru/3.15/reference/datamodel.html#method.__func__)), установка атрибутов метода на связанных методах запрещена. Попытка установить атрибут на методе приводит к возникновению исключения [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError). Чтобы установить атрибут метода, необходимо явно установить его на базовом объекте функции:42384239```pycon4240>>> class C:4241...     def method(self):4242...         pass4243...4244>>> c = C()4245>>> c.method.whoami = 'my name is method'  # нельзя установить на методе4246Traceback (most recent call last):4247  File "<stdin>", line 1, in <module>4248AttributeError: 'method' object has no attribute 'whoami'4249>>> c.method.__func__.whoami = 'my name is method'4250>>> c.method.whoami4251'my name is method'4252```42534254Дополнительную информацию см. в разделе [Методы экземпляров](https://python-all.ru/3.15/reference/datamodel.html#instance-methods).42554256### Объекты кода42574258Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, например тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.15/library/functions.html#compile) и могут быть извлечены из объектов функций через их атрибут [`__code__`](https://python-all.ru/3.15/reference/datamodel.html#function.__code__). Также см. модуль [`code`](https://python-all.ru/3.15/library/code.html#module-code).42594260Доступ к [`__code__`](https://python-all.ru/3.15/reference/datamodel.html#function.__code__) вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__getattr__` с аргументами `obj` и `"__code__"`.42614262Объект кода можно выполнить или вычислить, передав его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.15/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.15/library/functions.html#eval).42634264Дополнительную информацию см. в разделе [Стандартная иерархия типов](https://python-all.ru/3.15/reference/datamodel.html#types).42654266### Объекты типов42674268Объекты типов представляют различные типы объектов. Тип объекта можно получить с помощью встроенной функции [`type()`](https://python-all.ru/3.15/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.15/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.42694270Типы записываются так: `<class 'int'>`.42714272### Объект Null42734274Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один нулевой объект с именем `None` (встроенное имя). `type(None)()` возвращает тот же синглтон.42754276Он записывается как `None`.42774278### Объект многоточия42794280Этот объект обычно используется для обозначения того, что что-то пропущено. Он не поддерживает никаких специальных операций. Существует ровно один объект многоточия с именем [`Ellipsis`](https://python-all.ru/3.15/library/constants.html#Ellipsis) (встроенное имя). `type(Ellipsis)()` возвращает синглтон `Ellipsis`.42814282Он записывается как `Ellipsis` или `...`.42834284При обычном использовании `...` в качестве объекта `Ellipsis` встречается в нескольких разных местах, например:42854286- В аннотациях типов, например [вызываемые аргументы](https://python-all.ru/3.15/library/typing.html#annotating-callables) или [элементы кортежей](https://python-all.ru/3.15/library/typing.html#annotating-tuples).4287- В качестве тела функции вместо [инструкции pass](https://python-all.ru/3.15/tutorial/controlflow.html#tut-pass).4288- В сторонних библиотеках, например [срезы и шаги в Numpy](https://python-all.ru/3.15/library/stdtypes.html).42894290Python также использует три точки в случаях, которые не являются объектами `Ellipsis`, например:42914292- В Doctest [`ELLIPSIS`](https://python-all.ru/3.15/library/doctest.html#doctest.ELLIPSIS) используется как шаблон для отсутствующего содержимого.4293- Стандартное приглашение Python в [интерактивной](https://python-all.ru/3.15/glossary.html#term-interactive) оболочке, когда ввод неполный.42944295Наконец, документация Python часто использует три точки в обычном английском значении для обозначения пропущенного содержимого, даже в примерах кода, где они также используются как `Ellipsis`.42964297### Объект NotImplemented42984299Этот объект возвращается из сравнений и бинарных операций, когда они должны работать с типами, которые не поддерживают. Дополнительную информацию см. в разделе [Сравнения](https://python-all.ru/3.15/reference/expressions.html#comparisons). Существует ровно один объект [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented). `type(NotImplemented)()` возвращает экземпляр-синглтон.43004301Он записывается как `NotImplemented`.43024303### Внутренние объекты43044305Эту информацию см. в разделе [Стандартная иерархия типов](https://python-all.ru/3.15/reference/datamodel.html#types). Там описываются [объекты стековых фреймов](https://python-all.ru/3.15/reference/datamodel.html#frame-objects), [объекты трассировки](https://python-all.ru/3.15/reference/datamodel.html#traceback-objects) и объекты срезов.43064307## Специальные атрибуты43084309Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где это уместно. Некоторые из них не сообщаются встроенной функцией [`dir()`](https://python-all.ru/3.15/library/functions.html#dir).43104311#### `definition.__name__`43124313Имя класса, функции, метода, дескриптора или экземпляра генератора.43144315#### `definition.__qualname__`43164317[Полное имя](https://python-all.ru/3.15/glossary.html#term-qualified-name) класса, функции, метода, дескриптора, или экземпляра генератора.43184319Добавлено в версии 3.3.43204321#### `definition.__module__`43224323Имя модуля, в котором был определён класс или функция.43244325#### `definition.__doc__`43264327Строка документации класса или функции, или `None`, если не определена.43284329#### `definition.__type_params__`43304331[Параметры типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) обобщённых классов, функций и [псевдонимов типов](https://python-all.ru/3.15/library/typing.html#type-aliases). Для классов и функций, которые не являются обобщёнными, это будет пустой кортеж.43324333Добавлено в версии 3.12.43344335## Ограничение длины преобразования целого числа в строку43364337В CPython существует глобальное ограничение на преобразование между [`int`](https://python-all.ru/3.15/library/functions.html#int) и [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) для смягчения атак типа «отказ в обслуживании». Это ограничение *только* применяется к десятичной или другим системам счисления, не являющимся степенями двойки. Преобразования в шестнадцатеричную, восьмеричную и двоичную системы не ограничены. Ограничение можно настроить.43384339Тип [`int`](https://python-all.ru/3.15/library/functions.html#int) в CPython – это число произвольной длины, хранящееся в двоичной форме (обычно называемое «bignum»). Не существует алгоритма, который мог бы преобразовать строку в двоичное целое или двоичное целое в строку за линейное время, *кроме* случая, когда основание является степенью двойки. Даже лучшие известные алгоритмы для основания 10 имеют субквадратичную сложность. Преобразование большого значения, такого как `int('1' * 500_000)`, может занять более секунды на быстром CPU.43404341Ограничение размера преобразования предлагает практический способ избежать [**CVE 2020-10735**](https://python-all.ru/3.15/library/stdtypes.html).43424343Ограничение применяется к количеству цифровых символов во входной или выходной строке, когда задействован нелинейный алгоритм преобразования. Символы подчёркивания и знак не учитываются в ограничении.43444345Когда операция превышает ограничение, вызывается [`ValueError`](https://python-all.ru/3.15/library/exceptions.html#ValueError):43464347```pycon4348>>> import sys4349>>> sys.set_int_max_str_digits(4300)  # Для иллюстрации, это значение по умолчанию.4350>>> _ = int('2' * 5432)4351Traceback (most recent call last):4352...4353ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit4354>>> i = int('2' * 4300)4355>>> len(str(i))435643004357>>> i_squared = i*i4358>>> len(str(i_squared))4359Traceback (most recent call last):4360...4361ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit4362>>> len(hex(i_squared))436371444364>>> assert int(hex(i_squared), base=16) == i*i  # Шестнадцатеричный формат не ограничен.4365```43664367Значение ограничения по умолчанию – 4300 цифр, как указано в [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.15/library/sys.html#sys.int_info). Наименьшее настраиваемое ограничение – 640 цифр, как указано в `sys.int_info.str_digits_check_threshold`.43684369Проверка:43704371```pycon4372>>> import sys4373>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info4374>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info4375>>> msg = int('578966293710682886880994035146873798396722250538762761564'4376...           '9252925514383915483333812743580549779436104706260696366600'4377...           '571186405732').to_bytes(53, 'big')4378...4379```43804381Добавлено в версии 3.12.43824383### Затронутые API43844385Ограничение применяется только к потенциально медленным преобразованиям между [`int`](https://python-all.ru/3.15/library/functions.html#int) и [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) или [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes):43864387- `int(string)` с основанием 10 по умолчанию.4388- `int(string, base)` для всех оснований, не являющихся степенью двойки.4389- `str(integer)`.4390- `repr(integer)`.4391- любое другое преобразование строки в основание 10, например `f"{integer}"`, `"{}".format(integer)` или `b"%d" % integer`.43924393Ограничения не применяются к функциям с линейным алгоритмом:43944395- `int(string, base)` с основанием 2, 4, 8, 16 или 32.4396- [`int.from_bytes()`](https://python-all.ru/3.15/library/stdtypes.html#int.from_bytes) и [`int.to_bytes()`](https://python-all.ru/3.15/library/stdtypes.html#int.to_bytes).4397- [`hex()`](https://python-all.ru/3.15/library/functions.html#hex), [`oct()`](https://python-all.ru/3.15/library/functions.html#oct), [`bin()`](https://python-all.ru/3.15/library/functions.html#bin).4398- [Мини-язык спецификации формата](https://python-all.ru/3.15/library/string.html#formatspec) для шестнадцатеричных, восьмеричных и двоичных чисел.4399- [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) в [`float`](https://python-all.ru/3.15/library/functions.html#float).4400- [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) в [`decimal.Decimal`](https://python-all.ru/3.15/library/decimal.html#decimal.Decimal).44014402### Настройка ограничения44034404Перед запуском Python можно использовать переменную окружения или флаг командной строки интерпретатора для настройки ограничения:44054406- [`PYTHONINTMAXSTRDIGITS`](https://python-all.ru/3.15/using/cmdline.html#envvar-PYTHONINTMAXSTRDIGITS), например, `PYTHONINTMAXSTRDIGITS=640 python3`, чтобы установить ограничение 640, или `PYTHONINTMAXSTRDIGITS=0 python3`, чтобы отключить ограничение.4407- [`-X int_max_str_digits`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-X), например, `python3 -X int_max_str_digits=640`4408- [`sys.flags.int_max_str_digits`](https://python-all.ru/3.15/library/sys.html#sys.flags.int_max_str_digits) содержит значение [`PYTHONINTMAXSTRDIGITS`](https://python-all.ru/3.15/using/cmdline.html#envvar-PYTHONINTMAXSTRDIGITS) или [`-X int_max_str_digits`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-X). Если заданы и переменная окружения, и опция `-X`, то опция `-X` имеет приоритет. Значение *-1* указывает, что обе не были установлены, поэтому при инициализации использовалось значение [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.15/library/sys.html#sys.int_info.default_max_str_digits).44094410Из кода можно проверить текущий лимит и установить новый с помощью этих [`sys`](https://python-all.ru/3.15/library/sys.html#module-sys) API:44114412- [`sys.get_int_max_str_digits()`](https://python-all.ru/3.15/library/sys.html#sys.get_int_max_str_digits) и [`sys.set_int_max_str_digits()`](https://python-all.ru/3.15/library/sys.html#sys.set_int_max_str_digits) – это геттер и сеттер для лимита на уровне интерпретатора. Суб-интерпретаторы имеют свой собственный лимит.44134414Информацию о значениях по умолчанию и минимальном можно найти в [`sys.int_info`](https://python-all.ru/3.15/library/sys.html#sys.int_info):44154416- [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.15/library/sys.html#sys.int_info) – это скомпилированный лимит по умолчанию.4417- [`sys.int_info.str_digits_check_threshold`](https://python-all.ru/3.15/library/sys.html#sys.int_info) – это наименьшее допустимое значение лимита (кроме 0, которое отключает его).44184419Добавлено в версии 3.12.44204421> **Внимание**4422>4423> Установка низкого лимита *может* привести к проблемам. Хотя это редко, существует код, содержащий десятичные целочисленные константы в исходниках, которые превышают минимальный порог. Следствие установки лимита: исходный код Python, содержащий десятичные целочисленные литералы длиннее лимита, вызовет ошибку при разборе, обычно во время запуска или импорта, или даже во время установки – в любой момент, когда актуальный `.pyc` ещё не существует для этого кода. Обходной путь для исходников, содержащих такие большие константы, – преобразовать их в `0x` шестнадцатеричную форму, так как у неё нет лимита.4424>4425> Тщательно тестируйте приложение, если используете низкий лимит. Убедитесь, что тесты запускаются с лимитом, установленным заранее через переменную окружения или флаг, чтобы он применялся во время запуска и даже на любом этапе установки, который может вызвать Python для предварительной компиляции `.py` исходников в `.pyc` файлы.44264427### Рекомендуемая конфигурация44284429Ожидается, что значение [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.15/library/sys.html#sys.int_info.default_max_str_digits) по умолчанию будет приемлемым для большинства приложений. Если вашему приложению требуется другой лимит, установите его из главной точки входа с помощью кода, не зависящего от версии Python, поскольку эти API были добавлены в выпусках исправлений безопасности в версиях до 3.12.44304431Пример:44324433```python4434>>> import sys4435>>> if hasattr(sys, "set_int_max_str_digits"):4436...     upper_bound = 680004437...     lower_bound = 40044438...     current_limit = sys.get_int_max_str_digits()4439...     if current_limit == 0 or current_limit > upper_bound:4440...         sys.set_int_max_str_digits(upper_bound)4441...     elif current_limit < lower_bound:4442...         sys.set_int_max_str_digits(lower_bound)4443```44444445Если нужно полностью отключить его, установите значение `0`.44464447Сноски44484449\[[1](https://python-all.ru/3.15/library/stdtypes.html#id1)\]44504451Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([Базовая настройка](https://python-all.ru/3.15/reference/datamodel.html#customization)).44524453\[[2](https://python-all.ru/3.15/library/stdtypes.html#id2)\]44544455Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей.44564457\[[3](https://python-all.ru/3.15/library/stdtypes.html#id4)\]44584459Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов.44604461\[4\]44624463([1](https://python-all.ru/3.15/library/stdtypes.html#id6),[2](https://python-all.ru/3.15/library/stdtypes.html#id7),[3](https://python-all.ru/3.15/library/stdtypes.html#id8),[4](https://python-all.ru/3.15/library/stdtypes.html#id9))44644465Символы с учётом регистра – это те, у которых свойство общей категории является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, заглавная).44664467\[5\]44684469([1](https://python-all.ru/3.15/library/stdtypes.html#id10),[2](https://python-all.ru/3.15/library/stdtypes.html#id11))44704471Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж.4472