stdtypes.md

1> **Источник:** https://python-all.ru/3.2/library/stdtypes.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 4. Встроенные типы89В следующих разделах описываются стандартные типы, встроенные в интерпретатор.1011Основные встроенные типы: числовые типы, последовательности, отображения, классы, экземпляры и исключения.1213Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать, проверять на истинность и преобразовывать в строку (с помощью функции [`repr()`](https://python-all.ru/3.2/library/functions.html#repr) или несколько отличной функции [`str()`](https://python-all.ru/3.2/library/functions.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.2/library/functions.html#print).1415## 4.1. Проверка истинности1617Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.2/reference/compound_stmts.html#while) или в качестве операнда логических операций ниже. Следующие значения считаются ложными:1819>2021- `None`22- `False`23- ноль любого числового типа, например, `0`, `0.0`, `0j`.24- любая пустая последовательность, например, `''`, `()`, `[]`.25- любое пустое отображение, например, `{}`.26- экземпляры пользовательских классов, если класс определяет метод [`__bool__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__bool__) или [`__len__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__len__), когда этот метод возвращает целое ноль или логическое значение [`bool`](https://python-all.ru/3.2/library/functions.html#bool) `False`. [\[1\]](https://python-all.ru/3.2/library/stdtypes.html#id11)2728Все остальные значения считаются истинными – поэтому объекты многих типов всегда истинны.2930Операции и встроенные функции, возвращающие логический результат, всегда возвращают `0` или `False` для false и `1` или `True` для true, если не указано иное. (Важное исключение: логические операции `or` и `and` всегда возвращают один из своих операндов.)3132## 4.2. Логические операции – [`and`](https://python-all.ru/3.2/reference/expressions.html#and), [`or`](https://python-all.ru/3.2/reference/expressions.html#or), [`not`](https://python-all.ru/3.2/reference/expressions.html#not)3334Это булевы операции в порядке возрастания приоритета:3536| Операция | Результат | Примечания |37| --- | --- | --- |38| `x or y` | если *x* ложно, то *y*, иначе *x* | (1) |39| `x and y` | если *x* ложно, то *x*, иначе *y* | (2) |40| `not x` | если *x* ложно, то `True`, иначе `False` | (3) |4142Примечания:43441. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`False`](https://python-all.ru/3.2/library/constants.html#False).452. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`True`](https://python-all.ru/3.2/library/constants.html#True).463. `not` имеет более низкий приоритет, чем нелогические операторы, поэтому `not a == b` интерпретируется как `not (a == b)`, а `a == not b` является синтаксической ошибкой.4748## 4.3. Сравнения4950В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (выше, чем у логических операций). Сравнения можно произвольно соединять в цепочки; например, `x < y <= z` эквивалентно `x < y and y <= z`, за исключением того, что *y* вычисляется только один раз (но в обоих случаях *z* не вычисляется вообще, когда `x < y` оказывается ложным).5152В этой таблице приведены операции сравнения:5354| Операция | Значение |55| --- | --- |56| `<` | строго меньше |57| `<=` | меньше или равно |58| `>` | строго больше |59| `>=` | больше или равно |60| `==` | равно |61| `!=` | не равно |62| `is` | идентичность объектов |63| `is not` | отрицание идентичности объектов |6465Объекты разных типов, за исключением разных числовых типов, никогда не сравниваются как равные. Кроме того, некоторые типы (например, объекты-функции) поддерживают только вырожденное понятие сравнения, при котором любые два объекта этого типа неравны. Операторы `<`, `<=`, `>` и `>=` возбуждают исключение [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError) при сравнении комплексного числа с другим встроенным числовым типом, когда объекты имеют разные типы, которые нельзя сравнивать, или в других случаях, когда не определён порядок.6667Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет метод [`__eq__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__eq__).6869Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или к объектам других типов, если класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__ge__) (в общем случае достаточно [`__lt__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__lt__) и [`__eq__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__eq__), если нужны обычные значения операторов сравнения).7071Поведение операторов [`is`](https://python-all.ru/3.2/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.2/reference/expressions.html#is-not) не может быть настроено; они также могут применяться к любым двум объектам и никогда не вызывают исключение.7273Ещё две операции с тем же синтаксическим приоритетом, [`in`](https://python-all.ru/3.2/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.2/reference/expressions.html#not-in), поддерживаются только типами последовательностей (см. ниже).7475## 4.4. Числовые типы – [`int`](https://python-all.ru/3.2/library/functions.html#int), [`float`](https://python-all.ru/3.2/library/functions.html#float), [`complex`](https://python-all.ru/3.2/library/functions.html#complex)7677Существует три различных числовых типа: *целые числа*, *числа с плавающей точкой* и *комплексные числа*. Кроме того, логические значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью `double` в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.2/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы: [`fractions`](https://python-all.ru/3.2/library/fractions.html#module-fractions) для рациональных чисел и [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) для чисел с плавающей точкой с настраиваемой точностью.)7879Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Простые целые литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно прибавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.8081Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до типа другого, где целое уже, чем с плавающей точкой, а то, в свою очередь, уже, чем комплексное. Сравнения чисел смешанного типа используют то же правило. [\[2\]](https://python-all.ru/3.2/library/stdtypes.html#id12) Конструкторы [`int()`](https://python-all.ru/3.2/library/functions.html#int), [`float()`](https://python-all.ru/3.2/library/functions.html#float) и [`complex()`](https://python-all.ru/3.2/library/functions.html#complex) можно использовать для создания чисел определённого типа.8283Все числовые типы (кроме комплексных) поддерживают следующие операции, отсортированные по возрастанию приоритета (операции в одной рамке имеют одинаковый приоритет; все числовые операции имеют более высокий приоритет, чем операции сравнения):8485| Операция | Результат | Примечания | Полная документация |86| --- | --- | --- | --- |87| `x + y` | сумма *x* и *y* |  |  |88| `x - y` | разность *x* и *y* |  |  |89| `x * y` | произведение *x* и *y* |  |  |90| `x / y` | частное *x* и *y* |  |  |91| `x // y` | неполное частное *x* и *y* | (1) |  |92| `x % y` | остаток от `x / y` | (2) |  |93| `-x` | *x* с обратным знаком |  |  |94| `+x` | *x* без изменений |  |  |95| `abs(x)` | абсолютное значение или модуль *x* |  | [`abs()`](https://python-all.ru/3.2/library/functions.html#abs) |96| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.2/library/functions.html#int) |97| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.2/library/functions.html#float) |98| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.2/library/functions.html#complex) |99| `c.conjugate()` | сопряжённое комплексного числа *c* |  |  |100| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.2/library/functions.html#divmod) |101| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.2/library/functions.html#pow) |102| `x ** y` | *x* в степени *y* | (5) |  |103104Примечания:1051061. Также называется целочисленным делением. Результирующее значение является целым числом, хотя тип результата не обязательно int. Результат всегда округляется в сторону минус бесконечности: `1//2` равно `0`, `(-1)//2` равно `-1`, `1//(-2)` равно `-1`, а `(-1)//(-2)` равно `0`.1072. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей запятой с помощью [`abs()`](https://python-all.ru/3.2/library/functions.html#abs), если это уместно.1083. Преобразование чисел с плавающей запятой в целые может выполняться округлением или усечением, как в C; обратитесь к функциям `floor()` и `ceil()` в модуле [`math`](https://python-all.ru/3.2/library/math.html#module-math) для получения однозначных преобразований.1094. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.1105. Python определяет `pow(0, 0)` и `0 ** 0` как `1`, что распространено в языках программирования.1116. Принимаемые числовые литералы включают цифры от `0` до `9` или любой эквивалент Unicode (кодовые точки со свойством `Nd`).112113   Полный список кодовых точек со свойством `Nd` приведен по адресу [http://www.unicode.org/Public/6.0.0/ucd/extracted/DerivedNumericType.txt](https://python-all.ru/3.2/library/stdtypes.html).114115Все типы [`numbers.Real`](https://python-all.ru/3.2/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.2/library/functions.html#int) и [`float`](https://python-all.ru/3.2/library/functions.html#float)) также включают следующие операции:116117| Операция | Результат | Примечания |118| --- | --- | --- |119| `math.trunc(x)` | *x*, усечённое до целого |  |120| `round(x[, n])` | *x*, округлённое до n знаков, с округлением половины до чётного. Если n опущено, по умолчанию 0. |  |121| `math.floor(x)` | наибольшее целое число с плавающей запятой, не превышающее *x* |  |122| `math.ceil(x)` | наименьшее целое число с плавающей запятой, не меньшее *x* |  |123124За дополнительными числовыми операциями обращайтесь к [`math`](https://python-all.ru/3.2/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath) модулям.125126### 4.4.1. Побитовые операции над целыми типами127128Побитовые операции имеют смысл только для целых чисел. Отрицательные числа интерпретируются как их дополнительный код (при этом предполагается, что количество битов достаточно велико, чтобы при операции не произошло переполнения).129130Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция `~` имеет тот же приоритет, что и другие унарные числовые операции (`+` и `-`).131132В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета (операции в одном блоке имеют одинаковый приоритет):133134| Операция | Результат | Примечания |135| --- | --- | --- |136| `x \| y` | побитовое *ИЛИ* для *x* и *y* |  |137| `x ^ y` | побитовое *исключающее ИЛИ* для *x* и *y* |  |138| `x & y` | побитовое *И* для *x* и *y* |  |139| `x << n` | *x*, сдвинутое влево на *n* битов | (1)(2) |140| `x >> n` | *x*, сдвинутое вправо на *n* битов | (1)(3) |141| `~x` | инвертированные биты *x* |  |142143Примечания:1441451. Отрицательные значения сдвига недопустимы и приводят к возникновению исключения [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError).1462. Сдвиг влево на *n* бит эквивалентен умножению на `pow(2, n)` без проверки переполнения.1473. Сдвиг вправо на *n* бит эквивалентен делению на `pow(2, n)` без проверки переполнения.148149### 4.4.2. Дополнительные методы для целых типов150151Тип int реализует [`numbers.Integral`](https://python-all.ru/3.2/library/numbers.html#numbers.Integral) [*абстрактный базовый класс*](https://python-all.ru/3.2/glossary.html#term-abstract-base-class). Кроме того, он предоставляет ещё один метод:152153#### `int.bit_length()`154155Возвращает количество битов, необходимое для представления целого числа в двоичном виде, без учёта знака и ведущих нулей:156157```python158>>> n = -37159>>> bin(n)160'-0b100101'161>>> n.bit_length()1626163```164165Точнее, если `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`.166167Эквивалентно следующему:168169```python170def bit_length(self):171    s = bin(self)       # двоичное представление:  bin(-37) --> '-0b100101'172    s = s.lstrip('-0b') # удалить ведущие нули и знак минус173    return len(s)       # len('100101') --> 6174```175176Новое в версии 3.1.177178#### `int.to_bytes(length, byteorder, *, signed=False)`179180Возвращает массив байтов, представляющий целое число.181182```python183>>> (1024).to_bytes(2, byteorder='big')184b'\x04\x00'185>>> (1024).to_bytes(10, byteorder='big')186b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'187>>> (-1024).to_bytes(10, byteorder='big', signed=True)188b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'189>>> x = 1000190>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')191b'\xe8\x03'192```193194Целое число представляется с помощью *length* байт. Исключение [`OverflowError`](https://python-all.ru/3.2/library/exceptions.html#OverflowError) возникает, если целое число не может быть представлено указанным количеством байт.195196Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.2/library/sys.html#sys.byteorder) в качестве значения порядка байт.197198Аргумент *signed* определяет, используется ли дополнительный код для представления целого числа. Если *signed* равен `False` и передано отрицательное целое число, возбуждается исключение [`OverflowError`](https://python-all.ru/3.2/library/exceptions.html#OverflowError). Значение по умолчанию для *signed* равно `False`.199200Новое в версии 3.2.201202#### `classmethod int.from_bytes(bytes, byteorder, *, signed=False)`203204Возвращает целое число, представленное заданным массивом байтов.205206```python207>>> int.from_bytes(b'\x00\x10', byteorder='big')20816209>>> int.from_bytes(b'\x00\x10', byteorder='little')2104096211>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)212-1024213>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)21464512215>>> int.from_bytes([255, 0, 0], byteorder='big')21616711680217```218219Аргумент *bytes* должен либо поддерживать буферный протокол, либо быть итерируемым, порождающим байты. [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray) являются примерами встроенных объектов, поддерживающих буферный протокол.220221Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.2/library/sys.html#sys.byteorder) в качестве значения порядка байт.222223Аргумент *signed* указывает, используется ли дополнительный код для представления целого числа.224225Новое в версии 3.2.226227### 4.4.3. Дополнительные методы для Float228229Тип float реализует [`numbers.Real`](https://python-all.ru/3.2/library/numbers.html#numbers.Real) [*абстрактный базовый класс*](https://python-all.ru/3.2/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.230231#### `float.as_integer_ratio()`232233Возвращает пару целых чисел, отношение которых в точности равно исходному числу с плавающей запятой, с положительным знаменателем. Возбуждает [`OverflowError`](https://python-all.ru/3.2/library/exceptions.html#OverflowError) для бесконечностей и [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError) для NaN.234235#### `float.is_integer()`236237Возвращает `True`, если экземпляр float является конечным и имеет целое значение, и `False` в противном случае:238239```python240>>> (-2.0).is_integer()241True242>>> (3.2).is_integer()243False244```245246Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python внутренне хранятся в двоичном виде, преобразование числа с плавающей запятой в строку *decimal* и обратно обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точно представлять и задавать числа с плавающей запятой. Это может быть полезно при отладке и в численных расчётах.247248#### `float.hex()`249250Возвращает представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой такое представление всегда содержит префикс `0x` и суффикс `p` с показателем степени.251252#### `classmethod float.fromhex(s)`253254Метод класса, возвращающий число с плавающей запятой, представленное шестнадцатеричной строкой *s*. Строка *s* может содержать начальные и конечные пробелы.255256Обратите внимание, что [`float.hex()`](https://python-all.ru/3.2/library/stdtypes.html#float.hex) – это метод экземпляра, тогда как [`float.fromhex()`](https://python-all.ru/3.2/library/stdtypes.html#float.fromhex) – это метод класса.257258Шестнадцатеричная строка имеет вид:259260```python261[sign] ['0x'] integer ['.' fraction] ['p' exponent]262```263264где необязательный `знак` может быть `+` или `-`, `целая часть` и `дробная часть` – строки шестнадцатеричных цифр, а `порядок` – десятичное целое с необязательным ведущим знаком. Регистр не имеет значения, и должна быть хотя бы одна шестнадцатеричная цифра либо в целой, либо в дробной части. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и выше. В частности, результат [`float.hex()`](https://python-all.ru/3.2/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде на C или Java, а шестнадцатеричные строки, создаваемые символом формата `%a` в C или методом `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.2/library/stdtypes.html#float.fromhex).265266Обратите внимание, что порядок записывается в десятичном виде, а не в шестнадцатеричном, и что он показывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка `0x3.a7p10` представляет число с плавающей запятой `(3 + 10./16 + 7./16**2) * 2.0**10`, или `3740.0`:267268```python269>>> float.fromhex('0x3.a7p10')2703740.0271```272273Применение обратного преобразования к `3740.0` даёт другую шестнадцатеричную строку, представляющую то же число:274275```python276>>> float.hex(3740.0)277'0x1.d380000000000p+11'278```279280### 4.4.4. Хеширование числовых типов281282Для чисел `x` и `y`, возможно разных типов, требуется, чтобы `hash(x) == hash(y)`, когда `x == y` (см. документацию метода [`__hash__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__hash__) для подробностей). Для простоты реализации и эффективности для разных числовых типов (включая [`int`](https://python-all.ru/3.2/library/functions.html#int), [`float`](https://python-all.ru/3.2/library/functions.html#float), [`decimal.Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal) и [`fractions.Fraction`](https://python-all.ru/3.2/library/fractions.html#fractions.Fraction)) хеш Python для числовых типов основан на одной математической функции, которая определена для любого рационального числа и, следовательно, применима ко всем экземплярам [`int`](https://python-all.ru/3.2/library/functions.html#int) и `fraction.Fraction`, а также ко всем конечным экземплярам [`float`](https://python-all.ru/3.2/library/functions.html#float) и [`decimal.Decimal`](https://python-all.ru/3.2/library/decimal.html#decimal.Decimal). По существу, эта функция задаётся приведением по модулю `P` для фиксированного простого числа `P`. Значение `P` доступно в Python как атрибут `modulus` объекта [`sys.hash_info`](https://python-all.ru/3.2/library/sys.html#sys.hash_info).283284**Особенность реализации CPython:** В настоящее время используется простое число `P = 2**31 - 1` на машинах с 32-разрядными C длинными целыми и `P = 2**61 - 1` на машинах с 64-разрядными C длинными целыми.285286Вот подробные правила:287288> - Если `x = m / n` – неотрицательное рациональное число и `n` не делится на `P`, определим `hash(x)` как `m * invmod(n, P) % P`, где `invmod(n, P)` даёт обратное к `n` по модулю `P`.289> - Если `x = m / n` – неотрицательное рациональное число и `n` делится на `P` (но `m` не делится), то `n` не имеет обратного по модулю `P`, и правило выше не применяется; в этом случае определим `hash(x)` как константу `sys.hash_info.inf`.290> - Если `x = m / n` – отрицательное рациональное число, определим `hash(x)` как `-hash(-x)`. Если полученный хеш равен `-1`, заменим его на `-2`.291> - Конкретные значения `sys.hash_info.inf`, `-sys.hash_info.inf` и `sys.hash_info.nan` используются как хеш-значения для положительной бесконечности, отрицательной бесконечности или nan (соответственно). (Все хешируемые nan имеют одинаковое хеш-значение.)292> - Для комплексного числа [`complex`](https://python-all.ru/3.2/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`.293294Для разъяснения приведённых выше правил, вот пример кода Python, эквивалентного встроенному хешу, для вычисления хеша рационального числа, [`float`](https://python-all.ru/3.2/library/functions.html#float), или [`complex`](https://python-all.ru/3.2/library/functions.html#complex):295296```python297import sys, math298299def hash_fraction(m, n):300    """Вычислить хеш рационального числа m / n.301302    Предполагается, что m и n – целые числа, n положительное.303    Эквивалентно hash(fractions.Fraction(m, n)).304305    """306    P = sys.hash_info.modulus307    # Удалить общие делители P.  (Необязательно, если m и n уже взаимно просты.)308    while m % P == n % P == 0:309        m, n = m // P, n // P310311    if n % P == 0:312        hash_ = sys.hash_info.inf313    else:314        # Малая теорема Ферма: pow(n, P-1, P) равно 1, поэтому315        # pow(n, P-2, P) даёт обратный элемент n по модулю P.316        hash_ = (abs(m) % P) * pow(n, P - 2, P) % P317    if m < 0:318        hash_ = -hash_319    if hash_ == -1:320        hash_ = -2321    return hash_322323def hash_float(x):324    """Вычислить хеш числа с плавающей запятой x."""325326    if math.isnan(x):327        return sys.hash_info.nan328    elif math.isinf(x):329        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf330    else:331        return hash_fraction(*x.as_integer_ratio())332333def hash_complex(z):334    """Вычислить хеш комплексного числа z."""335336    hash_ = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)337    # выполнить знаковое приведение по модулю 2**sys.hash_info.width338    M = 2**(sys.hash_info.width - 1)339    hash_ = (hash_ & (M - 1)) - (hash & M)340    if hash_ == -1:341        hash_ == -2342    return hash_343```344345## 4.5. Типы итераторов346347Python поддерживает концепцию итерации по контейнерам. Это реализовано с помощью двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают методы итерации.348349Для поддержки итерации в объектах-контейнерах необходимо определить один метод:350351#### `container.__iter__()`352353Возвращает объект-итератор. Объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные типы итерации, могут быть предоставлены дополнительные методы для запроса итераторов для этих типов. (Примером объекта, поддерживающего несколько форм итерации, может служить структура дерева, поддерживающая обход в ширину и в глубину.) Этот метод соответствует слоту `tp_iter` структуры типа для объектов Python в Python/C API.354355Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:356357#### `iterator.__iter__()`358359Возвращает сам объект-итератор. Это необходимо, чтобы и контейнеры, и итераторы можно было использовать с операторами [`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for) и [`in`](https://python-all.ru/3.2/reference/expressions.html#in). Этот метод соответствует слоту `tp_iter` структуры типа для объектов Python в Python/C API.360361#### `iterator.__next__()`362363Возвращает следующий элемент из контейнера. Если больше нет элементов, возбуждает исключение [`StopIteration`](https://python-all.ru/3.2/library/exceptions.html#StopIteration). Этот метод соответствует слоту `tp_iternext` структуры типа для объектов Python в Python/C API.364365Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.366367Как только метод [`__next__()`](https://python-all.ru/3.2/library/stdtypes.html#iterator.__next__) итератора возбуждает [`StopIteration`](https://python-all.ru/3.2/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.368369### 4.5.1. Типы генераторов370371Python’s [*generator*](https://python-all.ru/3.2/glossary.html#term-generator)s provide a convenient way to implement the iterator protocol. If a container object’s [`__iter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__iter__) method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the [`__iter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__iter__) and [`__next__()`](https://python-all.ru/3.2/reference/expressions.html#generator.__next__) methods. More information about generators can be found in [*the documentation for the yield expression*](https://python-all.ru/3.2/reference/expressions.html#yieldexpr).372373## 4.6. Типы последовательностей – [`str`](https://python-all.ru/3.2/library/functions.html#str), [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes), [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray), [`list`](https://python-all.ru/3.2/library/functions.html#list), [`tuple`](https://python-all.ru/3.2/library/functions.html#tuple), [`range`](https://python-all.ru/3.2/library/functions.html#range)374375Существует шесть типов последовательностей: строки, последовательности байтов (объекты [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes)), массивы байтов (объекты [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray)), списки, кортежи и объекты range. Для других контейнеров обратитесь ко встроенным классам [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict) и [`set`](https://python-all.ru/3.2/library/stdtypes.html#set), а также к модулю [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections).376377Текстовые данные в Python обрабатываются с помощью объектов [`str`](https://python-all.ru/3.2/library/functions.html#str), или *строки*. Строки – это неизменяемые [*последовательности*](https://python-all.ru/3.2/library/stdtypes.html#typesseq) кодовых точек Unicode. Строковые литералы записываются в одинарных или двойных кавычках: `'xyzzy'`, `"frobozz"`. См. [*Строковые литералы и литералы байтов*](https://python-all.ru/3.2/reference/lexical_analysis.html#strings) для получения дополнительной информации о строковых литералах. В дополнение к описанной здесь функциональности существуют также строковые методы, описанные в разделе [*Методы строк*](https://python-all.ru/3.2/library/stdtypes.html#string-methods).378379Объекты bytes и bytearray содержат отдельные байты – первый является неизменяемым, а второй – изменяемой последовательностью. Объекты bytes можно создать с помощью конструктора [`bytes()`](https://python-all.ru/3.2/library/functions.html#bytes), а также из литералов; используйте префикс `b` с обычным синтаксисом строк: `b'xyzzy'`. Для создания массивов байтов используйте функцию [`bytearray()`](https://python-all.ru/3.2/library/functions.html#bytearray).380381В то время как строковые объекты являются последовательностями символов (представленных строками длиной 1), объекты bytes и bytearray являются последовательностями *целых чисел* (от 0 до 255), представляющих значение ASCII отдельных байтов. Это означает, что для объекта bytes или bytearray *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytes или bytearray длиной 1. Представление объектов bytes использует формат литерала (`b'...'`), так как это обычно более полезно, чем, например, `bytes([50, 19, 100])`. Вы всегда можете преобразовать объект bytes в список целых чисел с помощью `list(b)`.382383Кроме того, хотя в предыдущих версиях Python байтовые строки и строки Unicode можно было довольно свободно заменять друг другом (за исключением проблем кодировки), строки и байты теперь являются полностью отдельными понятиями. Неявного кодирования/декодирования при передаче объекта неправильного типа не происходит. Строка всегда неравна объекту bytes или bytearray при сравнении.384385Списки создаются с помощью квадратных скобок, разделяя элементы запятыми: `[a, b, c]`. Кортежи создаются с помощью оператора запятой (не внутри квадратных скобок), с обрамляющими круглыми скобками или без них, но пустой кортеж должен иметь обрамляющие круглые скобки, например `a, b, c` или `()`. Кортеж из одного элемента должен иметь завершающую запятую, например `(d,)`.386387Объекты типа range создаются с помощью функции [`range()`](https://python-all.ru/3.2/library/functions.html#range). Они не поддерживают конкатенацию или повторение, а использование [`min()`](https://python-all.ru/3.2/library/functions.html#min) или [`max()`](https://python-all.ru/3.2/library/functions.html#max) для них неэффективно.388389Большинство типов последовательностей поддерживают следующие операции. Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` и `*` имеют тот же приоритет, что и соответствующие числовые операции. [\[3\]](https://python-all.ru/3.2/library/stdtypes.html#id13) Дополнительные методы предоставляются для [*Изменяемых типов последовательностей*](https://python-all.ru/3.2/library/stdtypes.html#typesseq-mutable).390391В этой таблице перечислены операции с последовательностями в порядке возрастания приоритета (операции в одной строке имеют одинаковый приоритет). В таблице *s* и *t* – это последовательности одного типа; *n*, *i*, *j* и *k* – целые числа.392393| Операция | Результат | Примечания |394| --- | --- | --- |395| `x в s` | `True`, если элемент *s* равен *x*, иначе `False` | (1) |396| `x не в s` | `False`, если элемент *s* равен *x*, иначе `True` | (1) |397| `s + t` | конкатенация *s* и *t* | (6) |398| `s * n, n * s` | *n* поверхностных копий *s*, объединённых | (2) |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(i)` | индекс первого вхождения *i* в *s* |  |406| `s.count(i)` | общее количество вхождений *i* в *s* |  |407408Типы последовательностей также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равным, а две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в [*Сравнения*](https://python-all.ru/3.2/reference/expressions.html#comparisons) в справочнике по языку.)409410Примечания:4114121. Если *s* является строковым объектом, операции `in` и `not in` работают как проверка на подстроку.4132. Значения *n* меньше `0` интерпретируются как `0` (что даёт пустую последовательность того же типа, что и *s*). Также обратите внимание, что копии являются поверхностными; вложенные структуры не копируются. Это часто удивляет новичков в Python; рассмотрите:414415   ```python416   >>> lists = [[]] * 3417   >>> lists418   [[], [], []]419   >>> lists[0].append(3)420   >>> lists421   [[3], [3], [3]]422   ```423424   Произошло следующее: `[[]]` – это список из одного элемента, содержащий пустой список, поэтому все три элемента `[[]] * 3` являются (указателями на) этот единственный пустой список. Модификация любого из элементов `списков` изменяет этот единственный список. Создать список из разных списков можно так:425426   ```python427   >>> lists = [[] for i in range(3)]428   >>> lists[0].append(3)429   >>> lists[1].append(5)430   >>> lists[2].append(7)431   >>> lists432   [[3], [5], [7]]433   ```4343. Если *i* или *j* отрицательно, индекс отсчитывается от конца строки: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание, что `-0` по-прежнему равно `0`.4354. Срез *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, таким что `i <= k < j`. Если *i* или *j* больше `len(s)`, используется `len(s)`. Если *i* опущено или равно `None`, используется `0`. Если *j* опущено или равно `None`, используется `len(s)`. Если *i* больше или равно *j*, срез пуст.4365. Срез *s* от *i* до *j* с шагом *k* определяется как последовательность элементов с индексом `x = i + n*k` таким, что `0 <= n < (j-i)/k`. Иными словами, индексы – это `i`, `i+k`, `i+2*k`, `i+3*k` и так далее, пока не будет достигнуто *j* (но *j* никогда не включается). Если *i* или *j* больше `len(s)`, используется `len(s)`. Если *i* или *j* опущены или равны `None`, они становятся «конечными» значениями (какой именно конец – зависит от знака *k*). Обратите внимание: *k* не может быть нулём. Если *k* равно `None`, оно трактуется как `1`.4376. Конкатенация неизменяемых строк всегда приводит к созданию нового объекта. Это означает, что построение строки путём повторной конкатенации будет иметь квадратичную стоимость выполнения от общей длины строки. Чтобы получить линейную стоимость, необходимо переключиться на один из следующих альтернативных подходов:438439   - если конкатенируются объекты [`str`](https://python-all.ru/3.2/library/functions.html#str), можно построить список и использовать [`str.join()`](https://python-all.ru/3.2/library/stdtypes.html#str.join) в конце;440   - если конкатенируются объекты [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes), можно аналогично использовать `bytes.join()`, или выполнить конкатенацию на месте с объектом [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray). Объекты [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray) являются изменяемыми и обладают эффективным механизмом перераспределения.441442### 4.6.1. Методы строк443444Строковые объекты поддерживают перечисленные ниже методы.445446Кроме того, строки Python поддерживают методы типов последовательностей, описанные в разделе [*Типы последовательностей – str, bytes, bytearray, list, tuple, range*](https://python-all.ru/3.2/library/stdtypes.html#typesseq). Для вывода форматированных строк см. раздел [*Форматирование строк*](https://python-all.ru/3.2/library/string.html#string-formatting). Также см. модуль [`re`](https://python-all.ru/3.2/library/re.html#module-re) для строковых функций, основанных на регулярных выражениях.447448#### `str.capitalize()`449450Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.451452#### `str.center(width[, fillchar])`453454Возвращает строку длины *width*, в которой исходная строка располагается по центру. Заполнение выполняется с использованием указанного символа *fillchar* (по умолчанию пробел).455456#### `str.count(sub[, start[, end]])`457458Возвращает количество непересекающихся вхождений подстроки *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов.459460#### `str.encode(encoding="utf-8", errors="strict")`461462Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* можно задать для указания другой схемы обработки ошибок. Значение *errors* по умолчанию – `'strict'`, что означает, что ошибки кодирования вызывают исключение [`UnicodeError`](https://python-all.ru/3.2/library/exceptions.html#UnicodeError). Другими возможными значениями являются `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'`, а также любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.2/library/codecs.html#codecs.register_error); см. раздел [*Базовые классы кодеков*](https://python-all.ru/3.2/library/codecs.html#codec-base-classes). Список возможных кодировок приведён в разделе [*Стандартные кодировки*](https://python-all.ru/3.2/library/codecs.html#standard-encodings).463464Изменено в версии 3.1: Добавлена поддержка именованных аргументов.465466#### `str.endswith(suffix[, start[, end]])`467468Возвращает `True`, если строка заканчивается указанным *suffix*, иначе возвращает `False`. *suffix* также может быть кортежем суффиксов, которые нужно искать. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение останавливается на этой позиции.469470#### `str.expandtabs([tabsize])`471472Возвращает копию строки, в которой все символы табуляции заменяются нулём или несколькими пробелами в зависимости от текущей позиции и заданного размера табуляции. Номер столбца сбрасывается на ноль после каждого перевода строки в строке. Если *tabsize* не указан, предполагается размер табуляции `8` символов. Эта функция не распознаёт другие непечатаемые символы или escape-последовательности.473474#### `str.find(sub[, start[, end]])`475476Возвращает наименьший индекс в строке, где найдена подстрока *sub*, такой что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.477478> **Примечание**479>480> Метод [`find()`](https://python-all.ru/3.2/library/stdtypes.html#str.find) следует использовать только если нужно узнать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.2/reference/expressions.html#in):481>482> ```python483> >>> 'Py' in 'Python'484> True485> ```486487#### `str.format(*args, **kwargs)`488489Выполняет операцию форматирования строки. Строка, к которой применяется этот метод, может содержать буквальный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию строки, в которой каждое поле замены заменено строковым значением соответствующего аргумента.490491```python492>>> "The sum of 1 + 2 is {0}".format(1+2)493'The sum of 1 + 2 is 3'494```495496См. [*Синтаксис форматных строк*](https://python-all.ru/3.2/library/string.html#formatstrings) для описания различных параметров форматирования, которые можно указать в форматных строках.497498#### `str.format_map(mapping)`499500Похоже на `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую и не копируется в [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict). Это полезно, если, например, `mapping` является подклассом dict:501502```python503>>> class Default(dict):504...     def __missing__(self, key):505...         return key506...507>>> '{name} was born in {country}'.format_map(Default(name='Guido'))508'Guido was born in country'509```510511Новое в версии 3.2.512513#### `str.index(sub[, start[, end]])`514515Как [`find()`](https://python-all.ru/3.2/library/stdtypes.html#str.find), но вызывает [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), если подстрока не найдена.516517#### `str.isalnum()`518519Возвращает true, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе false. Символ `c` является буквенно-цифровым, если один из следующих методов возвращает `True`: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()` или `c.isnumeric()`.520521#### `str.isalpha()`522523Возвращает true, если все символы в строке являются буквенными и есть хотя бы один символ, иначе false. Буквенные символы – это символы, определённые в базе данных символов Unicode как «Letter», т.е. те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Unicode.524525#### `str.isdecimal()`526527Возвращает true, если все символы в строке являются десятичными символами и есть хотя бы один символ, иначе false. Десятичные символы относятся к общей категории «Nd». Эта категория включает цифры и все символы, которые можно использовать для формирования чисел с десятичным основанием, например U+0660, АРАБСКО-ИНДИЙСКАЯ ЦИФРА НОЛЬ.528529#### `str.isdigit()`530531Возвращает true, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false. Цифры включают десятичные символы и цифры, требующие специальной обработки, например совместимые надстрочные цифры. Формально цифрой является символ со значением свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.532533#### `str.isidentifier()`534535Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, раздел [*Идентификаторы и ключевые слова*](https://python-all.ru/3.2/reference/lexical_analysis.html#identifiers).536537#### `str.islower()`538539Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.2/library/stdtypes.html#id14) в строке являются строчными и есть хотя бы один буквенный символ, иначе false.540541#### `str.isnumeric()`542543Возвращает true, если все символы в строке являются числовыми символами и есть хотя бы один символ, иначе false. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы – это символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric.544545#### `str.isprintable()`546547Возвращает true, если все символы строки являются печатаемыми или строка пуста, иначе false. Непечатаемые символы – это те, которые определены в базе данных Unicode как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатаемым. (Обратите внимание, что печатаемые символы в данном контексте – это те, которые не должны экранироваться при вызове [`repr()`](https://python-all.ru/3.2/library/functions.html#repr) для строки. Это не влияет на обработку строк, записываемых в [`sys.stdout`](https://python-all.ru/3.2/library/sys.html#sys.stdout) или [`sys.stderr`](https://python-all.ru/3.2/library/sys.html#sys.stderr).)548549#### `str.isspace()`550551Возвращает true, если в строке есть только пробельные символы и есть хотя бы один символ, иначе false. Пробельные символы – это символы, определённые в базе данных символов Unicode как «Other» или «Separator», а также символы со свойством двунаправленности, являющимся одним из «WS», «B» или «S».552553#### `str.istitle()`554555Возвращает true, если строка является строкой в заглавном регистре (titlecased) и есть хотя бы один символ, например прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. Иначе возвращает false.556557#### `str.isupper()`558559Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.2/library/stdtypes.html#id14) в строке являются прописными и есть хотя бы один буквенный символ, иначе false.560561#### `str.join(iterable)`562563Возвращает строку, которая является объединением строк в [*итерируемый объект*](https://python-all.ru/3.2/glossary.html#term-iterable) *итерируемый объект*. Исключение [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError) будет возбуждено, если в *итерируемый объект* есть значения, не являющиеся строками, включая объекты [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes). Разделителем между элементами служит строка, предоставляющая этот метод.564565#### `str.ljust(width[, fillchar])`566567Возвращает строку, выровненную по левому краю в строке длины *width*. Заполнение выполняется с помощью указанного символа *fillchar* (по умолчанию пробел). Исходная строка возвращается, если *width* меньше или равно `len(s)`.568569#### `str.lower()`570571Возвращает копию строки, в которой все символы, имеющие регистр, [\[4\]](https://python-all.ru/3.2/library/stdtypes.html#id14) преобразованы в нижний регистр.572573#### `str.lstrip([chars])`574575Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом; удаляются все комбинации его значений:576577```python578>>> '   spacious   '.lstrip()579'spacious   '580>>> 'www.example.com'.lstrip('cmowz.')581'example.com'582```583584#### `static str.maketrans(x[, y[, z]])`585586Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.2/library/stdtypes.html#str.translate).587588Если передан только один аргумент, это должен быть словарь, отображающий коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или None. Ключи-символы при этом будут преобразованы в коды.589590Если передано два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ из x будет сопоставлен символу на той же позиции в y. Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены None в результате.591592#### `str.partition(sep)`593594Разделяет строку по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.595596#### `str.replace(old, new[, count])`597598Возвращает копию строки, в которой все вхождения подстроки *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.599600#### `str.rfind(sub[, start[, end]])`601602Возвращает наибольший индекс в строке, на котором найдена подстрока *sub*, такой, что *sub* содержится в `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1` при неудаче.603604#### `str.rindex(sub[, start[, end]])`605606Похож на [`rfind()`](https://python-all.ru/3.2/library/stdtypes.html#str.rfind), но возбуждает [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), когда подстрока *sub* не найдена.607608#### `str.rjust(width[, fillchar])`609610Возвращает строку, выровненную по правому краю в строке длины *width*. Заполнение выполняется с помощью указанного символа *fillchar* (по умолчанию пробел). Исходная строка возвращается, если *width* меньше или равно `len(s)`.611612#### `str.rpartition(sep)`613614Разделяет строку по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.615616#### `str.rsplit([sep[, maxsplit]])`617618Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, причём *справа* Если *sep* не указан или равен `None`, разделителем считается любая строка из пробельных символов. За исключением разбиения справа, [`rsplit()`](https://python-all.ru/3.2/library/stdtypes.html#str.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.2/library/stdtypes.html#str.split), который подробно описан ниже.619620#### `str.rstrip([chars])`621622Возвращает копию строки с удалёнными конечными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является суффиксом; удаляются все комбинации его значений:623624```python625>>> '   spacious   '.rstrip()626'   spacious'627>>> 'mississippi'.rstrip('ipz')628'mississ'629```630631#### `str.split([sep[, maxsplit]])`632633Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то ограничение на количество разбиений отсутствует (выполняются все возможные разбиения).634635Если указан *sep*, то последовательные разделители не объединяются в один, а считаются ограничителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов (например, `'1<>2<>3'.split('<>')` возвращает `['1', '2', '3']`). Разбиение пустой строки с указанным разделителем возвращает `['']`.636637Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и в результате не будет пустых строк в начале или конце, если строка начинается или заканчивается пробелами. Соответственно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.638639Например, `' 1 2 3 '.split()'` возвращает `['1', '2', '3']`, а `' 1 2 3 '.split(None, 1)` возвращает `['1', '2 3 ']`.640641#### `str.splitlines([keepends])`642643Возвращает список строк из строки, разбивая по границам строк. Этот метод использует подход [*универсальных новых строк*](https://python-all.ru/3.2/glossary.html#term-universal-newlines) для разбиения строк. Символы перевода строки не включаются в результирующий список, если только *keepends* не задан и истинен.644645Например, `'ab c\n\nde fg\rkl\r\n'.splitlines()` возвращает `['ab c', '', 'de fg', 'kl']`, а тот же вызов с `splitlines(True)` возвращает `['ab c\n', '\n', 'de fg\r', 'kl\r\n']`.646647В отличие от [`split()`](https://python-all.ru/3.2/library/stdtypes.html#str.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и конечный перевод строки не приводит к добавлению дополнительной строки.648649#### `str.startswith(prefix[, start[, end]])`650651Возвращает `True`, если строка начинается с префикса *prefix*, иначе возвращает `False`. *prefix* также может быть кортежем искомых префиксов. С необязательным *start* проверка начинается с указанной позиции. С необязательным *end* сравнение строки завершается на указанной позиции.652653#### `str.strip([chars])`654655Возвращает копию строки с удалёнными ведущими и завершающими символами. Аргумент *chars* – строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:656657```python658>>> '   spacious   '.strip()659'spacious'660>>> 'www.example.com'.strip('cmowz.')661'example'662```663664#### `str.swapcase()`665666Возвращает копию строки, в которой символы верхнего регистра преобразованы в нижний и наоборот.667668#### `str.title()`669670Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.671672Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:673674```python675>>> "they're bill's friends from the UK".title()676"They'Re Bill'S Friends From The Uk"677```678679Обходной путь для апострофов можно построить с помощью регулярных выражений:680681```python682>>> import re683>>> def titlecase(s):684...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",685...                   lambda mo: mo.group(0)[0].upper() +686...                              mo.group(0)[1:].lower(),687...                   s)688...689>>> titlecase("they're bill's friends.")690"They're Bill's Friends."691```692693#### `str.translate(map)`694695Возвращает копию *s*, в которой все символы преобразованы с помощью *map*, который должен быть словарём, отображающим коды Unicode (целые числа) в коды Unicode, строки или `None`. Неотображённые символы остаются без изменений. Символы, отображённые на `None`, удаляются.696697Для создания таблицы трансляции из символьных отображений в разных форматах можно использовать [`str.maketrans()`](https://python-all.ru/3.2/library/stdtypes.html#str.maketrans).698699> **Примечание**700>701> Ещё более гибкий подход – создать собственный кодек отображения символов с помощью модуля [`codecs`](https://python-all.ru/3.2/library/codecs.html#module-codecs) (см. `encodings.cp1251` в качестве примера).702703#### `str.upper()`704705Возвращает копию строки, в которой все буквенные символы [\[4\]](https://python-all.ru/3.2/library/stdtypes.html#id14) преобразованы в верхний регистр. Обратите внимание, что `str.upper().isupper()` может быть `False`, если `s` содержит символы без регистра или если категория Unicode результирующего символа не «Lu» (буква верхнего регистра), а, например, «Lt» (буква заглавная).706707#### `str.zfill(width)`708709Возвращает числовую строку, дополненную слева нулями до длины *width*. Знак префикса обрабатывается корректно. Исходная строка возвращается, если *width* меньше или равно `len(s)`.710711### 4.6.2. Старые операции форматирования строк712713> **Примечание**714>715> Описанные здесь операции форматирования основаны на синтаксисе printf() в C. Они поддерживают форматирование только некоторых встроенных типов. Использование бинарного оператора означает, что может потребоваться осторожность для правильного форматирования кортежей и словарей. Поскольку синтаксис нового [*Форматирование строк*](https://python-all.ru/3.2/library/string.html#string-formatting) более гибок и естественно работает с кортежами и словарями, его рекомендуется использовать в новом коде. Однако в настоящее время нет планов по прекращению поддержки printf-стиля форматирования.716717Строковые объекты имеют одну уникальную встроенную операцию: оператор `%` (modulo). Он также известен как оператор *форматирования* или *интерполяции* строк. При использовании `format % values` (где *format* – это строка), спецификации преобразования `%` в строке *format* заменяются на ноль или более элементов из *values*. Результат аналогичен использованию `sprintf()` в языке C.718719Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [\[5\]](https://python-all.ru/3.2/library/stdtypes.html#id15) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).720721Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:7227231. Символ `'%'`, обозначающий начало спецификатора.7242. Ключ отображения (необязательно), состоящий из последовательности символов в скобках (например, `(somename)`).7253. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.7264. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.7275. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.7286. Модификатор длины (необязательно).7297. Тип преобразования.730731Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:732733```python734>>> print('%(language)s has %(number)03d quote types.' %735...       {'language': "Python", "number": 2})736Python has 002 quote types.737```738739В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).740741Символы флагов преобразования:742743| Флаг | Значение |744| --- | --- |745| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |746| `'0'` | Для числовых значений преобразование будет дополняться нулями. |747| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |748| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |749| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |750751Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, так как не нужен для Python – например, `%ld` идентично `%d`.752753Типы преобразования:754755| Преобразование | Значение | Примечания |756| --- | --- | --- |757| `'d'` | Десятичное целое со знаком. |  |758| `'i'` | Десятичное целое со знаком. |  |759| `'o'` | Восьмеричное значение со знаком. | (1) |760| `'u'` | Устаревший тип – он идентичен `'d'`. | (7) |761| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |762| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |763| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |764| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |765| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |766| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |767| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |768| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |769| `'c'` | Один символ (принимает целое число или строку из одного символа). |  |770| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.2/library/functions.html#repr)). | (5) |771| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.2/library/functions.html#str)). | (5) |772| `'a'` | Строка (преобразует любой объект Python с помощью [`ascii()`](https://python-all.ru/3.2/library/functions.html#ascii)). | (5) |773| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |774775Примечания:7767771. Альтернативная форма приводит к вставке ведущего нуля (`'0'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.7782. Альтернативная форма приводит к вставке ведущего `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.7793. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.780781   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.7824. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.783784   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.7855. Если точность равна `N`, вывод обрезается до `N` символов.7867877. См. [**PEP 237**](https://python-all.ru/3.2/library/stdtypes.html).788789Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.790791Изменено в версии 3.1: преобразования `%f` для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.792793Дополнительные строковые операции определены в стандартных модулях [`string`](https://python-all.ru/3.2/library/string.html#module-string) и [`re`](https://python-all.ru/3.2/library/re.html#module-re).794795### 4.6.3. Тип range796797Тип [`range`](https://python-all.ru/3.2/library/functions.html#range) – это неизменяемая последовательность, обычно используемая для циклических итераций. Преимущество типа [`range`](https://python-all.ru/3.2/library/functions.html#range) заключается в том, что объект [`range`](https://python-all.ru/3.2/library/functions.html#range) всегда будет занимать один и тот же объём памяти, независимо от размера диапазона, который он представляет.798799Объекты range имеют относительно немного поведения: они поддерживают индексацию, проверку вхождения, итерацию, функцию [`len()`](https://python-all.ru/3.2/library/functions.html#len) и следующие методы:800801#### `range.count(x)`802803Возвращает количество *i*, для которых `s[i] == x`.804805> Новое в версии 3.2.806807#### `range.index(x)`808809Возвращает наименьшее *i*, такое что `s[i] == x`. Возбуждает [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), если *x* отсутствует в диапазоне.810811> Новое в версии 3.2.812813### 4.6.4. Изменяемые типы последовательностей814815Объекты list и bytearray поддерживают дополнительные операции, позволяющие изменять объект на месте. Другие изменяемые типы последовательностей (если они будут добавлены в язык) также должны поддерживать эти операции. Строки и кортежи являются неизменяемыми типами последовательностей: такие объекты нельзя изменить после создания. Для изменяемых типов последовательностей определены следующие операции (где *x* – произвольный объект).816817Обратите внимание: хотя списки допускают элементы любого типа, «элементы» объекта bytearray – это целые числа в диапазоне 0 \<= x \< 256.818819| Операция | Результат | Примечания |820| --- | --- | --- |821| `s[i] = x` | элемент *i* из *s* заменяется на *x* |  |822| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* |  |823| `del s[i:j]` | то же, что `s[i:j] = []` |  |824| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами *t* | (1) |825| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка |  |826| `s.append(x)` | то же, что и `s[len(s):len(s)] = [x]` |  |827| `s.extend(x)` | то же, что и `s[len(s):len(s)] = x` | (2) |828| `s.count(x)` | возвращает количество *i*, для которых `s[i] == x` |  |829| `s.index(x[, i[, j]])` | возвращает наименьшее *k*, такое что `s[k] == x` и `i <= k < j` | (3) |830| `s.insert(i, x)` | то же, что и `s[i:i] = [x]` | (4) |831| `s.pop([i])` | то же, что и `x = s[i]; del s[i]; return x` | (5) |832| `s.remove(x)` | то же, что и `del s[s.index(x)]` | (3) |833| `s.reverse()` | переворачивает элементы *s* на месте | (6) |834| `s.sort([key[, reverse]])` | сортирует элементы *s* на месте | (6), (7), (8) |835836Примечания:8378381. *t* должен иметь ту же длину, что и заменяемый срез.8392. *x* может быть любым итерируемым объектом.8403. Возбуждает [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), если *x* не найден в *s*. Когда отрицательный индекс передаётся вторым или третьим параметром метода `index()`, к нему добавляется длина последовательности, как для срезов. Если он всё ещё отрицательный, он усекается до нуля, как для срезов.8414. Когда отрицательный индекс передаётся первым параметром методу `insert()`, к нему добавляется длина последовательности, как для срезов. Если он всё ещё отрицательный, он усекается до нуля, как для срезов.8425. Необязательный аргумент *i* по умолчанию равен `-1`, поэтому по умолчанию удаляется и возвращается последний элемент.8436. The `sort()` and `reverse()` methods modify the sequence in place for economy of space when sorting or reversing a large sequence. To remind you that they operate by side effect, they don’t return the sorted or reversed sequence.8447. Метод `sort()` принимает необязательные аргументы для управления сравнениями. Каждый должен быть указан как именованный аргумент.845846   *key* задаёт функцию одного аргумента, которая извлекает ключ сравнения из каждого элемента списка: `key=str.lower`. Значение по умолчанию – `None`. Используйте [`functools.cmp_to_key()`](https://python-all.ru/3.2/library/functools.html#functools.cmp_to_key), чтобы преобразовать старую функцию сравнения *cmp* в функцию *key*.847848   *reverse* – логическое значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.849850   Метод `sort()` гарантированно является устойчивым. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые считаются равными – это полезно при сортировке в несколько проходов (например, сначала по отделу, затем по уровню зарплаты).851852   **Особенность реализации CPython:** Во время сортировки списка результат попытки изменить или даже просмотреть список не определён. C-реализация Python делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.8538. Метод `sort()` не поддерживается объектами [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray).854855### 4.6.5. Методы bytes и bytearray856857Объекты bytes и bytearray, будучи «строками байтов», имеют все методы, доступные для строк, за исключением `encode()`, [`format()`](https://python-all.ru/3.2/library/functions.html#format) и `isidentifier()`, которые не имеют смысла для этих типов. Для преобразования объектов в строки у них есть метод `decode()`.858859Если какому-либо из этих методов требуется интерпретировать байты как символы (например, методы `is...()`), предполагается набор символов ASCII.860861> **Примечание**862>863> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать864>865> ```python866> a = "abc"867> b = a.replace("a", "f")868> ```869>870> и871>872> ```python873> a = b"abc"874> b = a.replace(b"a", b"f")875> ```876877#### `bytes.decode(encoding="utf-8", errors="strict")`878879#### `bytearray.decode(encoding="utf-8", errors="strict")`880881Возвращает строку, декодированную из заданных байтов. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* можно задать для выбора другой схемы обработки ошибок. По умолчанию *errors* равен `'strict'`, что означает, что ошибки кодирования вызывают [`UnicodeError`](https://python-all.ru/3.2/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.2/library/codecs.html#codecs.register_error); см. раздел [*Базовые классы кодеков*](https://python-all.ru/3.2/library/codecs.html#codec-base-classes). Список возможных кодировок – в разделе [*Стандартные кодировки*](https://python-all.ru/3.2/library/codecs.html#standard-encodings).882883Изменено в версии 3.1: Добавлена поддержка именованных аргументов.884885Типы bytes и bytearray имеют дополнительный метод класса:886887#### `classmethod bytes.fromhex(string)`888889#### `classmethod bytearray.fromhex(string)`890891Этот метод класса [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) возвращает объект bytes или bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, пробелы игнорируются.892893```python894>>> bytes.fromhex('f0 f1f2  ')895b'\xf0\xf1\xf2'896```897898Методы maketrans и translate отличаются семантикой от версий, доступных для строк:899900#### `bytes.translate(table[, delete])`901902#### `bytearray.translate(table[, delete])`903904Возвращает копию объекта bytes или bytearray, из которой удалены все байты, входящие в необязательный аргумент *delete*, а оставшиеся байты преобразованы через заданную таблицу перевода, которая должна быть объектом bytes длиной 256.905906Для создания таблицы перевода можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.2/library/stdtypes.html#bytes.maketrans).907908Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:909910```python911>>> b'read this short text'.translate(None, b'aeiou')912b'rd ths shrt txt'913```914915#### `static bytes.maketrans(from, to)`916917#### `static bytearray.maketrans(from, to)`918919Этот статический метод возвращает таблицу перевода, пригодную для использования в [`bytes.translate()`](https://python-all.ru/3.2/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* должны быть объектами bytes и иметь одинаковую длину.920921Новое в версии 3.1.922923## 4.7. Типы множеств – [`set`](https://python-all.ru/3.2/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset)924925Объект *set* – это неупорядоченная коллекция уникальных [*хэшируемых*](https://python-all.ru/3.2/glossary.html#term-hashable) объектов. Обычное применение включает проверку принадлежности, удаление дубликатов из последовательности и вычисление математических операций, таких как пересечение, объединение, разность и симметрическая разность. (О других контейнерах см. встроенные классы [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.2/library/functions.html#list) и [`tuple`](https://python-all.ru/3.2/library/functions.html#tuple), а также модуль [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections).)926927Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множества не сохраняют позицию элемента или порядок вставки. Соответственно, множества не поддерживают индексацию, срезы или другое поведение, подобное последовательностям.928929В настоящее время существует два встроенных типа множеств: [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset). Тип [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) является изменяемым – содержимое можно изменять с помощью методов, таких как `add()` и `remove()`. Поскольку он изменяем, у него нет хэш-значения, и он не может использоваться ни в качестве ключа словаря, ни в качестве элемента другого множества. Тип [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset) является неизменяемым и [*хэшируемым*](https://python-all.ru/3.2/glossary.html#term-hashable) – его содержимое не может быть изменено после создания; поэтому его можно использовать как ключ словаря или как элемент другого множества.930931Непустые множества (не frozenset) можно создать, перечислив элементы через запятую в фигурных скобках, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.2/library/stdtypes.html#set).932933Конструкторы обоих классов работают одинаково:934935#### `class set([iterable])`936937#### `class frozenset([iterable])`938939Возвращает новый объект set или frozenset, элементы которого берутся из *iterable*. Элементы множества должны быть хэшируемыми. Для представления множеств множеств внутренние множества должны быть объектами [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset). Если *iterable* не указан, возвращается новое пустое множество.940941Instances of [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset) provide the following operations:942943#### `len(s)`944945Return the cardinality of set *s*.946947#### `x in s`948949Проверяет принадлежность *x* множеству *s*.950951#### `x not in s`952953Проверяет отсутствие *x* в множестве *s*.954955#### `isdisjoint(other)`956957Возвращает True, если множество не имеет общих элементов с *other*. Множества являются непересекающимися тогда и только тогда, когда их пересечение является пустым множеством.958959#### `issubset(other)`960961#### `set <= other`962963Проверяет, принадлежит ли каждый элемент множества множеству *other*.964965#### `set < other`966967Test whether the set is a proper subset of *other*, that is, `set <= other and set != other`.968969#### `issuperset(other)`970971#### `set >= other`972973Проверяет, принадлежит ли каждый элемент *other* множеству.974975#### `set > other`976977Test whether the set is a proper superset of *other*, that is, `set >= other and set != other`.978979#### `union(other, ...)`980981#### `set | other | ...`982983Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.984985#### `intersection(other, ...)`986987#### `set & other & ...`988989Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.990991#### `difference(other, ...)`992993#### `set - other - ...`994995Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.996997#### `symmetric_difference(other)`998999#### `set ^ other`10001001Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в *other*, но не в обоих.10021003#### `copy()`10041005Возвращает новое множество с поверхностной копией *s*.10061007Note, the non-operator versions of [`union()`](https://python-all.ru/3.2/library/stdtypes.html#set.union), [`intersection()`](https://python-all.ru/3.2/library/stdtypes.html#set.intersection), [`difference()`](https://python-all.ru/3.2/library/stdtypes.html#set.difference), and [`symmetric_difference()`](https://python-all.ru/3.2/library/stdtypes.html#set.symmetric_difference), [`issubset()`](https://python-all.ru/3.2/library/stdtypes.html#set.issubset), and [`issuperset()`](https://python-all.ru/3.2/library/stdtypes.html#set.issuperset) methods will accept any iterable as an argument. In contrast, their operator based counterparts require their arguments to be sets. This precludes error-prone constructions like `set('abc') & 'cbs'` in favor of the more readable `set('abc').intersection('cbs')`.10081009Both [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset) support set to set comparisons. Two sets are equal if and only if every element of each set is contained in the other (each is a subset of the other). A set is less than another set if and only if the first set is a proper subset of the second set (is a subset, but is not equal). A set is greater than another set if and only if the first set is a proper superset of the second set (is a superset, but is not equal).10101011Instances of [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) are compared to instances of [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset) based on their members. For example, `set('abc') == frozenset('abc')` returns `True` and so does `set('abc') in set([frozenset('abc')])`.10121013Сравнения на подмножество и равенство не обобщаются до функции полного упорядочивания. Например, любые два непересекающихся множества не равны и не являются подмножествами друг друга, поэтому *all* из следующих возвращают `False`: `a<b`, `a==b` или `a>b`.10141015Поскольку множества определяют только частичный порядок (отношения подмножеств), результат метода `list.sort()` для списков множеств не определён.10161017Элементы множества, как и ключи словаря, должны быть [*хэшируемыми*](https://python-all.ru/3.2/glossary.html#term-hashable).10181019Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset).10201021В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.2/library/stdtypes.html#set), которые не применяются к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset):10221023#### `update(other, ...)`10241025#### `set |= other | ...`10261027Обновляет множество, добавляя элементы из всех других.10281029#### `intersection_update(other, ...)`10301031#### `set &= other & ...`10321033Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.10341035#### `difference_update(other, ...)`10361037#### `set -= other | ...`10381039Обновляет множество, удаляя элементы, найденные в других.10401041#### `symmetric_difference_update(other)`10421043#### `set ^= other`10441045Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.10461047#### `add(elem)`10481049Добавляет элемент *elem* в множество.10501051#### `remove(elem)`10521053Удаляет элемент *elem* из множества. Вызывает [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError), если *elem* не содержится во множестве.10541055#### `discard(elem)`10561057Удаляет элемент *elem* из множества, если он присутствует.10581059#### `pop()`10601061Удаляет и возвращает произвольный элемент из множества. Вызывает [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError), если множество пусто.10621063#### `clear()`10641065Удаляет все элементы из множества.10661067Обратите внимание: версии методов [`update()`](https://python-all.ru/3.2/library/stdtypes.html#set.update), [`intersection_update()`](https://python-all.ru/3.2/library/stdtypes.html#set.intersection_update), [`difference_update()`](https://python-all.ru/3.2/library/stdtypes.html#set.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.2/library/stdtypes.html#set.symmetric_difference_update), не использующие операторы, принимают любой итерируемый объект в качестве аргумента.10681069Обратите внимание: аргумент *elem* методов [`__contains__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.2/library/stdtypes.html#set.remove) и [`discard()`](https://python-all.ru/3.2/library/stdtypes.html#set.discard) может быть множеством. Для поддержки поиска эквивалентного неизменяемого множества (frozenset) множество *elem* временно изменяется во время поиска, а затем восстанавливается. Во время поиска не следует читать или изменять множество *elem*, так как оно не имеет осмысленного значения.10701071## 4.8. Типы отображений – [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict)10721073Объект [*отображения*](https://python-all.ru/3.2/glossary.html#term-mapping) сопоставляет [*хешируемые*](https://python-all.ru/3.2/glossary.html#term-hashable) значения с произвольными объектами. Отображения – изменяемые объекты. В настоящее время существует только один стандартный тип отображения – *словарь*. (Другие контейнеры: встроенные классы [`list`](https://python-all.ru/3.2/library/functions.html#list), [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.2/library/functions.html#tuple), а также модуль [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections).)10741075Ключи словаря могут быть *почти* любыми значениями. Значения, которые не являются [*хэшируемыми*](https://python-all.ru/3.2/glossary.html#term-hashable), то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, `1` и `1.0`), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)10761077Словари можно создать, поместив разделённый запятыми список пар `ключ: значение` в фигурные скобки, например: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`, или с помощью конструктора [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict).10781079#### `class dict(**kwarg)`10801081#### `class dict(mapping, **kwarg)`10821083#### `class dict(iterable, **kwarg)`10841085Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.10861087Если позиционный аргумент не передан, создаётся пустой словарь. Если позиционный аргумент передан и является отображением (mapping), создаётся словарь с теми же парами ключ-значение, что и у объекта-отображения. В противном случае позиционный аргумент должен быть [*итератором*](https://python-all.ru/3.2/glossary.html#term-iterator). Каждый элемент итерируемого объекта сам должен быть итератором ровно из двух объектов. Первый объект каждого элемента становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.10881089Если переданы именованные аргументы, они и их значения добавляются в словарь, созданный из позиционного аргумента. Если добавляемый ключ уже присутствует, значение из именованного аргумента заменяет значение из позиционного аргумента.10901091В качестве иллюстрации следующие примеры все возвращают словарь, равный `{"one": 1, "two": 2, "three": 3}`:10921093```python1094>>> a = dict(one=1, two=2, three=3)1095>>> b = {'one': 1, 'two': 2, 'three': 3}1096>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))1097>>> d = dict([('two', 2), ('one', 1), ('three', 3)])1098>>> e = dict({'three': 3, 'one': 1, 'two': 2})1099>>> a == b == c == d == e1100True1101```11021103Передача именованных аргументов, как в первом примере, работает только для ключей, являющихся допустимыми идентификаторами Python. В противном случае можно использовать любые допустимые ключи.11041105Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):11061107#### `len(d)`11081109Возвращает количество элементов в словаре *d*.11101111#### `d[key]`11121113Возвращает элемент *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError), если *key* отсутствует в отображении.11141115Если подкласс dict определяет метод `__missing__()`, то если ключ *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает то, что было возвращено или возбуждено вызовом `__missing__(key)`, если ключ отсутствует. Никакие другие операции или методы не вызывают `__missing__()`. Если `__missing__()` не определён, возбуждается [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError). `__missing__()` должен быть методом; он не может быть переменной экземпляра:11161117```python1118>>> class Counter(dict):1119...     def __missing__(self, key):1120...         return 01121>>> c = Counter()1122>>> c['red']112301124>>> c['red'] += 11125>>> c['red']112611127```11281129Смотрите [`collections.Counter`](https://python-all.ru/3.2/library/collections.html#collections.Counter) для полной реализации, включающей другие методы, полезные для накопления и управления подсчётами.11301131#### `d[key] = value`11321133Устанавливает `d[key]` в *value*.11341135#### `del d[key]`11361137Remove `d[key]` from *d*. Raises a [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError) if *key* is not in the map.11381139#### `key in d`11401141Возвращает `True`, если *d* содержит ключ *key*, иначе `False`.11421143#### `key not in d`11441145Эквивалентно `not key in d`.11461147#### `iter(d)`11481149Возвращает итератор по ключам словаря. Это более короткая запись для `iter(d.keys())`.11501151#### `clear()`11521153Удаляет все элементы из словаря.11541155#### `copy()`11561157Возвращает поверхностную копию словаря.11581159#### `classmethod fromkeys(seq[, value])`11601161Создаёт новый словарь, ключи которого берутся из *seq*, а значения устанавливаются равными *value*.11621163[`fromkeys()`](https://python-all.ru/3.2/library/stdtypes.html#dict.fromkeys) – это метод класса, который возвращает новый словарь. *value* по умолчанию равен `None`.11641165#### `get(key[, default])`11661167Возвращает значение для *key*, если *key* есть в словаре, иначе *default*. Если *default* не указан, он по умолчанию равен `None`, так что этот метод никогда не вызывает [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError).11681169#### `items()`11701171Возвращает новое представление элементов словаря (пары `(key, value)`). См. ниже документацию объектов представления.11721173#### `keys()`11741175Возвращает новое представление ключей словаря. См. ниже документацию объектов представления.11761177#### `pop(key[, default])`11781179Если *key* есть в словаре, удаляет его и возвращает его значение, иначе возвращает *default*. Если *default* не указан и *key* отсутствует в словаре, вызывается [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError).11801181#### `popitem()`11821183Удаляет и возвращает произвольную пару `(key, value)` из словаря.11841185[`popitem()`](https://python-all.ru/3.2/library/stdtypes.html#dict.popitem) удобна для разрушающего перебора словаря, что часто используется в алгоритмах над множествами. Если словарь пуст, вызов [`popitem()`](https://python-all.ru/3.2/library/stdtypes.html#dict.popitem) вызывает [`KeyError`](https://python-all.ru/3.2/library/exceptions.html#KeyError).11861187#### `setdefault(key[, default])`11881189Если *key* есть в словаре, возвращает его значение. Если нет, вставляет *key* со значением *default* и возвращает *default*. *default* по умолчанию равен `None`.11901191#### `update([other])`11921193Обновляет словарь парами ключ/значение из *other*, перезаписывая существующие ключи. Возвращает `None`.11941195[`update()`](https://python-all.ru/3.2/library/stdtypes.html#dict.update) принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (кортежи или другие итерабельные объекты длиной два). Если указаны именованные аргументы, словарь обновляется этими парами ключ/значение: `d.update(red=1, blue=2)`.11961197#### `values()`11981199Возвращает новое представление значений словаря. См. ниже документацию объектов представления.12001201### 4.8.1. Объекты представления словаря12021203Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.2/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.2/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.2/library/stdtypes.html#dict.items), являются *представлениями*. Они предоставляют динамическое представление содержимого словаря: при изменении словаря представление отражает эти изменения.12041205Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:12061207#### `len(dictview)`12081209Возвращает количество записей в словаре.12101211#### `iter(dictview)`12121213Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) словаря.12141215Ключи и значения итерируются в произвольном порядке, который не является случайным, варьируется в разных реализациях Python и зависит от истории вставок и удалений в словаре. Если представления ключей, значений и элементов итерируются без промежуточных изменений словаря, порядок элементов будет прямо соответствовать друг другу. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.2/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать тот же список: `pairs = [(v, k) for (k, v) in d.items()]`.12161217Итерация по представлениям во время добавления или удаления записей в словаре может вызвать [`RuntimeError`](https://python-all.ru/3.2/library/exceptions.html#RuntimeError) или не выполнить итерацию по всем записям.12181219#### `x in dictview`12201221Возвращает `True`, если *x* находится среди ключей, значений или элементов базового словаря (в последнем случае *x* должен быть кортежем `(key, value)`).12221223Представления ключей подобны множествам, поскольку их элементы уникальны и хешируемы. Если все значения хешируемы, так что пары `(key, value)` уникальны и хешируемы, то представление элементов также подобно множеству. (Представления значений не рассматриваются как подобные множествам, поскольку их элементы, как правило, не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса [`collections.Set`](https://python-all.ru/3.2/library/collections.html#collections.Set) (например, `==`, `<` или `^`).12241225Пример использования представления словаря:12261227```python1228>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}1229>>> keys = dishes.keys()1230>>> values = dishes.values()12311232>>> # итерация1233>>> n = 01234>>> for val in values:1235...     n += val1236>>> print(n)123750412381239>>> # ключи и значения перебираются в одном и том же порядке1240>>> list(keys)1241['eggs', 'bacon', 'sausage', 'spam']1242>>> list(values)1243[2, 1, 1, 500]12441245>>> # объекты представления динамичны и отражают изменения словаря1246>>> del dishes['eggs']1247>>> del dishes['sausage']1248>>> list(keys)1249['spam', 'bacon']12501251>>> # операции над множествами1252>>> keys & {'eggs', 'bacon', 'salad'}1253{'bacon'}1254>>> keys ^ {'sausage', 'juice'}1255{'juice', 'sausage', 'bacon', 'spam'}1256```12571258## 4.9. Тип memoryview12591260Объекты [`memoryview`](https://python-all.ru/3.2/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [*протокол буфера*](https://python-all.ru/3.2/c-api/buffer.html#bufferobjects), без копирования. Память обычно интерпретируется как простые байты.12611262#### `class memoryview(obj)`12631264Создаёт [`memoryview`](https://python-all.ru/3.2/library/stdtypes.html#memoryview), ссылающийся на *obj*. *obj* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray).12651266[`memoryview`](https://python-all.ru/3.2/library/stdtypes.html#memoryview) имеет понятие *элемента* – атомарной единицы памяти, с которой работает исходный объект *obj*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray), элемент представляет собой один байт, но другие типы, такие как [`array.array`](https://python-all.ru/3.2/library/array.html#array.array), могут иметь элементы большего размера.12671268`len(view)` возвращает общее количество элементов в memoryview, *view*. Атрибут [`itemsize`](https://python-all.ru/3.2/library/stdtypes.html#memoryview.itemsize) выдаёт количество байтов в одном элементе.12691270[`memoryview`](https://python-all.ru/3.2/library/stdtypes.html#memoryview) поддерживает срезы для раскрытия своих данных. Обращение по одному индексу возвращает один элемент в виде объекта [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes). Полный срез даёт подпредставление:12711272```python1273>>> v = memoryview(b'abcefg')1274>>> v[1]1275b'b'1276>>> v[-1]1277b'g'1278>>> v[1:4]1279<memory at 0x77ab28>1280>>> bytes(v[1:4])1281b'bce'1282```12831284Если объект, над которым создано memoryview, допускает изменение своих данных, memoryview поддерживает присваивание срезу:12851286```python1287>>> data = bytearray(b'abcefg')1288>>> v = memoryview(data)1289>>> v.readonly1290False1291>>> v[0] = b'z'1292>>> data1293bytearray(b'zbcefg')1294>>> v[1:4] = b'123'1295>>> data1296bytearray(b'z123fg')1297>>> v[2] = b'spam'1298Traceback (most recent call last):1299  File "<stdin>", line 1, in <module>1300ValueError: cannot modify size of memoryview object1301```13021303Обратите внимание, что размер объекта memoryview изменить нельзя.13041305[`memoryview`](https://python-all.ru/3.2/library/stdtypes.html#memoryview) имеет несколько методов:13061307#### `tobytes()`13081309Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) для данного представления памяти.13101311```python1312>>> m = memoryview(b"abc")1313>>> m.tobytes()1314b'abc'1315>>> bytes(m)1316b'abc'1317```13181319#### `tolist()`13201321Возвращает данные из буфера в виде списка целых чисел.13221323```python1324>>> memoryview(b'abc').tolist()1325[97, 98, 99]1326```13271328#### `release()`13291330Освобождает базовый буфер, предоставленный объектом memoryview. Многие объекты выполняют специальные действия, пока на них удерживается представление (например, [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray) временно запрещает изменение размера); поэтому вызов release() удобен для снятия этих ограничений (и освобождения любых висящих ресурсов) как можно скорее.13311332После вызова этого метода любая дальнейшая операция над представлением вызывает исключение [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError) (за исключением самого [`release()`](https://python-all.ru/3.2/library/stdtypes.html#memoryview.release), который можно вызывать многократно):13331334```python1335>>> m = memoryview(b'abc')1336>>> m.release()1337>>> m[0]1338Traceback (most recent call last):1339  File "<stdin>", line 1, in <module>1340ValueError: operation forbidden on released memoryview object1341```13421343Протокол управления контекстом можно использовать для аналогичного эффекта, применяя оператор `with`:13441345```python1346>>> with memoryview(b'abc') as m:1347...     m[0]1348...1349b'a'1350>>> m[0]1351Traceback (most recent call last):1352  File "<stdin>", line 1, in <module>1353ValueError: operation forbidden on released memoryview object1354```13551356Новое в версии 3.2.13571358Также доступно несколько атрибутов только для чтения:13591360#### `format`13611362Строка, содержащая формат (в стиле модуля [`struct`](https://python-all.ru/3.2/library/struct.html#module-struct)) для каждого элемента в представлении. По умолчанию это `'B'`, простая байтовая строка.13631364#### `itemsize`13651366Размер в байтах каждого элемента memoryview:13671368```python1369>>> m = memoryview(array.array('H', [1,2,3]))1370>>> m.itemsize137121372>>> m[0]1373b'\x01\x00'1374>>> len(m[0]) == m.itemsize1375True1376```13771378#### `shape`13791380Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.2/library/stdtypes.html#memoryview.ndim), задающий форму памяти как N-мерный массив.13811382#### `ndim`13831384Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.13851386#### `strides`13871388Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.2/library/stdtypes.html#memoryview.ndim), задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.13891390#### `readonly`13911392Логическое значение bool, указывающее, доступна ли память только для чтения.13931394## 4.10. Типы менеджеров контекста13951396Оператор [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with) в Python поддерживает концепцию контекста выполнения, определяемого менеджером контекста. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который вводится перед выполнением тела оператора и завершается при окончании оператора:13971398#### `contextmanager.__enter__()`13991400Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, привязывается к идентификатору в предложении [`as`](https://python-all.ru/3.2/reference/compound_stmts.html#as) оператора [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with), использующего данный менеджер контекста.14011402Примером менеджера контекста, который возвращает самого себя, является [*файловый объект*](https://python-all.ru/3.2/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить [`open()`](https://python-all.ru/3.2/library/functions.html#open) использовать в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with).14031404Примером менеджера контекста, возвращающего связанный объект, является тот, который возвращается [`decimal.localcontext()`](https://python-all.ru/3.2/library/decimal.html#decimal.localcontext). Эти менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста, а затем возвращают копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with), не затрагивая код вне оператора [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with).14051406#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`14071408Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если во время выполнения тела оператора [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with) произошло исключение, аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.14091410Возврат истинного значения из этого метода заставит оператор [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with) подавить исключение и продолжить выполнение с оператора, следующего непосредственно за оператором [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with). В противном случае исключение продолжает распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, произошедшее в теле оператора [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with).14111412Переданное исключение никогда не следует явно возбуждать повторно – вместо этого метод должен возвращать ложное значение, показывая, что метод выполнен успешно и не подавляет возникшее исключение. Это позволяет коду управления контекстом (например, `contextlib.nested`) легко определить, завершился ли метод [`__exit__()`](https://python-all.ru/3.2/library/stdtypes.html#contextmanager.__exit__) неудачей.14131414Python определяет несколько менеджеров контекста для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов и более простого управления активным десятичным контекстом. Конкретные типы не обрабатываются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.2/library/contextlib.html#module-contextlib) для примеров.14151416[*Генераторы*](https://python-all.ru/3.2/glossary.html#term-generator) Python и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.2/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором [`contextlib.contextmanager`](https://python-all.ru/3.2/library/contextlib.html#contextlib.contextmanager), она вернёт менеджер контекста, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__), а не итератор, создаваемый недекорированной функцией-генератором.14171418Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.14191420## 4.11. Другие встроенные типы14211422Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.14231424### 4.11.1. Модули14251426Единственная специальная операция над модулем – это доступ к атрибуту: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.2/reference/simple_stmts.html#import), строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, скорее он требует (внешнего) *определения* для модуля с именем *foo* где-либо.)14271428Специальный атрибут каждого модуля – `__dict__`. Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически меняет таблицу символов модуля, но прямое присваивание атрибуту `__dict__` невозможно (можно написать `m.__dict__['a'] = 1`, что определяет `m.a` равным `1`, но нельзя написать `m.__dict__ = {}`). Прямое изменение `__dict__` не рекомендуется.14291430Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.14311432### 4.11.2. Классы и экземпляры классов14331434См. [*Объекты, значения и типы*](https://python-all.ru/3.2/reference/datamodel.html#objects) и [*Определения классов*](https://python-all.ru/3.2/reference/compound_stmts.html#class).14351436### 4.11.3. Функции14371438Объекты функций создаются определениями функций. Единственная операция над объектом функции – это его вызов: `func(argument-list)`.14391440На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.14411442Дополнительную информацию см. в разделе [*Определения функций*](https://python-all.ru/3.2/reference/compound_stmts.html#function).14431444### 4.11.4. Методы14451446Методы – это функции, которые вызываются с использованием точечной нотации. Существует две разновидности: встроенные методы (например, `append()` у списков) и методы экземпляров классов. Встроенные методы описываются вместе с типами, которые их поддерживают.14471448Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, получается специальный объект: объект *связанного метода* (также называемый *методом экземпляра*). При вызове он добавляет аргумент `self` в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: `m.__self__` – это объект, над которым выполняется метод, а `m.__func__` – это функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.14491450Как и объекты функций, объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции (`meth.__func__`), установка атрибутов метода на связанных методах запрещена. Попытка установить атрибут у метода приводит к возбуждению [`AttributeError`](https://python-all.ru/3.2/library/exceptions.html#AttributeError). Чтобы установить атрибут метода, нужно явно установить его в базовом объекте функции:14511452```python1453>>> class C:1454...     def method(self):1455...         pass1456...1457>>> c = C()1458>>> c.method.whoami = 'my name is method'  # нельзя установить на методе1459Traceback (most recent call last):1460  File "<stdin>", line 1, in <module>1461AttributeError: 'method' object has no attribute 'whoami'1462>>> c.method.__func__.whoami = 'my name is method'1463>>> c.method.whoami1464'my name is method'1465```14661467Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.2/reference/datamodel.html#types).14681469### 4.11.5. Объекты кода14701471Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, например, тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.2/library/functions.html#compile) и могут быть извлечены из объектов функций через их атрибут `__code__`. См. также модуль [`code`](https://python-all.ru/3.2/library/code.html#module-code).14721473Объект кода может быть выполнен или вычислен путём передачи его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.2/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.2/library/functions.html#eval).14741475Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.2/reference/datamodel.html#types).14761477### 4.11.6. Объекты типа14781479Объекты типов представляют различные типы объектов. Тип объекта доступен через встроенную функцию [`type()`](https://python-all.ru/3.2/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.2/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.14801481Типы записываются так: `<class 'int'>`.14821483### 4.11.7. Объект None14841485Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один нулевой объект с именем `None` (встроенное имя).14861487Он записывается как `None`.14881489### 4.11.8. Объект Ellipsis14901491Этот объект обычно используется при срезах (см. [*Slicings*](https://python-all.ru/3.2/reference/expressions.html#slicings)). Он не поддерживает никаких специальных операций. Существует ровно один объект Ellipsis с именем [`Ellipsis`](https://python-all.ru/3.2/library/constants.html#Ellipsis) (встроенное имя).14921493Оно записывается как `Ellipsis` или `...`.14941495### 4.11.9. Объект NotImplemented14961497Этот объект возвращается из сравнений и бинарных операций, когда они применяются к типам, которые их не поддерживают. См. [*Comparisons*](https://python-all.ru/3.2/reference/expressions.html#comparisons) для получения дополнительной информации.14981499Оно записывается как `NotImplemented`.15001501### 4.11.10. Булевы значения15021503Логические значения – это два константных объекта `False` и `True`. Они используются для представления истинностных значений (хотя другие значения также могут считаться ложными или истинными). В числовом контексте (например, при использовании в качестве аргумента арифметического оператора) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция [`bool()`](https://python-all.ru/3.2/library/functions.html#bool) может использоваться для преобразования любого значения в логическое, если это значение может быть интерпретировано как истинностное (см. раздел [*Проверка истинности*](https://python-all.ru/3.2/library/stdtypes.html#truth) выше).15041505Они записываются как `False` и `True` соответственно.15061507### 4.11.11. Внутренние объекты15081509См. [*Стандартная иерархия типов*](https://python-all.ru/3.2/reference/datamodel.html#types) для получения этой информации. В нем описываются объекты стековых кадров, объекты трассировки и объекты срезов.15101511## 4.12. Специальные атрибуты15121513Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где они уместны. Некоторые из них не возвращаются встроенной функцией [`dir()`](https://python-all.ru/3.2/library/functions.html#dir).15141515#### `object.__dict__`15161517Словарь или другой отображающий объект, используемый для хранения (изменяемых) атрибутов объекта.15181519#### `instance.__class__`15201521Класс, которому принадлежит экземпляр класса.15221523#### `class.__bases__`15241525Кортеж базовых классов объекта класса.15261527#### `class.__name__`15281529Имя класса или типа.15301531#### `class.__mro__`15321533Этот атрибут представляет собой кортеж классов, которые учитываются при поиске базовых классов во время разрешения методов.15341535#### `class.mro()`15361537Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в [`__mro__`](https://python-all.ru/3.2/library/stdtypes.html#class.__mro__).15381539#### `class.__subclasses__()`15401541Каждый класс хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех ещё существующих ссылок. Пример:15421543```python1544>>> int.__subclasses__()1545[<class 'bool'>]1546```15471548Сноски15491550| [\[1\]](https://python-all.ru/3.2/library/stdtypes.html#id1) | Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([*Базовая настройка*](https://python-all.ru/3.2/reference/datamodel.html#customization)). |1551| --- | --- |15521553| [\[2\]](https://python-all.ru/3.2/library/stdtypes.html#id2) | Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей. |1554| --- | --- |15551556| [\[3\]](https://python-all.ru/3.2/library/stdtypes.html#id4) | Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов. |1557| --- | --- |15581559| \[4\] | *([1](https://python-all.ru/3.2/library/stdtypes.html#id6), [2](https://python-all.ru/3.2/library/stdtypes.html#id7), [3](https://python-all.ru/3.2/library/stdtypes.html#id8), [4](https://python-all.ru/3.2/library/stdtypes.html#id9))* Символы с регистром – это те, у которых свойство общей категории равно «Lu» (Letter, uppercase), «Ll» (Letter, lowercase) или «Lt» (Letter, titlecase). |1560| --- | --- |15611562| [\[5\]](https://python-all.ru/3.2/library/stdtypes.html#id10) | Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж. |1563| --- | --- |1564