stdtypes.md
1> **Источник:** https://python-all.ru/3.8/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.8/library/functions.html#repr) или немного отличающейся функции [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.8/library/functions.html#print).1617## Проверка на истинность1819Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.8/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.8/reference/compound_stmts.html#while) или в качестве операнда булевых операций, описанных ниже.2021По умолчанию объект считается истинным, если только его класс не определяет метод [`__bool__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__bool__), возвращающий `False`, или метод [`__len__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__len__), возвращающий ноль при вызове с объектом. [1](https://python-all.ru/3.8/library/stdtypes.html#id12) Ниже приведены большинство встроенных объектов, считающихся ложными:2223>2425- константы, определённые как ложные: `None` и `False`.26- ноль любого числового типа: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`27- пустые последовательности и коллекции: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`2829Операции и встроенные функции, возвращающие булев результат, всегда возвращают `0` или `False` для ложного и `1` или `True` для истинного, если не указано иное. (Важное исключение: булевы операции `or` и `and` всегда возвращают один из своих операндов.)3031## Булевы операции – `and`, `or`, `not`3233Это булевы операции в порядке возрастания приоритета:3435| Операция | Результат | Примечания |36| --- | --- | --- |37| `x or y` | если *x* ложно, то *y*, иначе *x* | (1) |38| `x and y` | если *x* ложно, то *x*, иначе *y* | (2) |39| `not x` | если *x* ложно, то `True`, иначе `False` | (3) |4041Примечания:42431. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый ложен.442. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый истинен.453. `not` имеет более низкий приоритет, чем небулевы операторы, поэтому `not a == b` интерпретируется как `not (a == b)`, а `a == not b` является синтаксической ошибкой.4647## Сравнения4849В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (выше, чем у булевых операций). Сравнения можно произвольно объединять в цепочки; например, `x < y <= z` эквивалентно `x < y and y <= z`, за исключением того, что *y* вычисляется только один раз (но в обоих случаях *z* вообще не вычисляется, если `x < y` оказывается ложным).5051В этой таблице приведены операции сравнения:5253| Операция | Значение |54| --- | --- |55| `<` | строго меньше |56| `<=` | меньше или равно |57| `>` | строго больше |58| `>=` | больше или равно |59| `==` | равно |60| `!=` | не равно |61| `is` | идентичность объектов |62| `is not` | отрицание идентичности объектов |6364Объекты разных типов, кроме разных числовых типов, никогда не считаются равными. Оператор `==` всегда определён, но для некоторых типов объектов (например, объектов-классов) он эквивалентен [`is`](https://python-all.ru/3.8/reference/expressions.html#is). Операторы `<`, `<=`, `>` и `>=` определены только там, где они имеют смысл; например, они вызывают исключение [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError), если один из аргументов – комплексное число.6566Разные экземпляры класса обычно сравниваются как неравные, если только класс не определяет метод [`__eq__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__eq__).6768Экземпляры класса не могут быть упорядочены относительно других экземпляров того же класса или объектов других типов, если класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__ge__) (в общем случае [`__lt__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__lt__) и [`__eq__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__eq__) достаточно, если нужны обычные значения операторов сравнения).6970Поведение операторов [`is`](https://python-all.ru/3.8/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.8/reference/expressions.html#is-not) не может быть настроено; кроме того, они применимы к любым двум объектам и никогда не вызывают исключение.7172Ещё две операции с тем же синтаксическим приоритетом, [`in`](https://python-all.ru/3.8/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.8/reference/expressions.html#not-in), поддерживаются типами, которые являются [итерируемыми](https://python-all.ru/3.8/glossary.html#term-iterable) или реализуют метод [`__contains__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__contains__).7374## Числовые типы – [`int`](https://python-all.ru/3.8/library/functions.html#int), [`float`](https://python-all.ru/3.8/library/functions.html#float), [`complex`](https://python-all.ru/3.8/library/functions.html#complex)7576Существует три различных числовых типа: *целые числа*, *числа с плавающей точкой* и *комплексные числа*. Кроме того, булевы значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью `double` в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.8/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы [`fractions.Fraction`](https://python-all.ru/3.8/library/fractions.html#fractions.Fraction) для рациональных чисел и [`decimal.Decimal`](https://python-all.ru/3.8/library/decimal.html#decimal.Decimal) для чисел с плавающей точкой с задаваемой пользователем точностью.)7778Числа создаются с помощью числовых литералов или в результате работы встроенных функций и операторов. Целочисленные литералы без каких-либо суффиксов (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей запятой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно добавить к целому числу или числу с плавающей запятой, чтобы получить комплексное число с действительной и мнимой частями.7980Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до другого типа, при этом целое число уже числа с плавающей запятой, которое, в свою очередь, уже комплексного числа. Сравнение чисел разных типов ведет себя так, как если бы сравнивались точные значения этих чисел. [2](https://python-all.ru/3.8/library/stdtypes.html#id13)8182Конструкторы [`int()`](https://python-all.ru/3.8/library/functions.html#int), [`float()`](https://python-all.ru/3.8/library/functions.html#float) и [`complex()`](https://python-all.ru/3.8/library/functions.html#complex) можно использовать для создания чисел определённого типа.8384Все числовые типы (кроме комплексных) поддерживают следующие операции (о приоритетах операций см. [Приоритет операций](https://python-all.ru/3.8/reference/expressions.html#operator-summary)):8586| Операция | Результат | Примечания | Полная документация |87| --- | --- | --- | --- |88| `x + y` | сумма *x* и *y* | | |89| `x - y` | разность *x* и *y* | | |90| `x * y` | произведение *x* и *y* | | |91| `x / y` | частное *x* и *y* | | |92| `x // y` | неполное частное *x* и *y* | (1) | |93| `x % y` | остаток от `x / y` | (2) | |94| `-x` | *x* с обратным знаком | | |95| `+x` | *x* без изменений | | |96| `abs(x)` | абсолютное значение или модуль *x* | | [`abs()`](https://python-all.ru/3.8/library/functions.html#abs) |97| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.8/library/functions.html#int) |98| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.8/library/functions.html#float) |99| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.8/library/functions.html#complex) |100| `c.conjugate()` | сопряжённое комплексного числа *c* | | |101| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.8/library/functions.html#divmod) |102| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.8/library/functions.html#pow) |103| `x ** y` | *x* в степени *y* | (5) | |104105Примечания:1061071. Также называется целочисленным делением. Результирующее значение является целым числом, хотя тип результата не обязательно int. Результат всегда округляется в сторону минус бесконечности: `1//2` равно `0`, `(-1)//2` равно `-1`, `1//(-2)` равно `-1`, а `(-1)//(-2)` равно `0`.1082. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей запятой с помощью [`abs()`](https://python-all.ru/3.8/library/functions.html#abs), если это уместно.1093. Преобразование числа с плавающей запятой в целое может округлять или усекать, как в C; для хорошо определённых преобразований см. функции [`math.floor()`](https://python-all.ru/3.8/library/math.html#math.floor) и [`math.ceil()`](https://python-all.ru/3.8/library/math.html#math.ceil).1104. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.1115. Python определяет `pow(0, 0)` и `0 ** 0` как `1`, что общепринято для языков программирования.1126. Принимаемые числовые литералы включают цифры от `0` до `9` или любой эквивалент в Unicode (кодовые точки со свойством `Nd`).113114 См. [http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt](https://python-all.ru/3.8/library/stdtypes.html) для полного списка кодовых точек со свойством `Nd`.115116Все типы [`numbers.Real`](https://python-all.ru/3.8/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.8/library/functions.html#int) и [`float`](https://python-all.ru/3.8/library/functions.html#float)) также включают следующие операции:117118| Операция | Результат |119| --- | --- |120| [`math.trunc(x)`](https://python-all.ru/3.8/library/math.html#math.trunc) | *x*, усечённое до [`Integral`](https://python-all.ru/3.8/library/numbers.html#numbers.Integral) |121| [`round(x[, n])`](https://python-all.ru/3.8/library/functions.html#round) | *x*, округлённое до *n* знаков, с округлением до ближайшего чётного. Если *n* опущено, по умолчанию равно 0. |122| [`math.floor(x)`](https://python-all.ru/3.8/library/math.html#math.floor) | наибольшее [`Integral`](https://python-all.ru/3.8/library/numbers.html#numbers.Integral) \<= *x* |123| [`math.ceil(x)`](https://python-all.ru/3.8/library/math.html#math.ceil) | наименьшее [`Integral`](https://python-all.ru/3.8/library/numbers.html#numbers.Integral) \>= *x* |124125За дополнительными числовыми операциями обращайтесь к модулям [`math`](https://python-all.ru/3.8/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.8/library/cmath.html#module-cmath).126127### Побитовые операции над целыми типами128129Побитовые операции имеют смысл только для целых чисел. Результат побитовых операций вычисляется так, как если бы они выполнялись в дополнительном коде с бесконечным количеством знаковых битов.130131Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция `~` имеет тот же приоритет, что и другие унарные числовые операции (`+` и `-`).132133В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета:134135| Операция | Результат | Примечания |136| --- | --- | --- |137| `x \| y` | побитовое *ИЛИ* для *x* и *y* | (4) |138| `x ^ y` | побитовое *исключающее ИЛИ* для *x* и *y* | (4) |139| `x & y` | побитовое *И* для *x* и *y* | (4) |140| `x << n` | *x*, сдвинутое влево на *n* битов | (1)(2) |141| `x >> n` | *x*, сдвинутое вправо на *n* битов | (1)(3) |142| `~x` | инвертированные биты *x* | |143144Примечания:1451461. Отрицательные значения сдвига недопустимы и вызывают [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError).1472. Сдвиг влево на *n* битов эквивалентен умножению на `pow(2, n)`.1483. Сдвиг вправо на *n* битов эквивалентен целочисленному делению на `pow(2, n)`.1494. Выполнение этих вычислений с хотя бы одним дополнительным битом знакового расширения в конечном дополнительном коде (рабочая разрядность `1 + max(x.bit_length(), y.bit_length())` или более) достаточно для получения того же результата, как если бы было бесконечное количество знаковых битов.150151### Дополнительные методы для целых типов152153Тип int реализует [`numbers.Integral`](https://python-all.ru/3.8/library/numbers.html#numbers.Integral) [абстрактный базовый класс](https://python-all.ru/3.8/glossary.html#term-abstract-base-class). Кроме того, он предоставляет ещё несколько методов:154155#### `int.bit_length()`156157Возвращает количество битов, необходимое для представления целого числа в двоичном виде, без учёта знака и ведущих нулей:158159```python160>>> n = -37161>>> bin(n)162'-0b100101'163>>> n.bit_length()1646165```166167Более точно, если `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`.168169Эквивалентно следующему:170171```python172def bit_length(self):173 s = bin(self) # двоичное представление: bin(-37) --> '-0b100101'174 s = s.lstrip('-0b') # удалить ведущие нули и знак минус175 return len(s) # len('100101') --> 6176```177178Новое в версии 3.1.179180#### `int.to_bytes(length, byteorder, *, signed=False)`181182Возвращает массив байтов, представляющий целое число.183184```python185>>> (1024).to_bytes(2, byteorder='big')186b'\x04\x00'187>>> (1024).to_bytes(10, byteorder='big')188b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'189>>> (-1024).to_bytes(10, byteorder='big', signed=True)190b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'191>>> x = 1000192>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')193b'\xe8\x03'194```195196Целое число представляется с использованием *длины* байт. Исключение [`OverflowError`](https://python-all.ru/3.8/library/exceptions.html#OverflowError) возбуждается, если целое число не может быть представлено заданным количеством байт.197198Аргумент *byteorder* определяет порядок байтов, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байтов. Если *byteorder* равен `"little"`, старший байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.8/library/sys.html#sys.byteorder) в качестве значения порядка байтов.199200Аргумент *signed* определяет, используется ли дополнительный код для представления целого числа. Если *signed* равен `False` и передано отрицательное целое число, вызывается исключение [`OverflowError`](https://python-all.ru/3.8/library/exceptions.html#OverflowError). Значение по умолчанию для *signed* – `False`.201202Новое в версии 3.2.203204#### `classmethod int.from_bytes(bytes, byteorder, *, signed=False)`205206Возвращает целое число, представленное заданным массивом байтов.207208```python209>>> int.from_bytes(b'\x00\x10', byteorder='big')21016211>>> int.from_bytes(b'\x00\x10', byteorder='little')2124096213>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)214-1024215>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)21664512217>>> int.from_bytes([255, 0, 0], byteorder='big')21816711680219```220221Аргумент *bytes* должен быть либо [bytes-подобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object), либо итерабельным объектом, производящим байты.222223Аргумент *byteorder* определяет порядок байтов, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байтов. Если *byteorder* равен `"little"`, старший байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.8/library/sys.html#sys.byteorder) в качестве значения порядка байтов.224225Аргумент *signed* указывает, используется ли дополнительный код для представления целого числа.226227Новое в версии 3.2.228229#### `int.as_integer_ratio()`230231Возвращает пару целых чисел, отношение которых в точности равно исходному целому числу, с положительным знаменателем. Для целых чисел результатом всегда является само число в качестве числителя и `1` в качестве знаменателя.232233Новое в версии 3.8.234235### Дополнительные методы float236237Тип float реализует [`numbers.Real`](https://python-all.ru/3.8/library/numbers.html#numbers.Real) [абстрактный базовый класс](https://python-all.ru/3.8/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.238239#### `float.as_integer_ratio()`240241Возвращает пару целых чисел, отношение которых в точности равно исходному числу с плавающей запятой, с положительным знаменателем. Возбуждает [`OverflowError`](https://python-all.ru/3.8/library/exceptions.html#OverflowError) для бесконечностей и [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError) для NaN.242243#### `float.is_integer()`244245Возвращает `True`, если экземпляр float является конечным и имеет целочисленное значение, и `False` в противном случае:246247```python248>>> (-2.0).is_integer()249True250>>> (3.2).is_integer()251False252```253254Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python внутренне хранятся в двоичном виде, преобразование числа с плавающей запятой в строку *decimal* и обратно обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точно представлять и задавать числа с плавающей запятой. Это может быть полезно при отладке и в численных расчётах.255256#### `float.hex()`257258Возвращает представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой это представление всегда будет содержать ведущий `0x` и завершающий `p` и экспоненту.259260#### `classmethod float.fromhex(s)`261262Метод класса, возвращающий число с плавающей запятой, представленное шестнадцатеричной строкой *s*. Строка *s* может содержать начальные и конечные пробелы.263264Обратите внимание, что [`float.hex()`](https://python-all.ru/3.8/library/stdtypes.html#float.hex) – это метод экземпляра, а [`float.fromhex()`](https://python-all.ru/3.8/library/stdtypes.html#float.fromhex) – метод класса.265266Шестнадцатеричная строка имеет вид:267268```python269[sign] ['0x'] integer ['.' fraction] ['p' exponent]270```271272где необязательный `sign` может быть либо `+`, либо `-`, `integer` и `fraction` – строки шестнадцатеричных цифр, а `exponent` – десятичное целое с необязательным ведущим знаком. Регистр не имеет значения, и должна быть хотя бы одна шестнадцатеричная цифра в целой части либо в дробной. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и выше. В частности, результат [`float.hex()`](https://python-all.ru/3.8/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде C или Java, а шестнадцатеричные строки, созданные символом формата `%a` в C или `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.8/library/stdtypes.html#float.fromhex).273274Обратите внимание, что экспонента записывается в десятичном, а не шестнадцатеричном виде, и что она указывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка `0x3.a7p10` представляет число с плавающей запятой `(3 + 10./16 + 7./16**2) * 2.0**10`, или `3740.0`:275276```python277>>> float.fromhex('0x3.a7p10')2783740.0279```280281Применение обратного преобразования к `3740.0` даёт другую шестнадцатеричную строку, представляющую то же число:282283```python284>>> float.hex(3740.0)285'0x1.d380000000000p+11'286```287288### Хеширование числовых типов289290Для чисел `x` и `y`, возможно разных типов, требуется, чтобы `hash(x) == hash(y)` всякий раз, когда `x == y` (см. документацию метода [`__hash__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__hash__) для подробностей). Для простоты реализации и эффективности для различных числовых типов (включая [`int`](https://python-all.ru/3.8/library/functions.html#int), [`float`](https://python-all.ru/3.8/library/functions.html#float), [`decimal.Decimal`](https://python-all.ru/3.8/library/decimal.html#decimal.Decimal) и [`fractions.Fraction`](https://python-all.ru/3.8/library/fractions.html#fractions.Fraction)) хеш Python для числовых типов основан на одной математической функции, определённой для любого рационального числа, и, следовательно, применим ко всем экземплярам [`int`](https://python-all.ru/3.8/library/functions.html#int) и [`fractions.Fraction`](https://python-all.ru/3.8/library/fractions.html#fractions.Fraction), а также ко всем конечным экземплярам [`float`](https://python-all.ru/3.8/library/functions.html#float) и [`decimal.Decimal`](https://python-all.ru/3.8/library/decimal.html#decimal.Decimal). По существу, эта функция задаётся приведением по модулю `P` для фиксированного простого числа `P`. Значение `P` доступно в Python как атрибут `modulus` объекта [`sys.hash_info`](https://python-all.ru/3.8/library/sys.html#sys.hash_info).291292**Деталь реализации CPython:** В настоящее время используется простое число `P = 2**31 - 1` на машинах с 32-битными C longs и `P = 2**61 - 1` на машинах с 64-битными C longs.293294Вот подробные правила:295296- Если `x = m / n` – неотрицательное рациональное число и `n` не делится на `P`, определим `hash(x)` как `m * invmod(n, P) % P`, где `invmod(n, P)` даёт обратное к `n` по модулю `P`.297- Если `x = m / n` – неотрицательное рациональное число и `n` делится на `P` (но `m` не делится), то `n` не имеет обратного по модулю `P`, и вышеуказанное правило не применяется; в этом случае определим `hash(x)` как константу `sys.hash_info.inf`.298- Если `x = m / n` – отрицательное рациональное число, определим `hash(x)` как `-hash(-x)`. Если полученный хеш равен `-1`, заменим его на `-2`.299- Определённые значения `sys.hash_info.inf`, `-sys.hash_info.inf` и `sys.hash_info.nan` используются как хеш-значения для положительной бесконечности, отрицательной бесконечности или nan (соответственно). (Все хешируемые nan имеют одинаковое хеш-значение.)300- Для комплексного числа [`complex`](https://python-all.ru/3.8/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`.301302Для пояснения вышеуказанных правил приведём пример кода Python, эквивалентного встроенной функции hash, для вычисления хеша рационального числа, [`float`](https://python-all.ru/3.8/library/functions.html#float) или [`complex`](https://python-all.ru/3.8/library/functions.html#complex):303304```python305import sys, math306307def hash_fraction(m, n):308 """Вычислить хеш рационального числа m / n.309310 Предполагается, что m и n – целые числа, n положительное.311 Эквивалентно hash(fractions.Fraction(m, n)).312313 """314 P = sys.hash_info.modulus315 # Удалить общие делители P. (Необязательно, если m и n уже взаимно просты.)316 while m % P == n % P == 0:317 m, n = m // P, n // P318319 if n % P == 0:320 hash_value = sys.hash_info.inf321 else:322 # Малая теорема Ферма: pow(n, P-1, P) равно 1, поэтому323 # pow(n, P-2, P) даёт обратный элемент n по модулю P.324 hash_value = (abs(m) % P) * pow(n, P - 2, P) % P325 if m < 0:326 hash_value = -hash_value327 if hash_value == -1:328 hash_value = -2329 return hash_value330331def hash_float(x):332 """Вычислить хеш числа с плавающей запятой x."""333334 if math.isnan(x):335 return sys.hash_info.nan336 elif math.isinf(x):337 return sys.hash_info.inf if x > 0 else -sys.hash_info.inf338 else:339 return hash_fraction(*x.as_integer_ratio())340341def hash_complex(z):342 """Вычислить хеш комплексного числа z."""343344 hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)345 # выполнить знаковое приведение по модулю 2**sys.hash_info.width346 M = 2**(sys.hash_info.width - 1)347 hash_value = (hash_value & (M - 1)) - (hash_value & M)348 if hash_value == -1:349 hash_value = -2350 return hash_value351```352353## Типы итераторов354355Python поддерживает концепцию итерации по контейнерам. Это реализовано с помощью двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают методы итерации.356357Для поддержки итерации в объектах-контейнерах необходимо определить один метод:358359#### `container.__iter__()`360361Возвращает объект-итератор. Этот объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные типы итерации, можно предоставить дополнительные методы для явного запроса итераторов для этих типов. (Примером объекта, поддерживающего несколько форм итерации, может служить древовидная структура, поддерживающая обход как в ширину, так и в глубину.) Этот метод соответствует слоту [`tp_iter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в API Python/C.362363Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:364365#### `iterator.__iter__()`366367Возвращает сам объект-итератор. Это необходимо, чтобы контейнеры и итераторы можно было использовать с операторами [`for`](https://python-all.ru/3.8/reference/compound_stmts.html#for) и [`in`](https://python-all.ru/3.8/reference/expressions.html#in). Данный метод соответствует слоту [`tp_iter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в API Python/C.368369#### `iterator.__next__()`370371Возвращает следующий элемент из контейнера. Если больше элементов нет, возбуждает исключение [`StopIteration`](https://python-all.ru/3.8/library/exceptions.html#StopIteration). Этот метод соответствует слоту [`tp_iternext`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iternext) структуры типа для объектов Python в API Python/C.372373Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.374375Как только метод [`__next__()`](https://python-all.ru/3.8/library/stdtypes.html#iterator.__next__) итератора вызывает [`StopIteration`](https://python-all.ru/3.8/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.376377### Типы генераторов378379[Генераторы](https://python-all.ru/3.8/glossary.html#term-generator) Python предоставляют удобный способ реализации протокола итератора. Если метод [`__iter__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__iter__) объекта контейнера реализован как генератор, он автоматически вернет объект итератора (технически объект генератора), предоставляющий методы [`__iter__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__iter__) и [`__next__()`](https://python-all.ru/3.8/reference/expressions.html#generator.__next__). Дополнительную информацию о генераторах можно найти в [документации по yield expression](https://python-all.ru/3.8/reference/expressions.html#yieldexpr).380381## Типы последовательностей – [`list`](https://python-all.ru/3.8/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple), [`range`](https://python-all.ru/3.8/library/stdtypes.html#range)382383Существуют три основных типа последовательностей: списки, кортежи и объекты range. Дополнительные типы последовательностей, предназначенные для обработки [двоичных данных](https://python-all.ru/3.8/library/stdtypes.html#binaryseq) и [текстовых строк](https://python-all.ru/3.8/library/stdtypes.html#textseq), описаны в отдельных разделах.384385### Общие операции с последовательностями386387Операции, перечисленные в следующей таблице, поддерживаются большинством типов последовательностей, как изменяемых, так и неизменяемых. ABC [`collections.abc.Sequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Sequence) предоставляется, чтобы упростить корректную реализацию этих операций в пользовательских типах последовательностей.388389В этой таблице перечислены операции с последовательностями, отсортированные по возрастанию приоритета. В таблице *s* и *t* – последовательности одного типа, *n*, *i*, *j* и *k* – целые числа, а *x* – произвольный объект, удовлетворяющий любым ограничениям на тип и значение, накладываемым *s*.390391Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` (конкатенация) и `*` (повторение) имеют тот же приоритет, что и соответствующие числовые операции. [3](https://python-all.ru/3.8/library/stdtypes.html#id14)392393| Операция | Результат | Примечания |394| --- | --- | --- |395| `x in s` | `True`, если элемент последовательности *s* равен *x*, иначе `False` | (1) |396| `x not in s` | `False`, если элемент последовательности *s* равен *x*, иначе `True` | (1) |397| `s + t` | конкатенация *s* и *t* | (6)(7) |398| `s * n` или `n * s` | эквивалентно сложению *s* с собой *n* раз | (2)(7) |399| `s[i]` | *i*-й элемент *s*, начиная с 0 | (3) |400| `s[i:j]` | срез *s* от *i* до *j* | (3)(4) |401| `s[i:j:k]` | срез *s* от *i* до *j* с шагом *k* | (3)(5) |402| `len(s)` | длина *s* | |403| `min(s)` | наименьший элемент *s* | |404| `max(s)` | наибольший элемент *s* | |405| `s.index(x[, i[, j]])` | индекс первого вхождения *x* в *s* (начиная с индекса *i* и до индекса *j*) | (8) |406| `s.count(x)` | общее количество вхождений *x* в *s* | |407408Последовательности одного типа также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равен, а две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в [Comparisons](https://python-all.ru/3.8/reference/expressions.html#comparisons) в справочнике по языку.)409410Примечания:4114121. Хотя операции `in` и `not in` в общем случае используются только для простой проверки на вхождение, некоторые специализированные последовательности (например, [`str`](https://python-all.ru/3.8/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray)) также используют их для проверки на подпоследовательность:413414 ```python415 >>> "gg" in "eggs"416 True417 ```4182. Значения *n* меньше `0` трактуются как `0` (что даёт пустую последовательность того же типа, что и *s*). Обратите внимание: элементы последовательности *s* не копируются; на них ссылаются многократно. Это часто преследует начинающих программистов Python; рассмотрите:419420 ```python421 >>> lists = [[]] * 3422 >>> lists423 [[], [], []]424 >>> lists[0].append(3)425 >>> lists426 [[3], [3], [3]]427 ```428429 Произошло следующее: `[[]]` – это список из одного элемента, содержащего пустой список, поэтому все три элемента `[[]] * 3` являются ссылками на этот единственный пустой список. Изменение любого из элементов `lists` изменяет этот единственный список. Создать список из разных списков можно так:430431 ```python432 >>> lists = [[] for i in range(3)]433 >>> lists[0].append(3)434 >>> lists[1].append(5)435 >>> lists[2].append(7)436 >>> lists437 [[3], [5], [7]]438 ```439440 Подробное объяснение доступно в разделе FAQ [Как создать многомерный список?](https://python-all.ru/3.8/faq/programming.html#faq-multidimensional-list).4413. Если *i* или *j* отрицательное, индекс отсчитывается от конца последовательности *s*: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание: `-0` по-прежнему равно `0`.4424. Срез *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, для которых `i <= k < j`. Если *i* или *j* больше `len(s)`, используйте `len(s)`. Если *i* опущен или равен `None`, используйте `0`. Если *j* опущен или равен `None`, используйте `len(s)`. Если *i* больше или равно *j*, срез пуст.4435. 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`.4446. Конкатенация неизменяемых последовательностей всегда приводит к созданию нового объекта. Это означает, что построение последовательности путём многократной конкатенации будет иметь квадратичную временную сложность от общей длины последовательности. Чтобы получить линейную сложность, следует перейти к одному из следующих вариантов:445446 - при конкатенации объектов [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) можно собрать список, а затем использовать [`str.join()`](https://python-all.ru/3.8/library/stdtypes.html#str.join) в конце или же записывать данные в экземпляр [`io.StringIO`](https://python-all.ru/3.8/library/io.html#io.StringIO) и получить его значение по завершении447 - при конкатенации объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) можно аналогично использовать [`bytes.join()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.join) или [`io.BytesIO`](https://python-all.ru/3.8/library/io.html#io.BytesIO), либо выполнять конкатенацию на месте с объектом [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray). Объекты [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) являются изменяемыми и обладают эффективным механизмом предварительного выделения памяти448 - при конкатенации объектов [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple) лучше расширять объект [`list`](https://python-all.ru/3.8/library/stdtypes.html#list)449 - для других типов – изучите документацию соответствующего класса4507. Некоторые типы последовательностей (например, [`range`](https://python-all.ru/3.8/library/stdtypes.html#range)) поддерживают только такие последовательности элементов, которые подчиняются определённым шаблонам, и поэтому не поддерживают конкатенацию или повторение последовательностей.4518. `index` вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если *x* не найден в *s*. Не все реализации поддерживают передачу дополнительных аргументов *i* и *j*. Эти аргументы позволяют эффективно искать подстроки последовательности. Передача дополнительных аргументов примерно эквивалентна использованию `s[i:j].index(x)`, но без копирования данных и с возвращаемым индексом относительно начала последовательности, а не начала среза.452453### Неизменяемые типы последовательностей454455Единственная операция, которую неизменяемые последовательности обычно реализуют, но которой нет у изменяемых, – это поддержка встроенной функции [`hash()`](https://python-all.ru/3.8/library/functions.html#hash).456457Эта поддержка позволяет использовать неизменяемые последовательности, такие как экземпляры [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple), в качестве ключей [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict) и хранить их в экземплярах [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset).458459Попытка вычислить хеш неизменяемой последовательности, содержащей нехешируемые значения, приведёт к [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError).460461### Изменяемые типы последовательностей462463В следующей таблице приведены операции, определённые для изменяемых типов последовательностей. ABC [`collections.abc.MutableSequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MutableSequence) предоставляется для упрощения корректной реализации этих операций в пользовательских типах последовательностей.464465В таблице *s* – экземпляр изменяемого типа последовательности, *t* – любой итерируемый объект, а *x* – произвольный объект, удовлетворяющий всем ограничениям по типу и значению, накладываемым *s* (например, [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) принимает только целые числа, удовлетворяющие ограничению по значению `0 <= x <= 255`).466467| Операция | Результат | Примечания |468| --- | --- | --- |469| `s[i] = x` | элемент *i* из *s* заменяется на *x* | |470| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* | |471| `del s[i:j]` | то же, что и `s[i:j] = []` | |472| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами из *t* | (1) |473| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка | |474| `s.append(x)` | добавляет *x* в конец последовательности (то же, что `s[len(s):len(s)] = [x]`) | |475| `s.clear()` | удаляет все элементы из *s* (то же, что `del s[:]`) | (5) |476| `s.copy()` | создаёт поверхностную копию *s* (то же, что `s[:]`) | (5) |477| `s.extend(t)` или `s += t` | расширяет *s* содержимым *t* (в основном то же, что и `s[len(s):len(s)] = t`) | |478| `s *= n` | обновляет *s*, повторяя его содержимое *n* раз | (6) |479| `s.insert(i, x)` | вставляет *x* в *s* по индексу *i* (то же, что `s[i:i] = [x]`) | |480| `s.pop()` или `s.pop(i)` | извлекает элемент по индексу *i* и удаляет его из *s* | (2) |481| `s.remove(x)` | удаляет первый элемент из *s*, для которого `s[i]` равно *x* | (3) |482| `s.reverse()` | переворачивает элементы *s* на месте | (4) |483484Примечания:4854861. *t* должен иметь ту же длину, что и заменяемый срез.4872. Необязательный аргумент *i* по умолчанию равен `-1`, поэтому по умолчанию удаляется и возвращается последний элемент.4883. `remove()` вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если *x* не найден в *s*.4894. Метод `reverse()` изменяет последовательность на месте для экономии памяти при обращении большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он не возвращает обращённую последовательность.4905. `clear()` и `copy()` включены для согласованности с интерфейсами изменяемых контейнеров, которые не поддерживают операции среза (таких как [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict) и [`set`](https://python-all.ru/3.8/library/stdtypes.html#set)). `copy()` не является частью абстрактного базового класса [`collections.abc.MutableSequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.MutableSequence), но большинство конкретных классов изменяемых последовательностей его предоставляют.491492 Новое в версии 3.3: `clear()` и `copy()` методы.4936. Значение *n* – целое число или объект, реализующий [`__index__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__index__). Нулевые и отрицательные значения *n* очищают последовательность. Элементы последовательности не копируются; на них делаются множественные ссылки, как описано для `s * n` в разделе [Общие операции с последовательностями](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common).494495### Списки496497Списки – это изменяемые последовательности, обычно используемые для хранения коллекций однородных элементов (степень однородности может варьироваться в зависимости от приложения).498499#### `class list([iterable])`500501Списки можно создать несколькими способами:502503- Используя пару квадратных скобок для обозначения пустого списка: `[]`504- Используя квадратные скобки, разделяя элементы запятыми: `[a]`, `[a, b, c]`505- Используя списковое включение: `[x for x in iterable]`506- Используя конструктор типа: `list()` или `list(iterable)`507508Конструктор создаёт список, элементы которого совпадают с элементами *итерируемого объекта* и располагаются в том же порядке. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *итерируемый объект* уже является списком, создаётся и возвращается его копия (аналогично `iterable[:]`). Например, `list('abc')` возвращает `['a', 'b', 'c']`, а `list( (1, 2, 3) )` возвращает `[1, 2, 3]`. Если аргумент не указан, конструктор создаёт новый пустой список – `[]`.509510Многие другие операции также создают списки, включая встроенную функцию [`sorted()`](https://python-all.ru/3.8/library/functions.html#sorted).511512Списки реализуют все [общие](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common) и [изменяемые](https://python-all.ru/3.8/library/stdtypes.html#typesseq-mutable) операции последовательностей. Списки также предоставляют следующий дополнительный метод:513514#### `sort(*, key=None, reverse=False)`515516Этот метод сортирует список на месте, используя только `<` сравнений между элементами. Исключения не подавляются – если какая-либо операция сравнения завершится ошибкой, вся сортировка завершится ошибкой (и список, скорее всего, останется в частично изменённом состоянии).517518[`sort()`](https://python-all.ru/3.8/library/stdtypes.html#list.sort) принимает два аргумента, которые могут быть переданы только по ключевому слову ([аргументы только по ключевому слову](https://python-all.ru/3.8/glossary.html#keyword-only-parameter)):519520*key* задаёт функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка (например, `key=str.lower`). Ключ для каждого элемента списка вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию `None` означает, что элементы списка сортируются напрямую, без вычисления отдельного ключа.521522Утилита [`functools.cmp_to_key()`](https://python-all.ru/3.8/library/functools.html#functools.cmp_to_key) позволяет преобразовать функцию сравнения *cmp* в стиле 2.x в функцию *key*.523524*reverse* – булево значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.525526Этот метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает с побочным эффектом, он не возвращает отсортированную последовательность (используйте [`sorted()`](https://python-all.ru/3.8/library/functions.html#sorted) для явного запроса нового отсортированного списка).527528Метод [`sort()`](https://python-all.ru/3.8/library/stdtypes.html#list.sort) гарантированно устойчив. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые считаются равными – это полезно при многоэтапной сортировке (например, сначала по отделу, затем по уровню зарплаты).529530Примеры сортировки и краткое руководство см. в [Sorting HOW TO](https://python-all.ru/3.8/howto/sorting.html#sortinghowto).531532**Особенность реализации CPython:** Во время сортировки списка результат попыток изменить или даже проверить список не определён. Реализация Python на C делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.533534### Кортежи535536Кортежи – это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (например, пар, возвращаемых встроенной функцией [`enumerate()`](https://python-all.ru/3.8/library/functions.html#enumerate)). Кортежи также используются в случаях, когда требуется неизменяемая последовательность однородных данных (например, для хранения в экземпляре [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) или [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict)).537538#### `class tuple([iterable])`539540Кортежи можно создать несколькими способами:541542- Используя пару круглых скобок для обозначения пустого кортежа: `()`543- Используя завершающую запятую для кортежа из одного элемента: `a,` или `(a,)`544- Разделяя элементы запятыми: `a, b, c` или `(a, b, c)`545- Используя встроенную функцию [`tuple()`](https://python-all.ru/3.8/library/stdtypes.html#tuple): `tuple()` или `tuple(iterable)`546547Конструктор создаёт кортеж, элементы которого совпадают с элементами *итерируемого объекта* и располагаются в том же порядке. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *итерируемый объект* уже является кортежем, он возвращается без изменений. Например, `tuple('abc')` возвращает `('a', 'b', 'c')`, а `tuple( [1, 2, 3] )` возвращает `(1, 2, 3)`. Если аргумент не указан, конструктор создаёт новый пустой кортеж – `()`.548549Обратите внимание, что кортеж создаётся запятой, а не круглыми скобками. Скобки необязательны, за исключением пустого кортежа или случаев, когда они необходимы для устранения синтаксической неоднозначности. Например, `f(a, b, c)` – это вызов функции с тремя аргументами, а `f((a, b, c))` – это вызов функции с одним аргументом – кортежем из трёх элементов.550551Кортежи реализуют все [общие](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common) операции последовательностей.552553Для гетерогенных коллекций данных, где доступ по имени понятнее, чем доступ по индексу, [`collections.namedtuple()`](https://python-all.ru/3.8/library/collections.html#collections.namedtuple) может быть более подходящим выбором, чем простой объект кортежа.554555### Диапазоны556557Тип [`range`](https://python-all.ru/3.8/library/stdtypes.html#range) представляет собой неизменяемую последовательность чисел и обычно используется для цикла с определённым числом итераций в циклах [`for`](https://python-all.ru/3.8/reference/compound_stmts.html#for).558559#### `class range(stop)`560561#### `class range(start, stop[, step])`562563Аргументы конструктора range должны быть целыми числами (либо встроенными [`int`](https://python-all.ru/3.8/library/functions.html#int), либо любым объектом, реализующим специальный метод `__index__`). Если аргумент *step* опущен, по умолчанию используется `1`. Если аргумент *start* опущен, по умолчанию используется `0`. Если *step* равен нулю, возбуждается [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError).564565Для положительного *step* содержимое диапазона `r` определяется формулой `r[i] = start + step*i`, где `i >= 0` и `r[i] < stop`.566567Для отрицательного *step* содержимое диапазона по-прежнему определяется формулой `r[i] = start + step*i`, но ограничениями являются `i >= 0` и `r[i] > stop`.568569Объект диапазона будет пустым, если `r[0]` не удовлетворяет ограничению значения. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексация с конца последовательности, определяемой положительными индексами.570571Диапазоны, содержащие абсолютные значения больше [`sys.maxsize`](https://python-all.ru/3.8/library/sys.html#sys.maxsize), допускаются, но некоторые функции (например [`len()`](https://python-all.ru/3.8/library/functions.html#len)) могут возбуждать [`OverflowError`](https://python-all.ru/3.8/library/exceptions.html#OverflowError).572573Примеры диапазонов:574575```python576>>> list(range(10))577[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]578>>> list(range(1, 11))579[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]580>>> list(range(0, 30, 5))581[0, 5, 10, 15, 20, 25]582>>> list(range(0, 10, 3))583[0, 3, 6, 9]584>>> list(range(0, -10, -1))585[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]586>>> list(range(0))587[]588>>> list(range(1, 0))589[]590```591592Диапазоны реализуют все [общие](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common) операции последовательностей, за исключением конкатенации и повторения (ввиду того, что объекты диапазонов могут представлять только последовательности, следующие строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).593594#### `start`595596Значение параметра *start* (или `0`, если параметр не был указан)597598#### `stop`599600Значение параметра *stop*601602#### `step`603604Значение параметра *step* (или `1`, если параметр не был указан)605606Преимущество типа [`range`](https://python-all.ru/3.8/library/stdtypes.html#range) перед обычными [`list`](https://python-all.ru/3.8/library/stdtypes.html#list) или [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple) заключается в том, что объект [`range`](https://python-all.ru/3.8/library/stdtypes.html#range) всегда занимает одинаковый (небольшой) объём памяти, независимо от размера диапазона, который он представляет (поскольку он хранит только значения `start`, `stop` и `step`, вычисляя отдельные элементы и поддиапазоны по мере необходимости).607608Объекты диапазонов реализуют абстрактный базовый класс (ABC) [`collections.abc.Sequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Sequence) и предоставляет такие возможности, как проверка на вхождение, поиск индекса элемента, срезы и поддержка отрицательных индексов (см. [Типы последовательностей – list, tuple, range](https://python-all.ru/3.8/library/stdtypes.html#typesseq)):609610```python611>>> r = range(0, 20, 2)612>>> r613range(0, 20, 2)614>>> 11 in r615False616>>> 10 in r617True618>>> r.index(10)6195620>>> r[5]62110622>>> r[:5]623range(0, 10, 2)624>>> r[-1]62518626```627628Проверка объектов диапазонов на равенство с `==` и `!=` сравнивает их как последовательности. То есть два объекта диапазонов считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два равных объекта диапазонов могут иметь разные атрибуты [`start`](https://python-all.ru/3.8/library/stdtypes.html#range.start), [`stop`](https://python-all.ru/3.8/library/stdtypes.html#range.stop) и [`step`](https://python-all.ru/3.8/library/stdtypes.html#range.step), например `range(0) == range(2, 1, 3)` или `range(0, 3, 2) == range(0, 4, 2)`.)629630Изменено в версии 3.2: Реализует ABC Sequence. Поддерживает срезы и отрицательные индексы. Проверяет принадлежность объектов [`int`](https://python-all.ru/3.8/library/functions.html#int) за константное время вместо итерации по всем элементам.631632Изменено в версии 3.3: Определяет ‘==’ и ‘!=’ для сравнения объектов диапазонов на основе последовательности значений, которые они определяют (вместо сравнения по идентичности объектов).633634Новое в версии 3.3: атрибуты [`start`](https://python-all.ru/3.8/library/stdtypes.html#range.start), [`stop`](https://python-all.ru/3.8/library/stdtypes.html#range.stop) и [`step`](https://python-all.ru/3.8/library/stdtypes.html#range.step).635636> **См. также**637>638> - [Рецепт linspace](https://python-all.ru/3.8/library/stdtypes.html) показывает, как реализовать ленивую версию range, подходящую для работы с числами с плавающей запятой.639640## Тип текстовой последовательности – [`str`](https://python-all.ru/3.8/library/stdtypes.html#str)641642Текстовые данные в Python представлены объектами [`str`](https://python-all.ru/3.8/library/stdtypes.html#str), или *строками*. Строки – неизменяемые [последовательности](https://python-all.ru/3.8/library/stdtypes.html#typesseq) кодовых точек Unicode. Строковые литералы записываются различными способами:643644- Одинарные кавычки: `'allows embedded "double" quotes'`645- Двойные кавычки: `"allows embedded 'single' quotes"`.646- Тройные кавычки: `'''Three single quotes'''`, `"""Three double quotes"""`647648Строки в тройных кавычках могут занимать несколько строк – все сопутствующие пробельные символы будут включены в строковый литерал.649650Строковые литералы, являющиеся частью одного выражения и разделённые только пробельными символами, будут неявно объединены в один строковый литерал. То есть `("spam " "eggs") == "spam eggs"`.651652См. [Строковые и байтовые литералы](https://python-all.ru/3.8/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах строковых литералов, включая поддерживаемые escape-последовательности, и префикс `r` («сырой»), который отключает обработку большинства escape-последовательностей.653654Строки также могут быть созданы из других объектов с помощью конструктора [`str`](https://python-all.ru/3.8/library/stdtypes.html#str).655656Поскольку отдельного типа «символ» не существует, индексация строки даёт строку длины 1. То есть для непустой строки *s* выполняется `s[0] == s[0:1]`.657658Также нет изменяемого строкового типа, но [`str.join()`](https://python-all.ru/3.8/library/stdtypes.html#str.join) или [`io.StringIO`](https://python-all.ru/3.8/library/io.html#io.StringIO) можно использовать для эффективного построения строк из нескольких фрагментов.659660Изменено в версии 3.3: Для обратной совместимости с серией Python 2 префикс `u` снова разрешён в строковых литералах. Он не влияет на значение строковых литералов и не может сочетаться с префиксом `r`.661662#### `class str(object='')`663664#### `class str(object=b'', encoding='utf-8', errors='strict')`665666Возвращает [строковое](https://python-all.ru/3.8/library/stdtypes.html#textseq) представление *объекта*. Если *объект* не указан, возвращает пустую строку. В противном случае поведение `str()` зависит от того, указаны ли *encoding* или *errors*, как описано ниже.667668Если не указаны ни *encoding*, ни *errors*, `str(object)` возвращает [`object.__str__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__str__) – «неформальное» или хорошо читаемое строковое представление *object*. Для строковых объектов это сама строка. Если *object* не имеет метода [`__str__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__str__), то [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str) возвращает [`repr(object)`](https://python-all.ru/3.8/library/functions.html#repr).669670Если указан хотя бы один из *encoding* или *errors*, *object* должен быть [байтово-подобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) (например, [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) или [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray)). В этом случае, если *объект* является объектом [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) (или [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray)), то `str(bytes, encoding, errors)` эквивалентно [`bytes.decode(encoding, errors)`](https://python-all.ru/3.8/library/stdtypes.html#bytes.decode). В противном случае объект bytes, лежащий в основе буферного объекта, получается перед вызовом [`bytes.decode()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.decode). Смотрите [Типы двоичных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.8/library/stdtypes.html#binaryseq) и [Протокол буфера](https://python-all.ru/3.8/c-api/buffer.html#bufferobjects) для информации о буферных объектах.671672Передача объекта [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) в [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str) без аргументов *encoding* или *errors* относится к первому случаю возврата неформального строкового представления (см. также параметр командной строки [`-b`](https://python-all.ru/3.8/using/cmdline.html#cmdoption-b) Python). Например:673674```python675>>> str(b'Zoot!')676"b'Zoot!'"677```678679Для получения дополнительной информации о классе `str` и его методах см. [Тип текстовой последовательности – str](https://python-all.ru/3.8/library/stdtypes.html#textseq) и раздел [Методы строк](https://python-all.ru/3.8/library/stdtypes.html#string-methods) ниже. Для вывода форматированных строк см. разделы [Форматированные строковые литералы](https://python-all.ru/3.8/reference/lexical_analysis.html#f-strings) и [Синтаксис форматной строки](https://python-all.ru/3.8/library/string.html#formatstrings). Кроме того, см. раздел [Сервисы обработки текста](https://python-all.ru/3.8/library/text.html#stringservices).680681### Методы строк682683Строки реализуют все [общие](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common) операции с последовательностями, а также дополнительные методы, описанные ниже.684685Строки также поддерживают два стиля форматирования: один предоставляет большую гибкость и настройку (см. [`str.format()`](https://python-all.ru/3.8/library/stdtypes.html#str.format), [Синтаксис форматных строк](https://python-all.ru/3.8/library/string.html#formatstrings) и [Пользовательское форматирование строк](https://python-all.ru/3.8/library/string.html#string-formatting)), а другой основан на стиле форматирования C `printf`, который поддерживает более узкий набор типов и немного сложнее в правильном использовании, но зачастую быстрее в тех случаях, с которыми он может справиться ([Форматирование строк в стиле printf](https://python-all.ru/3.8/library/stdtypes.html#old-string-formatting)).686687Раздел [Службы обработки текста](https://python-all.ru/3.8/library/text.html#textservices) стандартной библиотеки охватывает ряд других модулей, предоставляющих различные утилиты для работы с текстом (включая поддержку регулярных выражений в модуле [`re`](https://python-all.ru/3.8/library/re.html#module-re)).688689#### `str.capitalize()`690691Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.692693Изменено в версии 3.8: Первый символ теперь переводится в регистр заголовка (titlecase) вместо заглавного. Это означает, что символы типа диграфов будут иметь заглавной только первую букву, а не весь символ.694695#### `str.casefold()`696697Возвращает копию строки, преобразованную для регистронезависимого сравнения. Такие строки могут использоваться для сравнения без учёта регистра.698699Сведение регистра (casefolding) похоже на приведение к нижнему регистру, но действует более агрессивно, поскольку предназначено для удаления всех различий по регистру в строке. Например, немецкая строчная буква `'ß'` эквивалентна `"ss"`. Поскольку она уже строчная, [`lower()`](https://python-all.ru/3.8/library/stdtypes.html#str.lower) ничего не сделает с `'ß'`; [`casefold()`](https://python-all.ru/3.8/library/stdtypes.html#str.casefold) преобразует её в `"ss"`.700701Алгоритм casefolding описан в разделе 3.13 стандарта Unicode.702703Новое в версии 3.3.704705#### `str.center(width[, fillchar])`706707Возвращает строку, выровненную по центру, длиной *width*. Заполнение выполняется с помощью указанного *fillchar* (по умолчанию – пробел ASCII). Исходная строка возвращается, если *width* меньше или равен `len(s)`.708709#### `str.count(sub[, start[, end]])`710711Возвращает количество непересекающихся вхождений подстроки *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов.712713#### `str.encode(encoding="utf-8", errors="strict")`714715Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* может быть задан для выбора другой схемы обработки ошибок. По умолчанию для *errors* используется `'strict'`, что означает, что ошибки кодирования вызывают исключение [`UnicodeError`](https://python-all.ru/3.8/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'`, а также любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.8/library/codecs.html#codecs.register_error) (см. раздел [Обработчики ошибок](https://python-all.ru/3.8/library/codecs.html#error-handlers)). Список возможных кодировок приведён в разделе [Стандартные кодировки](https://python-all.ru/3.8/library/codecs.html#standard-encodings).716717Изменено в версии 3.1: Добавлена поддержка именованных аргументов.718719#### `str.endswith(suffix[, start[, end]])`720721Возвращает `True`, если строка заканчивается указанным *suffix*, иначе возвращает `False`. *suffix* также может быть кортежем суффиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение прекращается на этой позиции.722723#### `str.expandtabs(tabsize=8)`724725Возвращает копию строки, в которой все символы табуляции заменены на один или несколько пробелов в зависимости от текущей позиции столбца и заданного размера табуляции. Позиции табуляции находятся через каждые *tabsize* символов (по умолчанию 8, что даёт позиции табуляции на столбцах 0, 8, 16 и т.д.). Для разворачивания строки текущий столбец устанавливается в ноль, и строка просматривается посимвольно. Если символ – табуляция (`\t`), в результат вставляется один или несколько пробелов, пока текущий столбец не сравняется со следующей позицией табуляции. (Сам символ табуляции не копируется.) Если символ – новая строка (`\n`) или возврат каретки (`\r`), он копируется, а текущий столбец сбрасывается в ноль. Любой другой символ копируется без изменений, и текущий столбец увеличивается на единицу независимо от того, как этот символ представлен при печати.726727```python728>>> '01\t012\t0123\t01234'.expandtabs()729'01 012 0123 01234'730>>> '01\t012\t0123\t01234'.expandtabs(4)731'01 012 0123 01234'732```733734#### `str.find(sub[, start[, end]])`735736Возвращает наименьший индекс в строке, где подстрока *sub* найдена в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в записи среза. Возвращает `-1`, если *sub* не найдена.737738> **Примечание**739>740> Метод [`find()`](https://python-all.ru/3.8/library/stdtypes.html#str.find) следует использовать только если нужно знать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.8/reference/expressions.html#in):741>742> ```python743> >>> 'Py' in 'Python'744> True745> ```746747#### `str.format(*args, **kwargs)`748749Выполняет операцию форматирования строки. Строка, к которой применяется этот метод, может содержать буквальный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию строки, в которой каждое поле замены заменено строковым значением соответствующего аргумента.750751```python752>>> "The sum of 1 + 2 is {0}".format(1+2)753'The sum of 1 + 2 is 3'754```755756См. [Синтаксис форматных строк](https://python-all.ru/3.8/library/string.html#formatstrings) для описания различных параметров форматирования, которые можно указать в форматных строках.757758> **Примечание**759>760> При форматировании числа ([`int`](https://python-all.ru/3.8/library/functions.html#int), [`float`](https://python-all.ru/3.8/library/functions.html#float), [`complex`](https://python-all.ru/3.8/library/functions.html#complex), [`decimal.Decimal`](https://python-all.ru/3.8/library/decimal.html#decimal.Decimal) и подклассов) с типом `n` (например: `'{:n}'.format(1234)`) функция временно устанавливает локаль `LC_CTYPE` в локаль `LC_NUMERIC` для декодирования полей `decimal_point` и `thousands_sep` объекта `localeconv()`, если они не ASCII или длиннее 1 байта, и локаль `LC_NUMERIC` отличается от локали `LC_CTYPE`. Это временное изменение влияет на другие потоки.761762Изменено в версии 3.7: При форматировании числа с типом `n` функция временно устанавливает локаль `LC_CTYPE` в локаль `LC_NUMERIC` в некоторых случаях.763764#### `str.format_map(mapping)`765766Аналогично `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую, а не копируется в [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict). Это полезно, если, например, `mapping` является подклассом словаря:767768```python769>>> class Default(dict):770... def __missing__(self, key):771... return key772...773>>> '{name} was born in {country}'.format_map(Default(name='Guido'))774'Guido was born in country'775```776777Новое в версии 3.2.778779#### `str.index(sub[, start[, end]])`780781Как [`find()`](https://python-all.ru/3.8/library/stdtypes.html#str.find), но вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если подстрока не найдена.782783#### `str.isalnum()`784785Возвращает `True`, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе `False`. Символ `c` является буквенно-цифровым, если один из следующих методов возвращает `True`: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()` или `c.isnumeric()`.786787#### `str.isalpha()`788789Возвращает `True`, если все символы в строке являются буквенными и есть хотя бы один символ, иначе `False`. Буквенными считаются символы, определённые в базе данных символов Юникода как «Letter», то есть с общим категорийным свойством, равным «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Юникода.790791#### `str.isascii()`792793Возвращает `True`, если строка пуста или все символы в строке являются ASCII, `False` в противном случае. Символы ASCII имеют кодовые точки в диапазоне U+0000–U+007F.794795Добавлено в версии 3.7.796797#### `str.isdecimal()`798799Возвращает `True`, если все символы в строке являются десятичными цифрами и есть хотя бы один символ, и `False` в противном случае. Десятичные цифры – это те, которые можно использовать для записи чисел в десятичной системе, например U+0660 (арабско-индийская цифра ноль). Формально десятичная цифра – это символ общей категории Unicode «Nd».800801#### `str.isdigit()`802803Возвращает `True`, если все символы в строке являются цифрами и есть хотя бы один символ, и `False` в противном случае. Цифры включают десятичные цифры и цифры, требующие специальной обработки, например надстрочные цифры совместимости. Это охватывает цифры, которые нельзя использовать для записи чисел в десятичной системе, например цифры кхарошти. Формально цифра – это символ со значением свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.804805#### `str.isidentifier()`806807Возвращает `True`, если строка является допустимым идентификатором согласно определению языка, раздел [Идентификаторы и ключевые слова](https://python-all.ru/3.8/reference/lexical_analysis.html#identifiers).808809Вызов [`keyword.iskeyword()`](https://python-all.ru/3.8/library/keyword.html#keyword.iskeyword) позволяет проверить, является ли строка `s` зарезервированным идентификатором, например [`def`](https://python-all.ru/3.8/reference/compound_stmts.html#def) и [`class`](https://python-all.ru/3.8/reference/compound_stmts.html#class).810811Пример:812813```python814>>> from keyword import iskeyword815816>>> 'hello'.isidentifier(), iskeyword('hello')817True, False818>>> 'def'.isidentifier(), iskeyword('def')819True, True820```821822#### `str.islower()`823824Возвращает `True`, если все буквенные символы [4](https://python-all.ru/3.8/library/stdtypes.html#id15) в строке являются строчными и в строке есть хотя бы один буквенный символ, иначе `False`.825826#### `str.isnumeric()`827828Возвращает `True`, если все символы в строке являются числовыми символами и есть хотя бы один символ, и `False` в противном случае. Числовые символы включают цифровые символы и все символы, имеющие свойство числового значения Unicode, например U+2155 (обыкновенная дробь одна пятая). Формально числовые символы – это символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric.829830#### `str.isprintable()`831832Возвращает `True`, если все символы в строке являются печатными или строка пуста, иначе `False`. Непечатными считаются символы, определённые в базе данных символов Юникода как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатным. (Обратите внимание, что печатные символы в данном контексте – это те, которые не должны экранироваться при вызове [`repr()`](https://python-all.ru/3.8/library/functions.html#repr) для строки. Это не влияет на обработку строк, записываемых в [`sys.stdout`](https://python-all.ru/3.8/library/sys.html#sys.stdout) или [`sys.stderr`](https://python-all.ru/3.8/library/sys.html#sys.stderr).)833834#### `str.isspace()`835836Возвращает `True`, если в строке есть только пробельные символы и в ней есть хотя бы один символ, иначе `False`.837838Символ считается *пробельным*, если в базе данных символов Unicode (см. [`unicodedata`](https://python-all.ru/3.8/library/unicodedata.html#module-unicodedata)) его общая категория – `Zs` («Separator, space») или его двунаправленный класс – один из `WS`, `B` или `S`.839840#### `str.istitle()`841842Возвращает `True`, если строка записана в заголовочном регистре и содержит хотя бы один символ. Например, прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. В противном случае возвращает `False`.843844#### `str.isupper()`845846Возвращает `True`, если все буквенные символы [4](https://python-all.ru/3.8/library/stdtypes.html#id15) в строке являются прописными и в строке есть хотя бы один буквенный символ, иначе `False`.847848#### `str.join(iterable)`849850Возвращает строку, являющуюся конкатенацией строк из *iterable*. Будет возбуждено исключение [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError), если в *iterable* есть какие-либо значения, не являющиеся строками, включая объекты [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes). Разделителем между элементами служит строка, для которой вызывается этот метод.851852#### `str.ljust(width[, fillchar])`853854Возвращает строку, выровненную по левому краю в строке длины *width*. Заполнение выполняется с использованием указанного *fillchar* (по умолчанию пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`.855856#### `str.lower()`857858Возвращает копию строки, в которой все символы, имеющие регистр, [4](https://python-all.ru/3.8/library/stdtypes.html#id15) преобразованы в нижний регистр.859860Используемый алгоритм приведения к нижнему регистру описан в разделе 3.13 стандарта Юникода.861862#### `str.lstrip([chars])`863864Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* – это не префикс; удаляются все комбинации входящих в него символов:865866```python867>>> ' spacious '.lstrip()868'spacious '869>>> 'www.example.com'.lstrip('cmowz.')870'example.com'871```872873#### `static str.maketrans(x[, y[, z]])`874875Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.8/library/stdtypes.html#str.translate).876877Если указан только один аргумент, он должен быть словарём, отображающим коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или `None`. Ключи-символы при этом преобразуются в коды.878879Если передано два аргумента, они должны быть строками одинаковой длины; в результирующем словаре каждый символ из x будет сопоставлен символу на той же позиции в y. Если есть третий аргумент, он должен быть строкой, символы которой будут сопоставлены `None` в результате.880881#### `str.partition(sep)`882883Разделяет строку по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.884885#### `str.replace(old, new[, count])`886887Возвращает копию строки, в которой все вхождения подстроки *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.888889#### `str.rfind(sub[, start[, end]])`890891Возвращает наибольший индекс в строке, на котором найдена подстрока *sub*, при условии что *sub* находится в пределах `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в записи среза. В случае неудачи возвращает `-1`.892893#### `str.rindex(sub[, start[, end]])`894895Как [`rfind()`](https://python-all.ru/3.8/library/stdtypes.html#str.rfind), но возбуждает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если подстрока *sub* не найдена.896897#### `str.rjust(width[, fillchar])`898899Возвращает строку, выровненную по правому краю в строке длины *width*. Заполнение выполняется с использованием указанного *fillchar* (по умолчанию пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`.900901#### `str.rpartition(sep)`902903Разделяет строку по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.904905#### `str.rsplit(sep=None, maxsplit=-1)`906907Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, причём *самых правых*. Если *sep* не указан или равен `None`, в качестве разделителя используется любая строка из пробельных символов. За исключением разбиения справа, [`rsplit()`](https://python-all.ru/3.8/library/stdtypes.html#str.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.8/library/stdtypes.html#str.split), подробно описанный ниже.908909#### `str.rstrip([chars])`910911Возвращает копию строки с удалёнными завершающими символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является суффиксом; вместо этого удаляются все комбинации его значений:912913```python914>>> ' spacious '.rstrip()915' spacious'916>>> 'mississippi'.rstrip('ipz')917'mississ'918```919920#### `str.split(sep=None, maxsplit=-1)`921922Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (следовательно, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, ограничения на количество разбиений нет (выполняются все возможные разбиения).923924Если указан *sep*, последовательные разделители не группируются, а считаются разделителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов (например, `'1<>2<>3'.split('<>')` возвращает `['1', '2', '3']`). Разделение пустой строки с указанным разделителем возвращает `['']`.925926Например:927928```python929>>> '1,2,3'.split(',')930['1', '2', '3']931>>> '1,2,3'.split(',', maxsplit=1)932['1', '2,3']933>>> '1,2,,3,'.split(',')934['1', '2', '', '3', '']935```936937Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если строка содержит начальные или завершающие пробелы. Следовательно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.938939Например:940941```python942>>> '1 2 3'.split()943['1', '2', '3']944>>> '1 2 3'.split(maxsplit=1)945['1', '2 3']946>>> ' 1 2 3 '.split()947['1', '2', '3']948```949950#### `str.splitlines([keepends])`951952Возвращает список строк в строке, разбивая её по границам строк. Символы перевода строки не включаются в результирующий список, если только *keepends* не задан и не равен true.953954Этот метод разбивает строку по следующим границам строк. В частности, эти границы являются расширенным набором [универсальных символов перевода строки](https://python-all.ru/3.8/glossary.html#term-universal-newlines).955956| Представление | Описание |957| --- | --- |958| `\n` | Перевод строки (LF) |959| `\r` | Возврат каретки (CR) |960| `\r\n` | Возврат каретки + перевод строки (CR+LF) |961| `\v` или `\x0b` | Линейная табуляция |962| `\f` или `\x0c` | Перевод страницы |963| `\x1c` | Разделитель файлов |964| `\x1d` | Разделитель групп |965| `\x1e` | Разделитель записей |966| `\x85` | Следующая строка (управляющий код C1) |967| `\u2028` | Разделитель строк |968| `\u2029` | Разделитель абзацев |969970Изменено в версии 3.2: `\v` и `\f` добавлены в список границ строк.971972Например:973974```python975>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()976['ab c', '', 'de fg', 'kl']977>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)978['ab c\n', '\n', 'de fg\r', 'kl\r\n']979```980981В отличие от [`split()`](https://python-all.ru/3.8/library/stdtypes.html#str.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и концевой разрыв строки не приводит к появлению дополнительной строки:982983```python984>>> "".splitlines()985[]986>>> "One line\n".splitlines()987['One line']988```989990Для сравнения, `split('\n')` возвращает:991992```python993>>> ''.split('\n')994['']995>>> 'Two lines\n'.split('\n')996['Two lines', '']997```998999#### `str.startswith(prefix[, start[, end]])`10001001Возвращает `True`, если строка начинается с *prefix*, иначе возвращает `False`. *prefix* также может быть кортежем префиксов для поиска. При указании необязательного *start* строка проверяется начиная с этой позиции. При указании необязательного *end* сравнение строки прекращается на этой позиции.10021003#### `str.strip([chars])`10041005Возвращает копию строки с удалёнными начальными и завершающими символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:10061007```python1008>>> ' spacious '.strip()1009'spacious'1010>>> 'www.example.com'.strip('cmowz.')1011'example'1012```10131014Самые внешние начальные и завершающие значения аргумента *chars* удаляются из строки. Символы удаляются с начального конца до тех пор, пока не будет достигнут символ строки, не входящий в набор символов из *chars*. Аналогичная операция выполняется на завершающем конце. Например:10151016```python1017>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'1018>>> comment_string.strip('.#! ')1019'Section 3.2.1 Issue #32'1020```10211022#### `str.swapcase()`10231024Возвращает копию строки, в которой прописные буквы преобразованы в строчные и наоборот. Обратите внимание, что не обязательно верно, что `s.swapcase().swapcase() == s`.10251026#### `str.title()`10271028Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.10291030Например:10311032```python1033>>> 'Hello world'.title()1034'Hello World'1035```10361037Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:10381039```python1040>>> "they're bill's friends from the UK".title()1041"They'Re Bill'S Friends From The Uk"1042```10431044Обходной путь для апострофов можно построить с помощью регулярных выражений:10451046```python1047>>> import re1048>>> def titlecase(s):1049... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",1050... lambda mo: mo.group(0).capitalize(),1051... s)1052...1053>>> titlecase("they're bill's friends.")1054"They're Bill's Friends."1055```10561057#### `str.translate(table)`10581059Возвращает копию строки, в которой каждый символ преобразован с помощью заданной таблицы трансляции. Таблица должна быть объектом, поддерживающим индексацию по [`__getitem__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__getitem__), обычно это [отображение](https://python-all.ru/3.8/glossary.html#term-mapping) или [последовательность](https://python-all.ru/3.8/glossary.html#term-sequence). При индексации по коду Unicode (целое число) объект таблицы может выполнить одно из следующих действий: вернуть код Unicode или строку, чтобы сопоставить символ одному или нескольким другим символам; вернуть `None` для удаления символа из результирующей строки; или возбудить исключение [`LookupError`](https://python-all.ru/3.8/library/exceptions.html#LookupError), чтобы оставить символ без изменений.10601061Можно использовать [`str.maketrans()`](https://python-all.ru/3.8/library/stdtypes.html#str.maketrans) для создания таблицы трансляции на основе сопоставлений символов в различных форматах.10621063См. также модуль [`codecs`](https://python-all.ru/3.8/library/codecs.html#module-codecs) для более гибкого подхода к настраиваемым сопоставлениям символов.10641065#### `str.upper()`10661067Возвращает копию строки, в которой все буквенные символы [4](https://python-all.ru/3.8/library/stdtypes.html#id15) преобразованы в верхний регистр. Обратите внимание, что `s.upper().isupper()` может быть `False`, если `s` содержит символы без регистра или если категория Unicode результирующего символа не «Lu» (буква, верхний регистр), а, например, «Lt» (буква, заглавный регистр).10681069Алгоритм перевода в верхний регистр описан в разделе 3.13 стандарта Unicode.10701071#### `str.zfill(width)`10721073Возвращает копию строки, дополненную слева символами `'0'` (цифра ASCII) до длины *width*. Ведущий знак (`'+'`/`'-'`) обрабатывается так: заполнение вставляется *после* символа знака, а не перед ним. Исходная строка возвращается, если *width* меньше или равно `len(s)`.10741075Например:10761077```python1078>>> "42".zfill(5)1079'00042'1080>>> "-42".zfill(5)1081'-0042'1082```10831084### Форматирование строк в стиле `printf`10851086> **Примечание**1087>1088> Описанные здесь операции форматирования имеют ряд особенностей, которые приводят к распространённым ошибкам (например, некорректное отображение кортежей и словарей). Использование более новых [f-строк](https://python-all.ru/3.8/reference/lexical_analysis.html#f-strings), интерфейса [`str.format()`](https://python-all.ru/3.8/library/stdtypes.html#str.format) или [шаблонных строк](https://python-all.ru/3.8/library/string.html#template-strings) может помочь избежать этих ошибок. Каждая из этих альтернатив имеет свои компромиссы и преимущества в простоте, гибкости и/или расширяемости.10891090У строковых объектов есть одна уникальная встроенная операция: оператор `%` (modulo). Он также известен как оператор форматирования строк *formatting* или интерполяции *interpolation*. Для `format % values` (где *format* – строка), спецификации преобразования `%` в *format* заменяются на ноль или более элементов *values*. Результат аналогичен использованию `sprintf()` в языке C.10911092Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [5](https://python-all.ru/3.8/library/stdtypes.html#id16) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).10931094Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:109510961. Символ `'%'`, обозначающий начало спецификатора.10972. Ключ отображения (необязательно), состоящий из последовательности символов в круглых скобках (например, `(somename)`).10983. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.10994. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.11005. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.11016. Модификатор длины (необязательно).11027. Тип преобразования.11031104Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:11051106```python1107>>> print('%(language)s has %(number)03d quote types.' %1108... {'language': "Python", "number": 2})1109Python has 002 quote types.1110```11111112В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).11131114Символы флагов преобразования:11151116| Флаг | Значение |1117| --- | --- |1118| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |1119| `'0'` | Для числовых значений преобразование будет дополняться нулями. |1120| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |1121| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |1122| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |11231124Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, поскольку он не нужен для Python – так, например, `%ld` идентично `%d`.11251126Типы преобразования:11271128| Преобразование | Значение | Примечания |1129| --- | --- | --- |1130| `'d'` | Десятичное целое со знаком. | |1131| `'i'` | Десятичное целое со знаком. | |1132| `'o'` | Восьмеричное значение со знаком. | (1) |1133| `'u'` | Устаревший тип – идентичен `'d'`. | (6) |1134| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |1135| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |1136| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |1137| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |1138| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |1139| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |1140| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1141| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1142| `'c'` | Один символ (принимает целое число или строку из одного символа). | |1143| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.8/library/functions.html#repr)). | (5) |1144| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str)). | (5) |1145| `'a'` | Строка (преобразует любой объект Python с помощью [`ascii()`](https://python-all.ru/3.8/library/functions.html#ascii)). | (5) |1146| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. | |11471148Примечания:114911501. Альтернативная форма вставляет ведущий восьмеричный спецификатор (`'0o'`) перед первой цифрой.11512. Альтернативная форма вставляет перед первой цифрой ведущий `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`).11523. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.11531154 Точность определяет количество цифр после десятичной точки; по умолчанию – 6.11554. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.11561157 Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.11585. Если точность равна `N`, вывод усекается до `N` символов.11596. См. [**PEP 237**](https://python-all.ru/3.8/library/stdtypes.html).11601161Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.11621163Изменено в версии 3.1: `%f` преобразования для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.11641165## Типы бинарных последовательностей – [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes), [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray), [`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview)11661167Основные встроенные типы для работы с бинарными данными – [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray). Они поддерживаются [`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview), который использует [протокол буфера](https://python-all.ru/3.8/c-api/buffer.html#bufferobjects) для доступа к памяти других бинарных объектов без необходимости создания копии.11681169Модуль [`array`](https://python-all.ru/3.8/library/array.html#module-array) поддерживает эффективное хранение основных типов данных, таких как 32-битные целые числа и числа с плавающей точкой двойной точности IEEE754.11701171### Объекты bytes11721173Объекты bytes – это неизменяемые последовательности отдельных байтов. Поскольку многие основные бинарные протоколы основаны на текстовой кодировке ASCII, объекты bytes предоставляют несколько методов, которые действительны только при работе с данными, совместимыми с ASCII, и тесно связаны со строковыми объектами во многих других отношениях.11741175#### `class bytes([source[, encoding[, errors]]])`11761177Во-первых, синтаксис литералов bytes в основном такой же, как для строковых литералов, за исключением того, что добавляется префикс `b`:11781179- Одинарные кавычки: `b'still allows embedded "double" quotes'`1180- Двойные кавычки: `b"still allows embedded 'single' quotes"`.1181- Тройные кавычки: `b'''3 single quotes'''`, `b"""3 double quotes"""`11821183В литералах bytes допускаются только символы ASCII (независимо от объявленной кодировки исходного кода). Любые двоичные значения больше 127 должны вводиться в литералы bytes с помощью соответствующей управляющей последовательности.11841185Как и строковые литералы, литералы bytes также могут использовать префикс `r` для отключения обработки управляющих последовательностей. См. [Строковые литералы и литералы bytes](https://python-all.ru/3.8/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах литералов bytes, включая поддерживаемые управляющие последовательности.11861187Хотя литералы bytes и их представления основаны на тексте ASCII, объекты bytes на самом деле ведут себя как неизменяемые последовательности целых чисел, где каждое значение в последовательности ограничено так, что `0 <= x < 256` (попытки нарушить это ограничение вызовут [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError)). Это сделано намеренно, чтобы подчеркнуть, что хотя многие двоичные форматы содержат элементы на основе ASCII и могут быть полезно обработаны некоторыми текстовыми алгоритмами, в общем случае это не так для произвольных двоичных данных (слепое применение алгоритмов обработки текста к двоичным форматам, несовместимым с ASCII, обычно приводит к повреждению данных).11881189Помимо литералов, объекты bytes могут быть созданы несколькими другими способами:11901191- Объект bytes, заполненный нулями заданной длины: `bytes(10)`1192- Из итерируемого объекта целых чисел: `bytes(range(20))`1193- Копирование существующих двоичных данных через буферный протокол: `bytes(obj)`11941195См. также встроенную функцию [bytes](https://python-all.ru/3.8/library/functions.html#func-bytes).11961197Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа являются широко используемым форматом для описания двоичных данных. Соответственно, тип bytes имеет дополнительный метод класса для чтения данных в этом формате:11981199#### `classmethod fromhex(string)`12001201Этот метод класса [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) возвращает объект bytes, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробельные символы ASCII игнорируются.12021203```python1204>>> bytes.fromhex('2Ef0 F1f2 ')1205b'.\xf0\xf1\xf2'1206```12071208Изменено в версии 3.7: [`bytes.fromhex()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.fromhex) теперь пропускает все пробельные символы ASCII в строке, а не только пробелы.12091210Существует обратная функция преобразования для превращения объекта bytes в его шестнадцатеричное представление.12111212#### `hex([sep[, bytes_per_sep]])`12131214Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в экземпляре.12151216```python1217>>> b'\xf0\xf1\xf2'.hex()1218'f0f1f2'1219```12201221Для улучшения читаемости шестнадцатеричной строки можно указать параметр *sep* – односимвольный разделитель, добавляемый в вывод. По умолчанию разделитель ставится между каждым байтом. Второй необязательный параметр *bytes\_per\_sep* управляет шагом. Положительные значения задают позицию разделителя от правого края, отрицательные – от левого.12221223```python1224>>> value = b'\xf0\xf1\xf2'1225>>> value.hex('-')1226'f0-f1-f2'1227>>> value.hex('_', 2)1228'f0_f1f2'1229>>> b'UUDDLRLRAB'.hex(' ', -4)1230'55554444 4c524c52 4142'1231```12321233Новое в версии 3.5.12341235Изменено в версии 3.8: [`bytes.hex()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.hex) теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.12361237Поскольку объекты bytes являются последовательностями целых чисел (похожими на кортеж), для объекта bytes *b* `b[0]` будет целым числом, а `b[0:1]` – объектом bytes длины 1. (Это отличается от текстовых строк, где и индексация, и извлечение среза дают строку длины 1).12381239Представление объектов bytes использует литеральный формат (`b'...'`), поскольку он часто более полезен, чем, например, `bytes([46, 46, 46])`. Всегда можно преобразовать объект bytes в список целых чисел с помощью `list(b)`.12401241> **Примечание**1242>1243> Для пользователей Python 2.x: В серии Python 2.x допускался ряд неявных преобразований между 8-битными строками (ближайший аналог встроенного двоичного типа данных в 2.x) и строками Unicode. Это был обходной путь для обратной совместимости, учитывающий тот факт, что Python изначально поддерживал только 8-битный текст, а текст Unicode был добавлен позже. В Python 3.x эти неявные преобразования устранены – преобразования между 8-битными двоичными данными и текстом Unicode должны быть явными, а объекты bytes и string всегда сравниваются как неравные.12441245### Объекты Bytearray12461247Объекты [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) являются изменяемым аналогом объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) .12481249#### `class bytearray([source[, encoding[, errors]]])`12501251Для объектов bytearray не существует специального литерального синтаксиса, вместо этого они всегда создаются вызовом конструктора:12521253- Создание пустого экземпляра: `bytearray()`1254- Создание экземпляра, заполненного нулями заданной длины: `bytearray(10)`1255- Из итерируемого объекта целых чисел: `bytearray(range(20))`1256- Копирование существующих двоичных данных через буферный протокол: `bytearray(b'Hi!')`12571258Поскольку объекты bytearray являются изменяемыми, они поддерживают [изменяемые](https://python-all.ru/3.8/library/stdtypes.html#typesseq-mutable) операции последовательности в дополнение к общим операциям bytes и bytearray, описанным в [Операции с bytes и bytearray](https://python-all.ru/3.8/library/stdtypes.html#bytes-methods).12591260См. также встроенную функцию [bytearray](https://python-all.ru/3.8/library/functions.html#func-bytearray).12611262Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа часто используются для описания двоичных данных. Соответственно, тип bytearray имеет дополнительный метод класса для чтения данных в этом формате:12631264#### `classmethod fromhex(string)`12651266Этот метод класса [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) возвращает объект bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробельные символы ASCII игнорируются.12671268```python1269>>> bytearray.fromhex('2Ef0 F1f2 ')1270bytearray(b'.\xf0\xf1\xf2')1271```12721273Изменено в версии 3.7: [`bytearray.fromhex()`](https://python-all.ru/3.8/library/stdtypes.html#bytearray.fromhex) теперь пропускает все пробельные символы ASCII в строке, а не только пробелы.12741275Существует обратная функция преобразования для превращения объекта bytearray в его шестнадцатеричное представление.12761277#### `hex([sep[, bytes_per_sep]])`12781279Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в экземпляре.12801281```python1282>>> bytearray(b'\xf0\xf1\xf2').hex()1283'f0f1f2'1284```12851286Новое в версии 3.5.12871288Изменено в версии 3.8: Аналогично [`bytes.hex()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.hex), [`bytearray.hex()`](https://python-all.ru/3.8/library/stdtypes.html#bytearray.hex) теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.12891290Поскольку объекты bytearray являются последовательностями целых чисел (подобно списку), для объекта bytearray *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytearray длиной 1. (Это отличается от текстовых строк, где и индексирование, и срез возвращают строку длиной 1)12911292Представление объектов bytearray использует литеральный формат bytes (`bytearray(b'...')`), поскольку он часто более полезен, чем, например, `bytearray([46, 46, 46])`. Объект bytearray всегда можно преобразовать в список целых чисел с помощью `list(b)`.12931294### Операции с bytes и bytearray12951296Объекты bytes и bytearray поддерживают [общие](https://python-all.ru/3.8/library/stdtypes.html#typesseq-common) операции последовательности. Они взаимодействуют не только с операндами того же типа, но и с любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object). Благодаря такой гибкости их можно свободно смешивать в операциях, не вызывая ошибок. Однако тип возвращаемого результата может зависеть от порядка операндов.12971298> **Примечание**1299>1300> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать:1301>1302> ```python1303> a = "abc"1304> b = a.replace("a", "f")1305> ```1306>1307> и:1308>1309> ```python1310> a = b"abc"1311> b = a.replace(b"a", b"f")1312> ```13131314Некоторые операции с bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и поэтому их следует избегать при работе с произвольными двоичными данными. Эти ограничения описаны ниже.13151316> **Примечание**1317>1318> Использование этих операций на основе ASCII для манипуляции двоичными данными, которые не хранятся в формате на основе ASCII, может привести к повреждению данных.13191320Следующие методы объектов bytes и bytearray могут использоваться с произвольными двоичными данными.13211322#### `bytes.count(sub[, start[, end]])`13231324#### `bytearray.count(sub[, start[, end]])`13251326Возвращает количество непересекающихся вхождений подпоследовательности *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации среза.13271328Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.13291330Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.13311332#### `bytes.decode(encoding="utf-8", errors="strict")`13331334#### `bytearray.decode(encoding="utf-8", errors="strict")`13351336Возвращает строку, декодированную из переданных байтов. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* может быть задан для выбора другой схемы обработки ошибок. Значение по умолчанию для *errors* – `'strict'`, что означает, что ошибки кодирования вызывают исключение [`UnicodeError`](https://python-all.ru/3.8/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.8/library/codecs.html#codecs.register_error) (см. раздел [Обработчики ошибок](https://python-all.ru/3.8/library/codecs.html#error-handlers)). Список возможных кодировок приведён в разделе [Стандартные кодировки](https://python-all.ru/3.8/library/codecs.html#standard-encodings).13371338> **Примечание**1339>1340> Передача аргумента *encoding* в [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) позволяет декодировать любой [байтоподобный объект](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) напрямую, без необходимости создавать временный объект bytes или bytearray.13411342Изменено в версии 3.1: Добавлена поддержка именованных аргументов.13431344#### `bytes.endswith(suffix[, start[, end]])`13451346#### `bytearray.endswith(suffix[, start[, end]])`13471348Возвращает `True`, если двоичные данные оканчиваются указанным *suffix*, в противном случае возвращает `False`. *suffix* также может быть кортежем суффиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение прекращается на этой позиции.13491350Искомый суффикс (или суффиксы) может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).13511352#### `bytes.find(sub[, start[, end]])`13531354#### `bytearray.find(sub[, start[, end]])`13551356Возвращает наименьший индекс в данных, на котором найдена подпоследовательность *sub*, при условии, что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.13571358Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.13591360> **Примечание**1361>1362> Метод [`find()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.find) следует использовать только если нужно знать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.8/reference/expressions.html#in):1363>1364> ```python1365> >>> b'Py' in b'Python'1366> True1367> ```13681369Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.13701371#### `bytes.index(sub[, start[, end]])`13721373#### `bytearray.index(sub[, start[, end]])`13741375Как [`find()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.find), но возбуждает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если подпоследовательность не найдена.13761377Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.13781379Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.13801381#### `bytes.join(iterable)`13821383#### `bytearray.join(iterable)`13841385Возвращает объект bytes или bytearray, представляющий собой конкатенацию последовательностей двоичных данных из *iterable*. Исключение [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError) возникнет, если в *iterable* окажутся значения, не являющиеся [байтоподобными объектами](https://python-all.ru/3.8/glossary.html#term-bytes-like-object), включая объекты [`str`](https://python-all.ru/3.8/library/stdtypes.html#str). Разделителем между элементами служит содержимое объекта bytes или bytearray, предоставляющего этот метод.13861387#### `static bytes.maketrans(from, to)`13881389#### `static bytearray.maketrans(from, to)`13901391Этот статический метод возвращает таблицу перевода, пригодную для использования с [`bytes.translate()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* оба должны быть [байтоподобными объектами](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) и иметь одинаковую длину.13921393Новое в версии 3.1.13941395#### `bytes.partition(sep)`13961397#### `bytearray.partition(sep)`13981399Разделяет последовательность по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель (или его копию bytearray) и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий копию исходной последовательности, за которой следуют два пустых объекта bytes или bytearray.14001401Разделитель для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).14021403#### `bytes.replace(old, new[, count])`14041405#### `bytearray.replace(old, new[, count])`14061407Возвращает копию последовательности, в которой все вхождения подпоследовательности *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.14081409Искомая подпоследовательность и её замена могут быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).14101411> **Примечание**1412>1413> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.14141415#### `bytes.rfind(sub[, start[, end]])`14161417#### `bytearray.rfind(sub[, start[, end]])`14181419Возвращает наибольший индекс в последовательности, на котором найдена подпоследовательность *sub*, так что *sub* находится в пределах `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в записи среза. В случае отсутствия возвращает `-1`.14201421Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.14221423Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.14241425#### `bytes.rindex(sub[, start[, end]])`14261427#### `bytearray.rindex(sub[, start[, end]])`14281429Действует как [`rfind()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.rfind), но вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError), если подпоследовательность *sub* не найдена.14301431Подпоследовательность для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.14321433Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.14341435#### `bytes.rpartition(sep)`14361437#### `bytearray.rpartition(sep)`14381439Разделяет последовательность по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель (или его копию bytearray) и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий два пустых объекта bytes или bytearray, за которыми следует копия исходной последовательности.14401441Разделитель для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).14421443#### `bytes.startswith(prefix[, start[, end]])`14441445#### `bytearray.startswith(prefix[, start[, end]])`14461447Возвращает `True`, если двоичные данные начинаются с указанного *префикса*, иначе возвращает `False`. *Префикс* также может быть кортежем префиксов для поиска. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение останавливается на этой позиции.14481449Префикс(ы) для поиска может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).14501451#### `bytes.translate(table, /, delete=b'')`14521453#### `bytearray.translate(table, /, delete=b'')`14541455Возвращает копию объекта bytes или bytearray, из которой удалены все байты, встречающиеся в необязательном аргументе *delete*, а оставшиеся байты преобразованы через заданную таблицу перекодировки, которая должна быть объектом bytes длиной 256.14561457Для создания таблицы перекодировки можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.maketrans).14581459Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:14601461```python1462>>> b'read this short text'.translate(None, b'aeiou')1463b'rd ths shrt txt'1464```14651466Изменено в версии 3.6: *delete* теперь поддерживается как именованный аргумент.14671468Следующие методы объектов bytes и bytearray имеют поведение по умолчанию, предполагающее использование бинарных форматов, совместимых с ASCII, но их можно использовать с произвольными двоичными данными, передав соответствующие аргументы. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а вместо этого создают новые объекты.14691470#### `bytes.center(width[, fillbyte])`14711472#### `bytearray.center(width[, fillbyte])`14731474Возвращает копию объекта, выровненную по центру в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.14751476> **Примечание**1477>1478> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.14791480#### `bytes.ljust(width[, fillbyte])`14811482#### `bytearray.ljust(width[, fillbyte])`14831484Возвращает копию объекта, выровненную по левому краю в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.14851486> **Примечание**1487>1488> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.14891490#### `bytes.lstrip([chars])`14911492#### `bytearray.lstrip([chars])`14931494Возвращает копию последовательности с удалёнными указанными начальными байтами. Аргумент *chars* – это двоичная последовательность, задающая набор значений байтов для удаления; название связано с тем, что этот метод обычно используется с ASCII-символами. Если аргумент опущен или равен `None`, то *chars* по умолчанию удаляет ASCII-пробелы. Аргумент *chars* не является префиксом; скорее, удаляются все комбинации его значений:14951496```python1497>>> b' spacious '.lstrip()1498b'spacious '1499>>> b'www.example.com'.lstrip(b'cmowz.')1500b'example.com'1501```15021503Двоичная последовательность удаляемых байтов может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).15041505> **Примечание**1506>1507> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.15081509#### `bytes.rjust(width[, fillbyte])`15101511#### `bytearray.rjust(width[, fillbyte])`15121513Возвращает копию объекта, выровненную по правому краю в последовательности длины *width*. Заполнение выполняется с помощью указанного *fillbyte* (по умолчанию – пробел ASCII). Для объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.15141515> **Примечание**1516>1517> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.15181519#### `bytes.rsplit(sep=None, maxsplit=-1)`15201521#### `bytearray.rsplit(sep=None, maxsplit=-1)`15221523Разделяет двоичную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разделений, а именно *крайних справа*. Если *sep* не указан или равен `None`, любая подпоследовательность, состоящая только из пробельных символов ASCII, считается разделителем. За исключением разделения справа, [`rsplit()`](https://python-all.ru/3.8/library/stdtypes.html#bytearray.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.8/library/stdtypes.html#bytearray.split), который подробно описан ниже.15241525#### `bytes.rstrip([chars])`15261527#### `bytearray.rstrip([chars])`15281529Возвращает копию последовательности с удалёнными указанными конечными байтами. Аргумент *chars* – бинарная последовательность, задающая набор значений байтов для удаления; название связано с тем, что этот метод обычно используется с символами ASCII. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы ASCII. Аргумент *chars* не является суффиксом; скорее, удаляются все комбинации его значений:15301531```python1532>>> b' spacious '.rstrip()1533b' spacious'1534>>> b'mississippi'.rstrip(b'ipz')1535b'mississ'1536```15371538Двоичная последовательность удаляемых байтов может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).15391540> **Примечание**1541>1542> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.15431544#### `bytes.split(sep=None, maxsplit=-1)`15451546#### `bytearray.split(sep=None, maxsplit=-1)`15471548Разделяет двоичную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit* и он неотрицателен, то выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то ограничения на количество разбиений нет (выполняются все возможные разбиения).15491550Если *sep* указан, последовательные разделители не группируются и считаются разделяющими пустые подпоследовательности (например, `b'1,,2'.split(b',')` возвращает `[b'1', b'', b'2']`). Аргумент *sep* может состоять из многобайтовой последовательности (например, `b'1<>2<>3'.split(b'<>')` возвращает `[b'1', b'2', b'3']`). Разделение пустой последовательности с указанным разделителем возвращает `[b'']` или `[bytearray(b'')]` в зависимости от типа разделяемого объекта. Аргумент *sep* может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).15511552Например:15531554```python1555>>> b'1,2,3'.split(b',')1556[b'1', b'2', b'3']1557>>> b'1,2,3'.split(b',', maxsplit=1)1558[b'1', b'2,3']1559>>> b'1,2,,3,'.split(b',')1560[b'1', b'2', b'', b'3', b'']1561```15621563Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов ASCII считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если последовательность имеет начальные или завершающие пробелы. Следовательно, разбиение пустой последовательности или последовательности, состоящей только из пробельных символов ASCII, без указанного разделителя возвращает `[]`.15641565Например:15661567```python1568>>> b'1 2 3'.split()1569[b'1', b'2', b'3']1570>>> b'1 2 3'.split(maxsplit=1)1571[b'1', b'2 3']1572>>> b' 1 2 3 '.split()1573[b'1', b'2', b'3']1574```15751576#### `bytes.strip([chars])`15771578#### `bytearray.strip([chars])`15791580Возвращает копию последовательности с удалёнными указанными начальными и конечными байтами. Аргумент *chars* – бинарная последовательность, задающая набор значений байтов для удаления; название связано с тем, что этот метод обычно используется с символами ASCII. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы ASCII. Аргумент *chars* не является префиксом или суффиксом; напротив, удаляются все комбинации его значений:15811582```python1583>>> b' spacious '.strip()1584b'spacious'1585>>> b'www.example.com'.strip(b'cmowz.')1586b'example'1587```15881589Двоичная последовательность удаляемых байтов может быть любым [байтоподобным объектом](https://python-all.ru/3.8/glossary.html#term-bytes-like-object).15901591> **Примечание**1592>1593> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.15941595Следующие методы для объектов bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и не должны применяться к произвольным двоичным данным. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а создают новые объекты.15961597#### `bytes.capitalize()`15981599#### `bytearray.capitalize()`16001601Возвращает копию последовательности, где каждый байт интерпретируется как символ ASCII, первый байт преобразуется в верхний регистр, а остальные – в нижний. Не-ASCII байты передаются без изменений.16021603> **Примечание**1604>1605> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.16061607#### `bytes.expandtabs(tabsize=8)`16081609#### `bytearray.expandtabs(tabsize=8)`16101611Возвращает копию последовательности, в которой все символы табуляции ASCII заменяются одним или несколькими пробелами ASCII, в зависимости от текущей позиции столбца и заданного размера табуляции. Позиции табуляции находятся каждые *tabsize* байт (по умолчанию 8, что даёт позиции табуляции на столбцах 0, 8, 16 и так далее). Для расширения последовательности текущий столбец устанавливается в ноль, и последовательность просматривается побайтно. Если байт является символом табуляции ASCII (`b'\t'`), в результат вставляется один или несколько пробелов, пока текущий столбец не сравняется со следующей позицией табуляции. (Сам символ табуляции не копируется.) Если текущий байт является символом новой строки ASCII (`b'\n'`) или возврата каретки (`b'\r'`), он копируется, а текущий столбец сбрасывается в ноль. Любое другое значение байта копируется без изменений, а текущий столбец увеличивается на единицу независимо от того, как представляется значение байта при печати:16121613```python1614>>> b'01\t012\t0123\t01234'.expandtabs()1615b'01 012 0123 01234'1616>>> b'01\t012\t0123\t01234'.expandtabs(4)1617b'01 012 0123 01234'1618```16191620> **Примечание**1621>1622> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.16231624#### `bytes.isalnum()`16251626#### `bytearray.isalnum()`16271628Возвращает `True`, если все байты в последовательности являются буквенными символами ASCII или десятичными цифрами ASCII и последовательность непуста, иначе `False`. Буквенные символы ASCII – это значения байтов из диапазона `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Десятичные цифры ASCII – это значения байтов из диапазона `b'0123456789'`.16291630Например:16311632```python1633>>> b'ABCabc1'.isalnum()1634True1635>>> b'ABC abc1'.isalnum()1636False1637```16381639#### `bytes.isalpha()`16401641#### `bytearray.isalpha()`16421643Возвращает `True`, если все байты в последовательности являются буквенными символами ASCII и последовательность непуста, иначе `False`. Буквенные символы ASCII – это значения байтов из диапазона `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`.16441645Например:16461647```python1648>>> b'ABCabc'.isalpha()1649True1650>>> b'ABCabc1'.isalpha()1651False1652```16531654#### `bytes.isascii()`16551656#### `bytearray.isascii()`16571658Возвращает `True`, если последовательность пуста или все байты в последовательности являются ASCII, иначе `False`. Байты ASCII находятся в диапазоне 0-0x7F.16591660Добавлено в версии 3.7.16611662#### `bytes.isdigit()`16631664#### `bytearray.isdigit()`16651666Возвращает `True`, если все байты последовательности являются десятичными цифрами ASCII и последовательность не пуста, и `False` в противном случае. Десятичные цифры ASCII – это значения байтов из диапазона `b'0123456789'`.16671668Например:16691670```python1671>>> b'1234'.isdigit()1672True1673>>> b'1.23'.isdigit()1674False1675```16761677#### `bytes.islower()`16781679#### `bytearray.islower()`16801681Возвращает `True`, если в последовательности есть хотя бы один символ ASCII в нижнем регистре и нет символов ASCII в верхнем регистре, и `False` в противном случае.16821683Например:16841685```python1686>>> b'hello world'.islower()1687True1688>>> b'Hello world'.islower()1689False1690```16911692Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.16931694#### `bytes.isspace()`16951696#### `bytearray.isspace()`16971698Возвращает `True`, если все байты последовательности являются пробельными символами ASCII и последовательность не пуста, и `False` в противном случае. Пробельные символы ASCII – это значения байтов из диапазона `b' \t\n\r\x0b\f'` (пробел, табуляция, перевод строки, возврат каретки, вертикальная табуляция, перевод страницы).16991700#### `bytes.istitle()`17011702#### `bytearray.istitle()`17031704Возвращает `True`, если последовательность находится в регистре заголовка (titlecase) ASCII и не пуста, и `False` в противном случае. См. [`bytes.title()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.title) для подробностей об определении «titlecase».17051706Например:17071708```python1709>>> b'Hello World'.istitle()1710True1711>>> b'Hello world'.istitle()1712False1713```17141715#### `bytes.isupper()`17161717#### `bytearray.isupper()`17181719Возвращает `True`, если в последовательности есть хотя бы один алфавитный символ ASCII в верхнем регистре и нет символов ASCII в нижнем регистре, и `False` в противном случае.17201721Например:17221723```python1724>>> b'HELLO WORLD'.isupper()1725True1726>>> b'Hello world'.isupper()1727False1728```17291730Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.17311732#### `bytes.lower()`17331734#### `bytearray.lower()`17351736Возвращает копию последовательности, в которой все символы ASCII в верхнем регистре преобразованы в соответствующие символы нижнего регистра.17371738Например:17391740```python1741>>> b'Hello World'.lower()1742b'hello world'1743```17441745Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.17461747> **Примечание**1748>1749> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.17501751#### `bytes.splitlines(keepends=False)`17521753#### `bytearray.splitlines(keepends=False)`17541755Возвращает список строк в двоичной последовательности, разбивая по границам строк ASCII. Этот метод использует подход [универсального перевода строк](https://python-all.ru/3.8/glossary.html#term-universal-newlines) для разделения строк. Разрывы строк не включаются в итоговый список, если только *keepends* не задано и не равно true.17561757Например:17581759```python1760>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()1761[b'ab c', b'', b'de fg', b'kl']1762>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)1763[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']1764```17651766В отличие от [`split()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и концевой разрыв строки не приводит к появлению дополнительной строки:17671768```python1769>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')1770([b''], [b'Two lines', b''])1771>>> b"".splitlines(), b"One line\n".splitlines()1772([], [b'One line'])1773```17741775#### `bytes.swapcase()`17761777#### `bytearray.swapcase()`17781779Возвращает копию последовательности, в которой все символы ASCII в нижнем регистре преобразованы в соответствующие символы верхнего регистра и наоборот.17801781Например:17821783```python1784>>> b'Hello World'.swapcase()1785b'hELLO wORLD'1786```17871788Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.17891790В отличие от [`str.swapcase()`](https://python-all.ru/3.8/library/stdtypes.html#str.swapcase), для двоичных версий всегда выполняется `bin.swapcase().swapcase() == bin`. Преобразования регистра симметричны в ASCII, хотя это не всегда верно для произвольных кодовых точек Unicode.17911792> **Примечание**1793>1794> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.17951796#### `bytes.title()`17971798#### `bytearray.title()`17991800Возвращает версию двоичной последовательности, в которой каждое слово начинается с заглавной буквы ASCII, а остальные символы – строчные. Байтовые значения без регистра остаются без изменений.18011802Например:18031804```python1805>>> b'Hello world'.title()1806b'Hello World'1807```18081809Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Все остальные байтовые значения не имеют регистра.18101811Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:18121813```python1814>>> b"they're bill's friends from the UK".title()1815b"They'Re Bill'S Friends From The Uk"1816```18171818Обходной путь для апострофов можно построить с помощью регулярных выражений:18191820```python1821>>> import re1822>>> def titlecase(s):1823... return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",1824... lambda mo: mo.group(0)[0:1].upper() +1825... mo.group(0)[1:].lower(),1826... s)1827...1828>>> titlecase(b"they're bill's friends.")1829b"They're Bill's Friends."1830```18311832> **Примечание**1833>1834> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.18351836#### `bytes.upper()`18371838#### `bytearray.upper()`18391840Возвращает копию последовательности, в которой все строчные ASCII-символы преобразованы в соответствующие заглавные.18411842Например:18431844```python1845>>> b'Hello World'.upper()1846b'HELLO WORLD'1847```18481849Строчные ASCII-символы – это байтовые значения в диапазоне `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные ASCII-символы – это байтовые значения в диапазоне `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.18501851> **Примечание**1852>1853> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.18541855#### `bytes.zfill(width)`18561857#### `bytearray.zfill(width)`18581859Возвращает копию последовательности, дополненную слева цифрами `b'0'` ASCII, чтобы получить последовательность длины *width*. Ведущий знак (`b'+'`/ `b'-'`) обрабатывается путём вставки дополнения *после* знака, а не до него. Для объектов [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(seq)`.18601861Например:18621863```python1864>>> b"42".zfill(5)1865b'00042'1866>>> b"-42".zfill(5)1867b'-0042'1868```18691870> **Примечание**1871>1872> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.18731874### `printf`-стиль форматирования байтов18751876> **Примечание**1877>1878> Описанные здесь операции форматирования обладают рядом особенностей, которые приводят ко многим распространённым ошибкам (например, неправильное отображение кортежей и словарей). Если выводимое значение может быть кортежем или словарём, оберните его в кортеж.18791880Объекты bytes (`bytes`/`bytearray`) имеют одну уникальную встроенную операцию: оператор `%` (modulo). Он также известен как оператор *форматирования* или *интерполяции* байтов. Для выражения `format % values` (где *format* – это объект bytes) спецификации преобразования `%` в *format* заменяются на ноль или более элементов из *values*. Эффект аналогичен использованию `sprintf()` в языке C.18811882Если *format* требует один аргумент, *values* может быть одним объектом, не являющимся кортежем. [5](https://python-all.ru/3.8/library/stdtypes.html#id16) В противном случае *values* должен быть кортежем с точным числом элементов, указанным в форматном объекте bytes, или одним отображающим объектом (например, словарём).18831884Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:188518861. Символ `'%'`, обозначающий начало спецификатора.18872. Ключ отображения (необязательно), состоящий из последовательности символов в круглых скобках (например, `(somename)`).18883. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.18894. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.18905. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.18916. Модификатор длины (необязательно).18927. Тип преобразования.18931894Когда правый аргумент является словарём (или другим типом отображения), то форматы в объекте bytes *должны* включать ключ отображения в круглых скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:18951896```python1897>>> print(b'%(language)s has %(number)03d quote types.' %1898... {b'language': b"Python", b"number": 2})1899b'Python has 002 quote types.'1900```19011902В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).19031904Символы флагов преобразования:19051906| Флаг | Значение |1907| --- | --- |1908| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |1909| `'0'` | Для числовых значений преобразование будет дополняться нулями. |1910| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |1911| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |1912| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |19131914Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, поскольку он не нужен для Python – так, например, `%ld` идентично `%d`.19151916Типы преобразования:19171918| Преобразование | Значение | Примечания |1919| --- | --- | --- |1920| `'d'` | Десятичное целое со знаком. | |1921| `'i'` | Десятичное целое со знаком. | |1922| `'o'` | Восьмеричное значение со знаком. | (1) |1923| `'u'` | Устаревший тип – идентичен `'d'`. | (8) |1924| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |1925| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |1926| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |1927| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |1928| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |1929| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |1930| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1931| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1932| `'c'` | Один байт (принимает целое число или объект из одного байта). | |1933| `'b'` | Байты (любой объект, следующий [протоколу буфера](https://python-all.ru/3.8/c-api/buffer.html#bufferobjects) или имеющий [`__bytes__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__bytes__)). | (5) |1934| `'s'` | `'s'` – псевдоним для `'b'` и должен использоваться только в кодовых базах Python2/3. | (6) |1935| `'a'` | Байты (преобразует любой объект Python с помощью `repr(obj).encode('ascii','backslashreplace)`). | (5) |1936| `'r'` | `'r'` – псевдоним для `'a'` и должен использоваться только в кодовых базах Python2/3. | (7) |1937| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. | |19381939Примечания:194019411. Альтернативная форма вставляет ведущий восьмеричный спецификатор (`'0o'`) перед первой цифрой.19422. Альтернативная форма вставляет перед первой цифрой ведущий `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`).19433. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.19441945 Точность определяет количество цифр после десятичной точки; по умолчанию – 6.19464. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.19471948 Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.19495. Если точность равна `N`, вывод усекается до `N` символов.19506. `b'%s'` устарело, но не будет удалено в серии 3.x.19517. `b'%r'` устарело, но не будет удалено в серии 3.x.19528. См. [**PEP 237**](https://python-all.ru/3.8/library/stdtypes.html).19531954> **Примечание**1955>1956> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.19571958> **См. также**1959>1960> [**PEP 461**](https://python-all.ru/3.8/library/stdtypes.html) – добавление форматирования % для bytes и bytearray19611962Новое в версии 3.5.19631964### Представления памяти19651966Объекты [`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [протокол буфера](https://python-all.ru/3.8/c-api/buffer.html#bufferobjects), без копирования.19671968#### `class memoryview(obj)`19691970Создаёт [`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview), который ссылается на *obj*. *obj* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray).19711972[`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview) имеет понятие *элемента*, который является атомарной единицей памяти, обрабатываемой исходным объектом *obj*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) и [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray), элемент представляет собой один байт, но другие типы, такие как [`array.array`](https://python-all.ru/3.8/library/array.html#array.array), могут иметь большие элементы.19731974`len(view)` равна длине [`tolist`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.tolist). Если `view.ndim = 0`, длина равна 1. Если `view.ndim = 1`, длина равна количеству элементов в представлении. Для более высоких размерностей длина равна длине вложенного спискового представления представления. Атрибут [`itemsize`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.itemsize) даёт количество байт в одном элементе.19751976[`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview) поддерживает срезы и индексацию для доступа к своим данным. Одномерный срез приводит к подпредставлению:19771978```python1979>>> v = memoryview(b'abcefg')1980>>> v[1]1981981982>>> v[-1]19831031984>>> v[1:4]1985<memory at 0x7f3ddc9f4350>1986>>> bytes(v[1:4])1987b'bce'1988```19891990Если [`format`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.format) – один из собственных спецификаторов формата из модуля [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct), то также поддерживается индексация целым числом или кортежем целых чисел, которая возвращает отдельный *элемент* с правильным типом. Одномерные memoryview можно индексировать целым числом или кортежем из одного целого. Многомерные memoryview можно индексировать кортежами ровно из *ndim* целых чисел, где *ndim* – количество измерений. Нулевые memoryview можно индексировать пустым кортежем.19911992Вот пример с небайтовым форматом:19931994```python1995>>> import array1996>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])1997>>> m = memoryview(a)1998>>> m[0]1999-111111112000>>> m[-1]2001444444442002>>> m[::2].tolist()2003[-11111111, -33333333]2004```20052006Если базовый объект доступен для записи, memoryview поддерживает одномерное присваивание среза. Изменение размера не допускается:20072008```python2009>>> data = bytearray(b'abcefg')2010>>> v = memoryview(data)2011>>> v.readonly2012False2013>>> v[0] = ord(b'z')2014>>> data2015bytearray(b'zbcefg')2016>>> v[1:4] = b'123'2017>>> data2018bytearray(b'z123fg')2019>>> v[2:3] = b'spam'2020Traceback (most recent call last):2021 File "<stdin>", line 1, in <module>2022ValueError: memoryview assignment: lvalue and rvalue have different structures2023>>> v[2:6] = b'spam'2024>>> data2025bytearray(b'z1spam')2026```20272028Одномерные memoryview хешируемых (только для чтения) типов с форматами ‘B’, ‘b’ или ‘c’ также являются хешируемыми. Хеш определяется как `hash(m) == hash(m.tobytes())`:20292030```python2031>>> v = memoryview(b'abcefg')2032>>> hash(v) == hash(b'abcefg')2033True2034>>> hash(v[2:4]) == hash(b'ce')2035True2036>>> hash(v[::-2]) == hash(b'abcefg'[::-2])2037True2038```20392040Изменено в версии 3.3: Одномерные memoryview теперь можно нарезать. Одномерные memoryview с форматами ‘B’, ‘b’ или ‘c’ теперь являются хешируемыми.20412042Изменено в версии 3.4: memoryview теперь автоматически регистрируется с помощью [`collections.abc.Sequence`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Sequence)20432044Изменено в версии 3.5: memoryview теперь можно индексировать кортежем целых чисел.20452046[`memoryview`](https://python-all.ru/3.8/library/stdtypes.html#memoryview) имеет несколько методов:20472048#### `__eq__(exporter)`20492050Memoryview и [**PEP 3118**](https://python-all.ru/3.8/library/stdtypes.html) экспортёр равны, если их формы эквивалентны и если все соответствующие значения равны при интерпретации кодов формата операндов с использованием синтаксиса [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct).20512052Для подмножества строк формата [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct), поддерживаемых в настоящее время [`tolist()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.tolist), `v` и `w` равны, если `v.tolist() == w.tolist()`:20532054```python2055>>> import array2056>>> a = array.array('I', [1, 2, 3, 4, 5])2057>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])2058>>> c = array.array('b', [5, 3, 1])2059>>> x = memoryview(a)2060>>> y = memoryview(b)2061>>> x == a == y == b2062True2063>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()2064True2065>>> z = y[::-2]2066>>> z == c2067True2068>>> z.tolist() == c.tolist()2069True2070```20712072Если какая-либо строка формата не поддерживается модулем [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct), то объекты всегда будут сравниваться как неравные (даже если строки формата и содержимое буфера одинаковы):20732074```python2075>>> from ctypes import BigEndianStructure, c_long2076>>> class BEPoint(BigEndianStructure):2077... _fields_ = [("x", c_long), ("y", c_long)]2078...2079>>> point = BEPoint(100, 200)2080>>> a = memoryview(point)2081>>> b = memoryview(point)2082>>> a == point2083False2084>>> a == b2085False2086```20872088Обратите внимание, что, как и для чисел с плавающей точкой, `v is w` *не* подразумевает `v == w` для объектов memoryview.20892090Изменено в версии 3.3: В предыдущих версиях сравнивалась необработанная память без учёта формата элемента и логической структуры массива.20912092#### `tobytes(order=None)`20932094Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes) для memoryview.20952096```python2097>>> m = memoryview(b"abc")2098>>> m.tobytes()2099b'abc'2100>>> bytes(m)2101b'abc'2102```21032104Для несплошных массивов результат равен плоскому списку, представляющему данные, со всеми элементами, преобразованными в байты. [`tobytes()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.tobytes) поддерживает все строки формата, включая те, которые не соответствуют синтаксису модуля [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct).21052106Новое в версии 3.8: *order* может быть {‘C’, ‘F’, ‘A’}. Когда *order* равен ‘C’ или ‘F’, данные исходного массива преобразуются в порядок C или Fortran. Для смежных представлений ‘A’ возвращает точную копию физической памяти. В частности, порядок Fortran в памяти сохраняется. Для несмежных представлений данные сначала преобразуются в порядок C. *order=None* эквивалентно *order=’C’*.21072108#### `hex([sep[, bytes_per_sep]])`21092110Возвращает строковый объект, содержащий две шестнадцатеричные цифры для каждого байта в буфере.21112112```python2113>>> m = memoryview(b"abc")2114>>> m.hex()2115'616263'2116```21172118Новое в версии 3.5.21192120Изменено в версии 3.8: Аналогично [`bytes.hex()`](https://python-all.ru/3.8/library/stdtypes.html#bytes.hex), [`memoryview.hex()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.hex) теперь поддерживает необязательные параметры *sep* и *bytes\_per\_sep* для вставки разделителей между байтами в шестнадцатеричном выводе.21212122#### `tolist()`21232124Возвращает данные в буфере в виде списка элементов.21252126```python2127>>> memoryview(b'abc').tolist()2128[97, 98, 99]2129>>> import array2130>>> a = array.array('d', [1.1, 2.2, 3.3])2131>>> m = memoryview(a)2132>>> m.tolist()2133[1.1, 2.2, 3.3]2134```21352136Изменено в версии 3.3: [`tolist()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.tolist) теперь поддерживает все односимвольные нативные форматы в синтаксисе модуля [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct), а также многомерные представления.21372138#### `toreadonly()`21392140Возвращает версию объекта memoryview, доступную только для чтения. Исходный объект memoryview остаётся неизменным.21412142```python2143>>> m = memoryview(bytearray(b'abc'))2144>>> mm = m.toreadonly()2145>>> mm.tolist()2146[89, 98, 99]2147>>> mm[0] = 422148Traceback (most recent call last):2149 File "<stdin>", line 1, in <module>2150TypeError: cannot modify read-only memory2151>>> m[0] = 432152>>> mm.tolist()2153[43, 98, 99]2154```21552156Новое в версии 3.8.21572158#### `release()`21592160Освобождает буфер, предоставляемый объектом memoryview. Многие объекты выполняют специальные действия, когда на них удерживается представление (например, [`bytearray`](https://python-all.ru/3.8/library/stdtypes.html#bytearray) временно запрещает изменение размера); поэтому вызов release() удобен для снятия этих ограничений (и освобождения любых зависших ресурсов) как можно скорее.21612162После вызова этого метода любая дальнейшая операция над представлением вызывает [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError) (за исключением самого [`release()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.release), который может быть вызван несколько раз):21632164```python2165>>> m = memoryview(b'abc')2166>>> m.release()2167>>> m[0]2168Traceback (most recent call last):2169 File "<stdin>", line 1, in <module>2170ValueError: operation forbidden on released memoryview object2171```21722173Протокол управления контекстом может использоваться для аналогичного эффекта с помощью оператора `with`:21742175```python2176>>> with memoryview(b'abc') as m:2177... m[0]2178...2179972180>>> m[0]2181Traceback (most recent call last):2182 File "<stdin>", line 1, in <module>2183ValueError: operation forbidden on released memoryview object2184```21852186Новое в версии 3.2.21872188#### `cast(format[, shape])`21892190Преобразует memoryview в новый формат или форму. *shape* по умолчанию равен `[byte_length//new_itemsize]`, что означает, что результирующее представление будет одномерным. Возвращаемое значение – новый memoryview, но сам буфер не копируется. Поддерживаемые преобразования: 1D -\> C-[contiguous](https://python-all.ru/3.8/glossary.html#term-contiguous) и C-contiguous -\> 1D.21912192Целевой формат ограничен одноэлементным нативным форматом в синтаксисе [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct). Один из форматов должен быть байтовым форматом (‘B’, ‘b’ или ‘c’). Длина результата в байтах должна совпадать с исходной длиной.21932194Преобразование 1D/long в 1D/unsigned bytes:21952196```python2197>>> import array2198>>> a = array.array('l', [1,2,3])2199>>> x = memoryview(a)2200>>> x.format2201'l'2202>>> x.itemsize220382204>>> len(x)220532206>>> x.nbytes2207242208>>> y = x.cast('B')2209>>> y.format2210'B'2211>>> y.itemsize221212213>>> len(y)2214242215>>> y.nbytes2216242217```22182219Преобразование 1D/unsigned bytes в 1D/char:22202221```python2222>>> b = bytearray(b'zyz')2223>>> x = memoryview(b)2224>>> x[0] = b'a'2225Traceback (most recent call last):2226 File "<stdin>", line 1, in <module>2227ValueError: memoryview: invalid value for format "B"2228>>> y = x.cast('c')2229>>> y[0] = b'a'2230>>> b2231bytearray(b'ayz')2232```22332234Преобразование 1D/bytes в 3D/ints в 1D/signed char:22352236```python2237>>> import struct2238>>> buf = struct.pack("i"*12, *list(range(12)))2239>>> x = memoryview(buf)2240>>> y = x.cast('i', shape=[2,2,3])2241>>> y.tolist()2242[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]2243>>> y.format2244'i'2245>>> y.itemsize224642247>>> len(y)224822249>>> y.nbytes2250482251>>> z = y.cast('b')2252>>> z.format2253'b'2254>>> z.itemsize225512256>>> len(z)2257482258>>> z.nbytes2259482260```22612262Преобразование 1D/unsigned long в 2D/unsigned long:22632264```python2265>>> buf = struct.pack("L"*6, *list(range(6)))2266>>> x = memoryview(buf)2267>>> y = x.cast('L', shape=[2,3])2268>>> len(y)226922270>>> y.nbytes2271482272>>> y.tolist()2273[[0, 1, 2], [3, 4, 5]]2274```22752276Новое в версии 3.3.22772278Изменено в версии 3.5: Исходный формат больше не ограничен при преобразовании в байтовое представление.22792280Также доступно несколько атрибутов только для чтения:22812282#### `obj`22832284Базовый объект memoryview:22852286```python2287>>> b = bytearray(b'xyz')2288>>> m = memoryview(b)2289>>> m.obj is b2290True2291```22922293Новое в версии 3.3.22942295#### `nbytes`22962297`nbytes == product(shape) * itemsize == len(m.tobytes())`. Это объём в байтах, который массив занимал бы в непрерывном представлении. Он не обязательно равен `len(m)`:22982299```python2300>>> import array2301>>> a = array.array('i', [1,2,3,4,5])2302>>> m = memoryview(a)2303>>> len(m)230452305>>> m.nbytes2306202307>>> y = m[::2]2308>>> len(y)230932310>>> y.nbytes2311122312>>> len(y.tobytes())2313122314```23152316Многомерные массивы:23172318```python2319>>> import struct2320>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])2321>>> x = memoryview(buf)2322>>> y = x.cast('d', shape=[3,4])2323>>> y.tolist()2324[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]2325>>> len(y)232632327>>> y.nbytes2328962329```23302331Новое в версии 3.3.23322333#### `readonly`23342335Логическое значение bool, указывающее, доступна ли память только для чтения.23362337#### `format`23382339Строка, содержащая формат (в стиле модуля [`struct`](https://python-all.ru/3.8/library/struct.html#module-struct)) для каждого элемента в представлении. Memoryview может быть создан из экспортёров с произвольными строками формата, но некоторые методы (например, [`tolist()`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.tolist)) ограничены нативными одноэлементными форматами.23402341Изменено в версии 3.3: формат `'B'` теперь обрабатывается в соответствии с синтаксисом модуля struct. Это означает, что `memoryview(b'abc')[0] == b'abc'[0] == 97`.23422343#### `itemsize`23442345Размер в байтах каждого элемента memoryview:23462347```python2348>>> import array, struct2349>>> m = memoryview(array.array('H', [32000, 32001, 32002]))2350>>> m.itemsize235122352>>> m[0]2353320002354>>> struct.calcsize('H') == m.itemsize2355True2356```23572358#### `ndim`23592360Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.23612362#### `shape`23632364Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.ndim), задающий форму памяти как N-мерного массива.23652366Изменено в версии 3.3: пустой кортеж вместо `None`, когда ndim = 0.23672368#### `strides`23692370Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.8/library/stdtypes.html#memoryview.ndim), задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.23712372Изменено в версии 3.3: пустой кортеж вместо `None`, когда ndim = 0.23732374#### `suboffsets`23752376Используется внутри для массивов в стиле PIL. Значение носит только информационный характер.23772378#### `c_contiguous`23792380Логическое значение (bool), указывающее, является ли память C-[непрерывной](https://python-all.ru/3.8/glossary.html#term-contiguous).23812382Новое в версии 3.3.23832384#### `f_contiguous`23852386Логическое значение (bool), указывающее, является ли память [непрерывной](https://python-all.ru/3.8/glossary.html#term-contiguous) по Фортрану.23872388Новое в версии 3.3.23892390#### `contiguous`23912392Логическое значение (bool), указывающее, является ли память [непрерывной](https://python-all.ru/3.8/glossary.html#term-contiguous).23932394Новое в версии 3.3.23952396## Типы множеств – [`set`](https://python-all.ru/3.8/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset)23972398Объект *set* – это неупорядоченная коллекция уникальных [хэшируемых](https://python-all.ru/3.8/glossary.html#term-hashable) объектов. Обычно используется для проверки принадлежности, удаления дубликатов из последовательности и выполнения математических операций, таких как пересечение, объединение, разность и симметрическая разность. (О других контейнерах см. встроенные классы [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.8/library/stdtypes.html#list) и [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple), а также модуль [`collections`](https://python-all.ru/3.8/library/collections.html#module-collections).)23992400Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множество не запоминает положение элементов или порядок вставки. Поэтому множества не поддерживают индексацию, срезы и другое поведение, свойственное последовательностям.24012402В Python есть два встроенных типа множеств: [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset). Тип [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) изменяемый – его содержимое можно менять с помощью методов вроде `add()` и `remove()`. Поскольку он изменяемый, у него нет хеш-значения, поэтому его нельзя использовать ни в качестве ключа словаря, ни как элемент другого множества. Тип [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset) неизменяемый и [хешируемый](https://python-all.ru/3.8/glossary.html#term-hashable) – его содержимое нельзя изменить после создания; соответственно, его можно использовать как ключ словаря или как элемент другого множества.24032404Непустые множества (кроме frozenset) можно создать, поместив список элементов, разделённый запятыми, в фигурные скобки, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.8/library/stdtypes.html#set).24052406Конструкторы обоих классов работают одинаково:24072408#### `class set([iterable])`24092410#### `class frozenset([iterable])`24112412Возвращает новый объект set или frozenset, элементы которого берутся из *iterable*. Элементы множества должны быть [хэшируемыми](https://python-all.ru/3.8/glossary.html#term-hashable). Чтобы представлять множества множеств, внутренние множества должны быть [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset) объектами. Если *iterable* не указан, возвращается новое пустое множество.24132414Множества можно создать несколькими способами:24152416- Используйте разделённый запятыми список элементов в фигурных скобках: `{'jack', 'sjoerd'}`2417- Используйте абстракцию множества: `{c for c in 'abracadabra' if c not in 'abc'}`2418- Используйте конструктор типа: `set()`, `set('foobar')`, `set(['a', 'b', 'foo'])`24192420Экземпляры [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset) предоставляют следующие операции:24212422#### `len(s)`24232424Возвращает количество элементов в множестве *s* (мощность *s*).24252426#### `x in s`24272428Проверяет принадлежность *x* множеству *s*.24292430#### `x not in s`24312432Проверяет отсутствие *x* в множестве *s*.24332434#### `isdisjoint(other)`24352436Возвращает `True`, если у множества нет общих элементов с *other*. Множества не пересекаются тогда и только тогда, когда их пересечение – пустое множество.24372438#### `issubset(other)`24392440#### `set <= other`24412442Проверяет, принадлежит ли каждый элемент множества множеству *other*.24432444#### `set < other`24452446Проверяет, является ли множество строгим подмножеством *other*, то есть `set <= other and set != other`.24472448#### `issuperset(other)`24492450#### `set >= other`24512452Проверяет, принадлежит ли каждый элемент *other* множеству.24532454#### `set > other`24552456Проверяет, является ли множество строгим надмножеством *other*, то есть `set >= other and set != other`.24572458#### `union(*others)`24592460#### `set | other | ...`24612462Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.24632464#### `intersection(*others)`24652466#### `set & other & ...`24672468Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.24692470#### `difference(*others)`24712472#### `set - other - ...`24732474Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.24752476#### `symmetric_difference(other)`24772478#### `set ^ other`24792480Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в *other*, но не в обоих.24812482#### `copy()`24832484Возвращает поверхностную копию множества.24852486Замечание: версии методов [`union()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.union), [`intersection()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.intersection), [`difference()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.difference), [`symmetric_difference()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.symmetric_difference), [`issubset()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.issubset) и [`issuperset()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.issuperset) без операторов принимают любой итерируемый объект в качестве аргумента. В отличие от них, их операторные аналоги требуют, чтобы аргументы были множествами. Это исключает подверженные ошибкам конструкции вроде `set('abc') & 'cbs'` в пользу более читаемой `set('abc').intersection('cbs')`.24872488И [`set`](https://python-all.ru/3.8/library/stdtypes.html#set), и [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset) поддерживают сравнение множеств. Два множества равны тогда и только тогда, когда каждый элемент одного содержится в другом (каждое является подмножеством другого). Множество меньше другого тогда и только тогда, когда первое является собственным подмножеством второго (является подмножеством, но не равным). Множество больше другого тогда и только тогда, когда первое является собственным надмножеством второго (является надмножеством, но не равным).24892490Экземпляры [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) сравниваются с экземплярами [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset) на основе их элементов. Например, `set('abc') == frozenset('abc')` возвращает `True`, и то же самое делает `set('abc') in set([frozenset('abc')])`.24912492Сравнения на подмножество и равенство не обобщаются до функции полного упорядочения. Например, любые два непустых непересекающихся множества не равны и не являются подмножествами друг друга, поэтому *все* из следующих возвращают `False`: `a<b`, `a==b` или `a>b`.24932494Поскольку множества определяют лишь частичное упорядочение (отношения подмножеств), результат метода [`list.sort()`](https://python-all.ru/3.8/library/stdtypes.html#list.sort) для списков множеств не определён.24952496Элементы множества, как и ключи словаря, должны быть [хэшируемыми](https://python-all.ru/3.8/glossary.html#term-hashable).24972498Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset).24992500В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.8/library/stdtypes.html#set), которые не применимы к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.8/library/stdtypes.html#frozenset):25012502#### `update(*others)`25032504#### `set |= other | ...`25052506Обновляет множество, добавляя элементы из всех других.25072508#### `intersection_update(*others)`25092510#### `set &= other & ...`25112512Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.25132514#### `difference_update(*others)`25152516#### `set -= other | ...`25172518Обновляет множество, удаляя элементы, найденные в других.25192520#### `symmetric_difference_update(other)`25212522#### `set ^= other`25232524Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.25252526#### `add(elem)`25272528Добавляет элемент *elem* в множество.25292530#### `remove(elem)`25312532Удаляет элемент *elem* из множества. Вызывает [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError), если *elem* отсутствует в множестве.25332534#### `discard(elem)`25352536Удаляет элемент *elem* из множества, если он присутствует.25372538#### `pop()`25392540Удаляет и возвращает произвольный элемент множества. Вызывает [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError), если множество пусто.25412542#### `clear()`25432544Удаляет все элементы из множества.25452546Обратите внимание: не-операторные версии методов [`update()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.update), [`intersection_update()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.intersection_update), [`difference_update()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.symmetric_difference_update) принимают любой итерируемый объект в качестве аргумента.25472548Примечание: аргумент *elem* для методов [`__contains__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.remove) и [`discard()`](https://python-all.ru/3.8/library/stdtypes.html#frozenset.discard) может быть множеством. Для поддержки поиска эквивалентного замороженного множества создается временное множество из *elem*.25492550## Типы отображений – [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict)25512552Объект [отображения](https://python-all.ru/3.8/glossary.html#term-mapping) сопоставляет [хэшируемые](https://python-all.ru/3.8/glossary.html#term-hashable) значения с произвольными объектами. Отображения – изменяемые объекты. В настоящее время существует только один стандартный тип отображения – *словарь*. (О других контейнерах см. встроенные классы [`list`](https://python-all.ru/3.8/library/stdtypes.html#list), [`set`](https://python-all.ru/3.8/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple), а также модуль [`collections`](https://python-all.ru/3.8/library/collections.html#module-collections).)25532554Ключи словаря могут быть *почти* любыми значениями. Значения, которые не являются [хэшируемыми](https://python-all.ru/3.8/glossary.html#term-hashable), то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, `1` и `1.0`), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)25552556Словари можно создать, поместив разделённый запятыми список пар `key: value` в фигурные скобки, например: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`, либо с помощью конструктора [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict).25572558#### `class dict(**kwarg)`25592560#### `class dict(mapping, **kwarg)`25612562#### `class dict(iterable, **kwarg)`25632564Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.25652566Словари могут быть созданы несколькими способами:25672568- Используйте разделённый запятыми список пар `key: value` в фигурных скобках: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`2569- Используйте словарное включение: `{}`, `{x: x ** 2 for x in range(10)}`2570- Используйте конструктор типа: `dict()`, `dict([('foo', 100), ('bar', 200)])`, `dict(foo=100, bar=200)`25712572Если позиционный аргумент не указан, создаётся пустой словарь. Если позиционный аргумент указан и является объектом отображения (mapping), создаётся словарь с теми же парами ключ-значение, что и у объекта отображения. В противном случае позиционный аргумент должен быть [итерируемым объектом](https://python-all.ru/3.8/glossary.html#term-iterable). Каждый элемент итерируемого объекта сам должен быть итерируемым объектом, содержащим ровно два объекта. Первый объект каждого элемента становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.25732574Если переданы именованные аргументы, они и их значения добавляются в словарь, созданный из позиционного аргумента. Если добавляемый ключ уже присутствует, значение из именованного аргумента заменяет значение из позиционного аргумента.25752576В качестве иллюстрации следующие примеры возвращают словарь, равный `{"one": 1, "two": 2, "three": 3}`:25772578```python2579>>> a = dict(one=1, two=2, three=3)2580>>> b = {'one': 1, 'two': 2, 'three': 3}2581>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))2582>>> d = dict([('two', 2), ('one', 1), ('three', 3)])2583>>> e = dict({'three': 3, 'one': 1, 'two': 2})2584>>> a == b == c == d == e2585True2586```25872588Передача именованных аргументов, как в первом примере, работает только для ключей, являющихся допустимыми идентификаторами Python. В противном случае можно использовать любые допустимые ключи.25892590Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):25912592#### `list(d)`25932594Возвращает список всех ключей, используемых в словаре *d*.25952596#### `len(d)`25972598Возвращает количество элементов в словаре *d*.25992600#### `d[key]`26012602Возвращает элемент словаря *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError), если *key* отсутствует в отображении.26032604Если подкласс dict определяет метод [`__missing__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__missing__), а *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает результат вызова `__missing__(key)`. Никакие другие операции или методы не вызывают [`__missing__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__missing__). Если [`__missing__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__missing__) не определён, возбуждается [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError). [`__missing__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__missing__) должен быть методом; он не может быть переменной экземпляра:26052606```python2607>>> class Counter(dict):2608... def __missing__(self, key):2609... return 02610>>> c = Counter()2611>>> c['red']261202613>>> c['red'] += 12614>>> c['red']261512616```26172618В примере выше показана часть реализации [`collections.Counter`](https://python-all.ru/3.8/library/collections.html#collections.Counter). Для [`collections.defaultdict`](https://python-all.ru/3.8/library/collections.html#collections.defaultdict) используется другой метод `__missing__`.26192620#### `d[key] = value`26212622Устанавливает `d[key]` в значение *value*.26232624#### `del d[key]`26252626Удаляет `d[key]` из *d*. Вызывает [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError), если *key* отсутствует в отображении.26272628#### `key in d`26292630Возвращает `True`, если *d* содержит ключ *key*, иначе `False`.26312632#### `key not in d`26332634Эквивалентно `not key in d`.26352636#### `iter(d)`26372638Возвращает итератор по ключам словаря. Это краткая форма записи для `iter(d.keys())`.26392640#### `clear()`26412642Удаляет все элементы из словаря.26432644#### `copy()`26452646Возвращает поверхностную копию словаря.26472648#### `classmethod fromkeys(iterable[, value])`26492650Создаёт новый словарь с ключами из *iterable* и значениями, установленными в *value*.26512652[`fromkeys()`](https://python-all.ru/3.8/library/stdtypes.html#dict.fromkeys) – это метод класса, возвращающий новый словарь. *value* по умолчанию равен `None`. Все значения ссылаются на один и тот же экземпляр, поэтому обычно не имеет смысла делать *value* изменяемым объектом, например пустым списком. Чтобы получить разные значения, используйте вместо этого [dict comprehension](https://python-all.ru/3.8/reference/expressions.html#dict).26532654#### `get(key[, default])`26552656Возвращает значение для *key*, если *key* присутствует в словаре, иначе *default*. Если *default* не указан, по умолчанию принимается `None`, поэтому этот метод никогда не вызывает исключение [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError).26572658#### `items()`26592660Возвращает новое представление элементов словаря (пары `(key, value)`). См. [документацию по объектам-представлениям](https://python-all.ru/3.8/library/stdtypes.html#dict-views).26612662#### `keys()`26632664Возвращает новое представление ключей словаря. См. [документацию по объектам-представлениям](https://python-all.ru/3.8/library/stdtypes.html#dict-views).26652666#### `pop(key[, default])`26672668Если *key* присутствует в словаре, удаляет его и возвращает значение, иначе возвращает *default*. Если *default* не указан и *key* отсутствует в словаре, возбуждается [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError).26692670#### `popitem()`26712672Удаляет и возвращает пару `(key, value)` из словаря. Пары возвращаются в порядке LIFO.26732674[`popitem()`](https://python-all.ru/3.8/library/stdtypes.html#dict.popitem) полезен для разрушающего обхода словаря, как часто используется в алгоритмах над множествами. Если словарь пуст, вызов [`popitem()`](https://python-all.ru/3.8/library/stdtypes.html#dict.popitem) вызывает исключение [`KeyError`](https://python-all.ru/3.8/library/exceptions.html#KeyError).26752676Изменено в версии 3.7: Теперь гарантируется порядок LIFO. В предыдущих версиях [`popitem()`](https://python-all.ru/3.8/library/stdtypes.html#dict.popitem) мог вернуть произвольную пару ключ/значение.26772678#### `reversed(d)`26792680Возвращает обратный итератор по ключам словаря. Это сокращение для `reversed(d.keys())`.26812682Новое в версии 3.8.26832684#### `setdefault(key[, default])`26852686Если *key* есть в словаре, возвращает его значение. Если нет, вставляет *key* со значением *default* и возвращает *default*. *default* по умолчанию равен `None`.26872688#### `update([other])`26892690Обновляет словарь парами ключ/значение из *other*, перезаписывая существующие ключи. Возвращает `None`.26912692[`update()`](https://python-all.ru/3.8/library/stdtypes.html#dict.update) принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (в виде кортежей или других итерируемых объектов длиной два). Если указаны именованные аргументы, словарь затем обновляется этими парами ключ/значение: `d.update(red=1, blue=2)`.26932694#### `values()`26952696Возвращает новое представление (view) значений словаря. См. [документацию по объектам-представлениям](https://python-all.ru/3.8/library/stdtypes.html#dict-views).26972698Сравнение на равенство между двумя представлениями `dict.values()` всегда возвращает `False`. Это также относится к сравнению `dict.values()` с самим собой:26992700```python2701>>> d = {'a': 1}2702>>> d.values() == d.values()2703False2704```27052706Словари равны тогда и только тогда, когда они содержат одни и те же пары `(key, value)` (независимо от порядка). Операции сравнения порядка (‘\<’, ‘\<=’, ‘\>=’, ‘\>’) вызывают [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError).27072708Словари сохраняют порядок вставки. Обратите внимание, что обновление ключа не влияет на порядок. Ключи, добавленные после удаления, вставляются в конец.27092710```python2711>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}2712>>> d2713{'one': 1, 'two': 2, 'three': 3, 'four': 4}2714>>> list(d)2715['one', 'two', 'three', 'four']2716>>> list(d.values())2717[1, 2, 3, 4]2718>>> d["one"] = 422719>>> d2720{'one': 42, 'two': 2, 'three': 3, 'four': 4}2721>>> del d["two"]2722>>> d["two"] = None2723>>> d2724{'one': 42, 'three': 3, 'four': 4, 'two': None}2725```27262727Изменено в версии 3.7: Порядок словарей гарантированно соответствует порядку вставки. Это поведение было деталью реализации CPython начиная с версии 3.6.27282729Словари и их представления обратимы.27302731```python2732>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}2733>>> d2734{'one': 1, 'two': 2, 'three': 3, 'four': 4}2735>>> list(reversed(d))2736['four', 'three', 'two', 'one']2737>>> list(reversed(d.values()))2738[4, 3, 2, 1]2739>>> list(reversed(d.items()))2740[('four', 4), ('three', 3), ('two', 2), ('one', 1)]2741```27422743Изменено в версии 3.8: Теперь словари обратимы.27442745> **См. также**2746>2747> [`types.MappingProxyType`](https://python-all.ru/3.8/library/types.html#types.MappingProxyType) можно использовать для создания представления только для чтения для [`dict`](https://python-all.ru/3.8/library/stdtypes.html#dict).27482749### Объекты представления словаря27502751Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.8/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.8/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.8/library/stdtypes.html#dict.items), являются *объектами-представлениями*. Они предоставляют динамическое представление записей словаря, то есть при изменении словаря представление отражает эти изменения.27522753Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:27542755#### `len(dictview)`27562757Возвращает количество записей в словаре.27582759#### `iter(dictview)`27602761Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) в словаре.27622763Ключи и значения обходятся в порядке вставки. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.8/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать такой же список – `pairs = [(v, k) for (k, v) in d.items()]`.27642765Обход представлений во время добавления или удаления записей из словаря может вызвать [`RuntimeError`](https://python-all.ru/3.8/library/exceptions.html#RuntimeError) или не позволить обойти все записи.27662767Изменено в версии 3.7: Теперь гарантируется, что порядок словаря соответствует порядку вставки.27682769#### `x in dictview`27702771Возвращает `True`, если *x* находится в ключах, значениях или элементах (items) базового словаря (в последнем случае *x* должен быть кортежем `(key, value)`).27722773#### `reversed(dictview)`27742775Возвращает реверсивный итератор по ключам, значениям или элементам словаря. Представление (view) будет обходиться в порядке, обратном порядку вставки.27762777Изменено в версии 3.8: Представления словарей теперь можно обходить в обратном порядке.27782779Представления ключей ведут себя как множества, так как их элементы уникальны и хэшируемы. Если все значения хэшируемы, так что пары `(key, value)` уникальны и хэшируемы, то представление элементов также ведёт себя как множество. (Представления значений не рассматриваются как множества, поскольку их элементы обычно не уникальны.) Для представлений, ведущих себя как множества, доступны все операции, определённые для абстрактного базового класса [`collections.abc.Set`](https://python-all.ru/3.8/library/collections.abc.html#collections.abc.Set) (например, `==`, `<` или `^`).27802781Пример использования представления словаря:27822783```python2784>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}2785>>> keys = dishes.keys()2786>>> values = dishes.values()27872788>>> # итерация2789>>> n = 02790>>> for val in values:2791... n += val2792>>> print(n)279350427942795>>> # ключи и значения перебираются в одном порядке (порядок вставки)2796>>> list(keys)2797['eggs', 'sausage', 'bacon', 'spam']2798>>> list(values)2799[2, 1, 1, 500]28002801>>> # объекты представления динамичны и отражают изменения словаря2802>>> del dishes['eggs']2803>>> del dishes['sausage']2804>>> list(keys)2805['bacon', 'spam']28062807>>> # операции над множествами2808>>> keys & {'eggs', 'bacon', 'salad'}2809{'bacon'}2810>>> keys ^ {'sausage', 'juice'}2811{'juice', 'sausage', 'bacon', 'spam'}2812```28132814## Типы контекстных менеджеров28152816Оператор [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with) в Python поддерживает понятие контекста выполнения, определяемого контекстным менеджером. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который входит в действие до выполнения тела оператора и выходит из него по завершении оператора:28172818#### `contextmanager.__enter__()`28192820Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, связывается с идентификатором в предложении `as` оператора [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with), использующего данный контекстный менеджер.28212822Примером контекстного менеджера, который возвращает сам себя, является [файловый объект](https://python-all.ru/3.8/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить использовать [`open()`](https://python-all.ru/3.8/library/functions.html#open) в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with).28232824Примером контекстного менеджера, возвращающего связанный объект, является менеджер, возвращаемый [`decimal.localcontext()`](https://python-all.ru/3.8/library/decimal.html#decimal.localcontext). Такие менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста и затем возвращают эту копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with), не затрагивая код за пределами оператора `with`.28252826#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`28272828Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если исключение возникло при выполнении тела оператора [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with), аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.28292830Возврат истинного значения из этого метода приведет к тому, что оператор [`with`](https://python-all.ru/3.8/reference/compound_stmts.html#with) подавит исключение и продолжит выполнение с оператора, следующего сразу за оператором `with`. В противном случае исключение продолжит распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, возникшее в теле оператора `with`.28312832Переданное исключение никогда не должно явно возбуждаться повторно – вместо этого метод должен вернуть ложное значение, чтобы указать, что метод завершился успешно и не хочет подавлять возникшее исключение. Это позволяет коду управления контекстом легко определить, произошёл ли на самом деле сбой метода [`__exit__()`](https://python-all.ru/3.8/library/stdtypes.html#contextmanager.__exit__).28332834Python определяет несколько контекстных менеджеров для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов, а также более простого управления активным контекстом десятичной арифметики. Конкретные типы не рассматриваются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.8/library/contextlib.html#module-contextlib) для примеров.28352836Python [generator](https://python-all.ru/3.8/glossary.html#term-generator)s и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.8/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если генераторная функция декорирована декоратором [`contextlib.contextmanager`](https://python-all.ru/3.8/library/contextlib.html#contextlib.contextmanager), она вернёт менеджер контекста, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__exit__), а не итератор, создаваемый недекорированной генераторной функцией.28372838Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.28392840## Другие встроенные типы28412842Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.28432844### Модули28452846Единственная специальная операция над модулем – это доступ к атрибутам: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов модуля *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.8/reference/simple_stmts.html#import) строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, а требует (внешнего) *определения* для модуля с именем *foo* где-то.)28472848Специальным атрибутом каждого модуля является [`__dict__`](https://python-all.ru/3.8/library/stdtypes.html#object.__dict__). Это словарь, содержащий таблицу символов модуля. Изменение этого словаря действительно изменит таблицу символов модуля, но прямое присваивание атрибуту [`__dict__`](https://python-all.ru/3.8/library/stdtypes.html#object.__dict__) невозможно (можно написать `m.__dict__['a'] = 1`, что определит `m.a` как `1`, но нельзя написать `m.__dict__ = {}`). Изменять [`__dict__`](https://python-all.ru/3.8/library/stdtypes.html#object.__dict__) напрямую не рекомендуется.28492850Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.28512852### Классы и экземпляры классов28532854См. [Объекты, значения и типы](https://python-all.ru/3.8/reference/datamodel.html#objects) и [Определения классов](https://python-all.ru/3.8/reference/compound_stmts.html#class).28552856### Функции28572858Объекты-функции создаются определениями функций. Единственная операция над объектом-функцией – это вызов: `func(argument-list)`.28592860На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.28612862Дополнительную информацию см. в разделе [Определения функций](https://python-all.ru/3.8/reference/compound_stmts.html#function).28632864### Методы28652866Методы – это функции, вызываемые с использованием точечной нотации. Существуют два вида: встроенные методы (например, `append()` для списков) и методы экземпляров классов. Встроенные методы описываются с типами, которые их поддерживают.28672868Если обратиться к методу (функции, определенной в пространстве имен класса) через экземпляр, то получается специальный объект: объект *привязанного метода* (также называемый *метод экземпляра*). При вызове он добавляет аргумент `self` в список аргументов. Привязанные методы имеют два специальных атрибута только для чтения: `m.__self__` – объект, над которым метод выполняется, а `m.__func__` – функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.28692870Как и объекты функций, объекты привязанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции (`meth.__func__`), установка атрибутов метода для привязанных методов запрещена. Попытка установить атрибут на методе приводит к возбуждению [`AttributeError`](https://python-all.ru/3.8/library/exceptions.html#AttributeError). Чтобы установить атрибут метода, необходимо явно задать его в базовом объекте функции:28712872```python2873>>> class C:2874... def method(self):2875... pass2876...2877>>> c = C()2878>>> c.method.whoami = 'my name is method' # нельзя установить на методе2879Traceback (most recent call last):2880 File "<stdin>", line 1, in <module>2881AttributeError: 'method' object has no attribute 'whoami'2882>>> c.method.__func__.whoami = 'my name is method'2883>>> c.method.whoami2884'my name is method'2885```28862887Дополнительную информацию см. в разделе [Стандартная иерархия типов](https://python-all.ru/3.8/reference/datamodel.html#types).28882889### Объекты кода28902891Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, такого как тело функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.8/library/functions.html#compile) и могут быть получены из объектов функций через их атрибут `__code__`. См. также модуль [`code`](https://python-all.ru/3.8/library/code.html#module-code).28922893Доступ к `__code__` вызывает [событие аудита](https://python-all.ru/3.8/library/sys.html#auditing) `object.__getattr__` с аргументами `obj` и `"__code__"`.28942895Объект кода можно выполнить или вычислить, передав его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.8/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.8/library/functions.html#eval).28962897Дополнительную информацию см. в разделе [Стандартная иерархия типов](https://python-all.ru/3.8/reference/datamodel.html#types).28982899### Объекты типов29002901Объекты типов представляют различные типы объектов. Тип объекта можно получить с помощью встроенной функции [`type()`](https://python-all.ru/3.8/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.8/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.29022903Типы записываются так: `<class 'int'>`.29042905### Объект Null29062907Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один нулевой объект с именем `None` (встроенное имя). `type(None)()` возвращает тот же синглтон.29082909Он записывается как `None`.29102911### Объект многоточия29122913Этот объект обычно используется при срезах (см. [Срезы](https://python-all.ru/3.8/reference/expressions.html#slicings)). Он не поддерживает никаких специальных операций. Существует ровно один объект-многоточие с именем [`Ellipsis`](https://python-all.ru/3.8/library/constants.html#Ellipsis) (встроенное имя). `type(Ellipsis)()` возвращает одиночный объект [`Ellipsis`](https://python-all.ru/3.8/library/constants.html#Ellipsis).29142915Он записывается как `Ellipsis` или `...`.29162917### Объект NotImplemented29182919Этот объект возвращается из сравнений и бинарных операций, когда они должны работать с типами, которые не поддерживают. Дополнительную информацию см. в разделе [Сравнения](https://python-all.ru/3.8/reference/expressions.html#comparisons). Существует ровно один объект `NotImplemented`. `type(NotImplemented)()` возвращает экземпляр-синглтон.29202921Он записывается как `NotImplemented`.29222923### Логические значения29242925Логические значения – это два постоянных объекта `False` и `True`. Они используются для представления истинностных значений (хотя другие значения также могут считаться ложными или истинными). В числовых контекстах (например, при передаче в арифметическую операцию) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция [`bool()`](https://python-all.ru/3.8/library/functions.html#bool) может быть использована для преобразования любого значения в логическое, если значение может быть интерпретировано как истинностное значение (см. раздел [Проверка истинности](https://python-all.ru/3.8/library/stdtypes.html#truth) выше).29262927Они записываются как `False` и `True` соответственно.29282929### Внутренние объекты29302931См. [Стандартная иерархия типов](https://python-all.ru/3.8/reference/datamodel.html#types) для получения этой информации. В нем описываются объекты стековых кадров, объекты трассировки и объекты срезов.29322933## Специальные атрибуты29342935Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где это уместно. Некоторые из них не сообщаются встроенной функцией [`dir()`](https://python-all.ru/3.8/library/functions.html#dir).29362937#### `object.__dict__`29382939Словарь или другой отображающий объект, используемый для хранения (изменяемых) атрибутов объекта.29402941#### `instance.__class__`29422943Класс, которому принадлежит экземпляр класса.29442945#### `class.__bases__`29462947Кортеж базовых классов объекта класса.29482949#### `definition.__name__`29502951Имя класса, функции, метода, дескриптора или экземпляра генератора.29522953#### `definition.__qualname__`29542955[Полное имя](https://python-all.ru/3.8/glossary.html#term-qualified-name) класса, функции, метода, дескриптора, или экземпляра генератора.29562957Новое в версии 3.3.29582959#### `class.__mro__`29602961Этот атрибут представляет собой кортеж классов, которые учитываются при поиске базовых классов во время разрешения методов.29622963#### `class.mro()`29642965Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в [`__mro__`](https://python-all.ru/3.8/library/stdtypes.html#class.__mro__).29662967#### `class.__subclasses__()`29682969Каждый класс хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех ещё существующих ссылок. Пример:29702971```python2972>>> int.__subclasses__()2973[<class 'bool'>]2974```29752976## Ограничение длины преобразования целого числа в строку29772978В CPython существует глобальное ограничение на преобразование между [`int`](https://python-all.ru/3.8/library/functions.html#int) и [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) для смягчения атак типа «отказ в обслуживании». Это ограничение *только* применяется к десятичной или другим системам счисления, не являющимся степенями двойки. Преобразования в шестнадцатеричную, восьмеричную и двоичную системы не ограничены. Ограничение можно настроить.29792980Тип [`int`](https://python-all.ru/3.8/library/functions.html#int) в CPython – это число произвольной длины, хранящееся в двоичной форме (обычно называемое «bignum»). Не существует алгоритма, который мог бы преобразовать строку в двоичное целое или двоичное целое в строку за линейное время, *кроме* случая, когда основание является степенью двойки. Даже лучшие известные алгоритмы для основания 10 имеют субквадратичную сложность. Преобразование большого значения, такого как `int('1' * 500_000)`, может занять более секунды на быстром CPU.29812982Ограничение размера преобразования предоставляет практический способ избежать [CVE-2020-10735](https://python-all.ru/3.8/library/stdtypes.html).29832984Ограничение применяется к количеству цифровых символов во входной или выходной строке, когда задействован нелинейный алгоритм преобразования. Символы подчёркивания и знак не учитываются в ограничении.29852986Когда операция превышает ограничение, вызывается [`ValueError`](https://python-all.ru/3.8/library/exceptions.html#ValueError):29872988```pycon2989>>> import sys2990>>> sys.set_int_max_str_digits(4300) # Для иллюстрации, это значение по умолчанию.2991>>> _ = int('2' * 5432)2992Traceback (most recent call last):2993...2994ValueError: Exceeds the limit (4300) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit.2995>>> i = int('2' * 4300)2996>>> len(str(i))299743002998>>> i_squared = i*i2999>>> len(str(i_squared))3000Traceback (most recent call last):3001...3002ValueError: Exceeds the limit (4300) for integer string conversion: value has 8599 digits; use sys.set_int_max_str_digits() to increase the limit.3003>>> len(hex(i_squared))300471443005>>> assert int(hex(i_squared), base=16) == i*i # Шестнадцатеричный формат не ограничен.3006```30073008Значение ограничения по умолчанию – 4300 цифр, как указано в [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.8/library/sys.html#sys.int_info). Наименьшее настраиваемое ограничение – 640 цифр, как указано в [`sys.int_info.str_digits_check_threshold`](https://python-all.ru/3.8/library/sys.html#sys.int_info).30093010Проверка:30113012```pycon3013>>> import sys3014>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info3015>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info3016>>> msg = int('578966293710682886880994035146873798396722250538762761564'3017... '9252925514383915483333812743580549779436104706260696366600'3018... '571186405732').to_bytes(53, 'big')3019...3020```30213022Новое в версии 3.8.14.30233024### Затронутые API30253026Ограничение применяется только к потенциально медленным преобразованиям между [`int`](https://python-all.ru/3.8/library/functions.html#int) и [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) или [`bytes`](https://python-all.ru/3.8/library/stdtypes.html#bytes):30273028- `int(string)` с основанием 10 по умолчанию.3029- `int(string, base)` для всех оснований, не являющихся степенью двойки.3030- `str(integer)`.3031- `repr(integer)`.3032- любое другое преобразование строки в основание 10, например `f"{integer}"`, `"{}".format(integer)` или `b"%d" % integer`.30333034Ограничения не применяются к функциям с линейным алгоритмом:30353036- `int(string, base)` с основанием 2, 4, 8, 16 или 32.3037- [`int.from_bytes()`](https://python-all.ru/3.8/library/stdtypes.html#int.from_bytes) и [`int.to_bytes()`](https://python-all.ru/3.8/library/stdtypes.html#int.to_bytes).3038- [`hex()`](https://python-all.ru/3.8/library/functions.html#hex), [`oct()`](https://python-all.ru/3.8/library/functions.html#oct), [`bin()`](https://python-all.ru/3.8/library/functions.html#bin).3039- [Язык описания форматов](https://python-all.ru/3.8/library/string.html#formatspec) для шестнадцатеричных, восьмеричных и двоичных чисел.3040- [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) в [`float`](https://python-all.ru/3.8/library/functions.html#float).3041- [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) в [`decimal.Decimal`](https://python-all.ru/3.8/library/decimal.html#decimal.Decimal).30423043### Настройка ограничения30443045Перед запуском Python можно использовать переменную окружения или флаг командной строки интерпретатора для настройки ограничения:30463047- [`PYTHONINTMAXSTRDIGITS`](https://python-all.ru/3.8/using/cmdline.html#envvar-PYTHONINTMAXSTRDIGITS), например, `PYTHONINTMAXSTRDIGITS=640 python3`, чтобы установить ограничение 640, или `PYTHONINTMAXSTRDIGITS=0 python3`, чтобы отключить ограничение.3048- [`-X int_max_str_digits`](https://python-all.ru/3.8/using/cmdline.html#id5), например, `python3 -X int_max_str_digits=640`3049- `sys.flags.int_max_str_digits` содержит значение [`PYTHONINTMAXSTRDIGITS`](https://python-all.ru/3.8/using/cmdline.html#envvar-PYTHONINTMAXSTRDIGITS) или [`-X int_max_str_digits`](https://python-all.ru/3.8/using/cmdline.html#id5). Если заданы и переменная окружения, и опция `-X`, то опция `-X` имеет приоритет. Значение *-1* указывает, что обе не были установлены, поэтому при инициализации использовалось значение `sys.int_info.default_max_str_digits`.30503051Из кода можно проверить текущий лимит и установить новый с помощью этих [`sys`](https://python-all.ru/3.8/library/sys.html#module-sys) API:30523053- [`sys.get_int_max_str_digits()`](https://python-all.ru/3.8/library/sys.html#sys.get_int_max_str_digits) и [`sys.set_int_max_str_digits()`](https://python-all.ru/3.8/library/sys.html#sys.set_int_max_str_digits) – это геттер и сеттер для лимита на уровне интерпретатора. Суб-интерпретаторы имеют свой собственный лимит.30543055Информацию о значениях по умолчанию и минимальном можно найти в [`sys.int_info`](https://python-all.ru/3.8/library/sys.html#sys.int_info):30563057- [`sys.int_info.default_max_str_digits`](https://python-all.ru/3.8/library/sys.html#sys.int_info) – это скомпилированный лимит по умолчанию.3058- [`sys.int_info.str_digits_check_threshold`](https://python-all.ru/3.8/library/sys.html#sys.int_info) – это наименьшее допустимое значение лимита (кроме 0, которое отключает его).30593060Новое в версии 3.8.14.30613062> **Внимание**3063>3064> Установка низкого лимита *может* привести к проблемам. Хотя это редко, существует код, содержащий десятичные целочисленные константы в исходниках, которые превышают минимальный порог. Следствие установки лимита: исходный код Python, содержащий десятичные целочисленные литералы длиннее лимита, вызовет ошибку при разборе, обычно во время запуска или импорта, или даже во время установки – в любой момент, когда актуальный `.pyc` ещё не существует для этого кода. Обходной путь для исходников, содержащих такие большие константы, – преобразовать их в `0x` шестнадцатеричную форму, так как у неё нет лимита.3065>3066> Тщательно тестируйте приложение, если используете низкий лимит. Убедитесь, что тесты запускаются с лимитом, установленным заранее через переменную окружения или флаг, чтобы он применялся во время запуска и даже на любом этапе установки, который может вызвать Python для предварительной компиляции `.py` исходников в `.pyc` файлы.30673068### Рекомендуемая конфигурация30693070Значение по умолчанию `sys.int_info.default_max_str_digits`, как ожидается, будет разумным для большинства приложений. Если вашему приложению требуется другой предел, установите его из вашей точки входа с помощью кода, не зависящего от версии Python, поскольку эти API были добавлены в выпусках исправлений безопасности в версиях до 3.11.30713072Пример:30733074```python3075>>> import sys3076>>> if hasattr(sys, "set_int_max_str_digits"):3077... upper_bound = 680003078... lower_bound = 40043079... current_limit = sys.get_int_max_str_digits()3080... if current_limit == 0 or current_limit > upper_bound:3081... sys.set_int_max_str_digits(upper_bound)3082... elif current_limit < lower_bound:3083... sys.set_int_max_str_digits(lower_bound)3084```30853086Если нужно полностью отключить его, установите значение `0`.30873088Сноски30893090**[1](https://python-all.ru/3.8/library/stdtypes.html#id1)**30913092Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([Базовая настройка](https://python-all.ru/3.8/reference/datamodel.html#customization)).30933094**[2](https://python-all.ru/3.8/library/stdtypes.html#id2)**30953096Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей.30973098**[3](https://python-all.ru/3.8/library/stdtypes.html#id4)**30993100Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов.31013102**4([1](https://python-all.ru/3.8/library/stdtypes.html#id6),[2](https://python-all.ru/3.8/library/stdtypes.html#id7),[3](https://python-all.ru/3.8/library/stdtypes.html#id8),[4](https://python-all.ru/3.8/library/stdtypes.html#id9))**31033104Символы с учётом регистра – это те, у которых свойство общей категории является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, заглавная).31053106**5([1](https://python-all.ru/3.8/library/stdtypes.html#id10),[2](https://python-all.ru/3.8/library/stdtypes.html#id11))**31073108Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж.3109