stdtypes.md

1> **Источник:** https://python-all.ru/3.3/library/stdtypes.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 4. Встроенные типы89В следующих разделах описываются стандартные типы, встроенные в интерпретатор.1011Основные встроенные типы: числовые типы, последовательности, отображения, классы, экземпляры и исключения.1213Некоторые классы коллекций являются изменяемыми. Методы, которые добавляют, удаляют или переставляют элементы на месте и не возвращают конкретный элемент, никогда не возвращают сам экземпляр коллекции, а `None`.1415Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать, проверять на истинность и преобразовывать в строку (с помощью функции [`repr()`](https://python-all.ru/3.3/library/functions.html#repr) или несколько отличной функции [`str()`](https://python-all.ru/3.3/library/stdtypes.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.3/library/functions.html#print).1617## 4.1. Проверка истинности1819Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.3/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.3/reference/compound_stmts.html#while) или в качестве операнда логических операций ниже. Следующие значения считаются ложными:2021>2223- `None`24- `False`25- ноль любого числового типа, например, `0`, `0.0`, `0j`.26- любая пустая последовательность, например, `''`, `()`, `[]`.27- любое пустое отображение, например, `{}`.28- экземпляры пользовательских классов, если класс определяет метод [`__bool__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__bool__) или [`__len__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__len__), когда этот метод возвращает целое ноль или логическое значение [`bool`](https://python-all.ru/3.3/library/functions.html#bool) `False`. [\[1\]](https://python-all.ru/3.3/library/stdtypes.html#id10)2930Все остальные значения считаются истинными – поэтому объекты многих типов всегда истинны.3132Операции и встроенные функции, возвращающие логический результат, всегда возвращают `0` или `False` для false и `1` или `True` для true, если не указано иное. (Важное исключение: логические операции `or` и `and` всегда возвращают один из своих операндов.)3334## 4.2. Логические операции – [`and`](https://python-all.ru/3.3/reference/expressions.html#and), [`or`](https://python-all.ru/3.3/reference/expressions.html#or), [`not`](https://python-all.ru/3.3/reference/expressions.html#not)3536Это булевы операции в порядке возрастания приоритета:3738| Операция | Результат | Примечания |39| --- | --- | --- |40| `x or y` | если *x* ложно, то *y*, иначе *x* | (1) |41| `x and y` | если *x* ложно, то *x*, иначе *y* | (2) |42| `not x` | если *x* ложно, то `True`, иначе `False` | (3) |4344Примечания:45461. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`False`](https://python-all.ru/3.3/library/constants.html#False).472. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`True`](https://python-all.ru/3.3/library/constants.html#True).483. `not` имеет более низкий приоритет, чем нелогические операторы, поэтому `not a == b` интерпретируется как `not (a == b)`, а `a == not b` является синтаксической ошибкой.4950## 4.3. Сравнения5152В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (выше, чем у логических операций). Сравнения можно произвольно соединять в цепочки; например, `x < y <= z` эквивалентно `x < y and y <= z`, за исключением того, что *y* вычисляется только один раз (но в обоих случаях *z* не вычисляется вообще, когда `x < y` оказывается ложным).5354В этой таблице приведены операции сравнения:5556| Операция | Значение |57| --- | --- |58| `<` | строго меньше |59| `<=` | меньше или равно |60| `>` | строго больше |61| `>=` | больше или равно |62| `==` | равно |63| `!=` | не равно |64| `is` | идентичность объектов |65| `is not` | отрицание идентичности объектов |6667Объекты разных типов, за исключением разных числовых типов, никогда не сравниваются как равные. Кроме того, некоторые типы (например, объекты-функции) поддерживают только вырожденное понятие сравнения, при котором любые два объекта этого типа неравны. Операторы `<`, `<=`, `>` и `>=` возбуждают исключение [`TypeError`](https://python-all.ru/3.3/library/exceptions.html#TypeError) при сравнении комплексного числа с другим встроенным числовым типом, когда объекты имеют разные типы, которые нельзя сравнивать, или в других случаях, когда не определён порядок.6869Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет метод [`__eq__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__eq__).7071Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или к объектам других типов, если класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__ge__) (в общем случае достаточно [`__lt__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__lt__) и [`__eq__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__eq__), если нужны обычные значения операторов сравнения).7273Поведение операторов [`is`](https://python-all.ru/3.3/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.3/reference/expressions.html#is-not) не может быть настроено; они также могут применяться к любым двум объектам и никогда не вызывают исключение.7475Ещё две операции с тем же синтаксическим приоритетом, [`in`](https://python-all.ru/3.3/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.3/reference/expressions.html#not-in), поддерживаются только типами последовательностей (см. ниже).7677## 4.4. Числовые типы – [`int`](https://python-all.ru/3.3/library/functions.html#int), [`float`](https://python-all.ru/3.3/library/functions.html#float), [`complex`](https://python-all.ru/3.3/library/functions.html#complex)7879Существует три различных числовых типа: *целые числа*, *числа с плавающей точкой* и *комплексные числа*. Кроме того, логические значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью `double` в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.3/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы: [`fractions`](https://python-all.ru/3.3/library/fractions.html#module-fractions) для рациональных чисел и [`decimal`](https://python-all.ru/3.3/library/decimal.html#module-decimal) для чисел с плавающей точкой с настраиваемой точностью.)8081Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Простые целые литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно прибавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.8283Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до типа другого, где целое уже, чем с плавающей точкой, а то, в свою очередь, уже, чем комплексное. Сравнения чисел смешанного типа используют то же правило. [\[2\]](https://python-all.ru/3.3/library/stdtypes.html#id11) Конструкторы [`int()`](https://python-all.ru/3.3/library/functions.html#int), [`float()`](https://python-all.ru/3.3/library/functions.html#float) и [`complex()`](https://python-all.ru/3.3/library/functions.html#complex) можно использовать для создания чисел определённого типа.8485Все числовые типы (кроме комплексных) поддерживают следующие операции, отсортированные по возрастанию приоритета (операции в одной рамке имеют одинаковый приоритет; все числовые операции имеют более высокий приоритет, чем операции сравнения):8687| Операция | Результат | Примечания | Полная документация |88| --- | --- | --- | --- |89| `x + y` | сумма *x* и *y* |  |  |90| `x - y` | разность *x* и *y* |  |  |91| `x * y` | произведение *x* и *y* |  |  |92| `x / y` | частное *x* и *y* |  |  |93| `x // y` | неполное частное *x* и *y* | (1) |  |94| `x % y` | остаток от `x / y` | (2) |  |95| `-x` | *x* с обратным знаком |  |  |96| `+x` | *x* без изменений |  |  |97| `abs(x)` | абсолютное значение или модуль *x* |  | [`abs()`](https://python-all.ru/3.3/library/functions.html#abs) |98| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.3/library/functions.html#int) |99| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.3/library/functions.html#float) |100| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.3/library/functions.html#complex) |101| `c.conjugate()` | сопряжённое комплексного числа *c* |  |  |102| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.3/library/functions.html#divmod) |103| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.3/library/functions.html#pow) |104| `x ** y` | *x* в степени *y* | (5) |  |105106Примечания:1071081. Также называется целочисленным делением. Результирующее значение является целым числом, хотя тип результата не обязательно int. Результат всегда округляется в сторону минус бесконечности: `1//2` равно `0`, `(-1)//2` равно `-1`, `1//(-2)` равно `-1`, а `(-1)//(-2)` равно `0`.1092. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей запятой с помощью [`abs()`](https://python-all.ru/3.3/library/functions.html#abs), если это уместно.1103. Преобразование из числа с плавающей запятой в целое может округлять или усекать как в C; см. функции [`math.floor()`](https://python-all.ru/3.3/library/math.html#math.floor) и [`math.ceil()`](https://python-all.ru/3.3/library/math.html#math.ceil) для чётко определённых преобразований.1114. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.1125. Python определяет `pow(0, 0)` и `0 ** 0` как `1`, что распространено в языках программирования.1136. Принимаемые числовые литералы включают цифры от `0` до `9` или любой эквивалент Unicode (кодовые точки со свойством `Nd`).114115   Полный список кодовых точек со свойством `Nd` приведен по адресу [http://www.unicode.org/Public/6.0.0/ucd/extracted/DerivedNumericType.txt](https://python-all.ru/3.3/library/stdtypes.html).116117Все типы [`numbers.Real`](https://python-all.ru/3.3/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.3/library/functions.html#int) и [`float`](https://python-all.ru/3.3/library/functions.html#float)) также включают следующие операции:118119| Операция | Результат | Примечания |120| --- | --- | --- |121| `math.trunc(x)` | *x*, усечённое до целого |  |122| `round(x[, n])` | *x*, округлённое до n знаков, с округлением половины до чётного. Если n опущено, по умолчанию 0. |  |123| `math.floor(x)` | наибольшее целое число с плавающей запятой, не превышающее *x* |  |124| `math.ceil(x)` | наименьшее целое число с плавающей запятой, не меньшее *x* |  |125126За дополнительными числовыми операциями обращайтесь к [`math`](https://python-all.ru/3.3/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.3/library/cmath.html#module-cmath) модулям.127128### 4.4.1. Побитовые операции над целыми типами129130Побитовые операции имеют смысл только для целых чисел. Отрицательные числа интерпретируются как их дополнительный код (при этом предполагается, что количество битов достаточно велико, чтобы при операции не произошло переполнения).131132Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция `~` имеет тот же приоритет, что и другие унарные числовые операции (`+` и `-`).133134В этой таблице перечислены побитовые операции, отсортированные по возрастанию приоритета (операции в одном блоке имеют одинаковый приоритет):135136| Операция | Результат | Примечания |137| --- | --- | --- |138| `x \| y` | побитовое *ИЛИ* для *x* и *y* |  |139| `x ^ y` | побитовое *исключающее ИЛИ* для *x* и *y* |  |140| `x & y` | побитовое *И* для *x* и *y* |  |141| `x << n` | *x*, сдвинутое влево на *n* битов | (1)(2) |142| `x >> n` | *x*, сдвинутое вправо на *n* битов | (1)(3) |143| `~x` | инвертированные биты *x* |  |144145Примечания:1461471. Отрицательные значения сдвига недопустимы и приводят к возникновению исключения [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError).1482. Сдвиг влево на *n* бит эквивалентен умножению на `pow(2, n)` без проверки переполнения.1493. Сдвиг вправо на *n* бит эквивалентен делению на `pow(2, n)` без проверки переполнения.150151### 4.4.2. Дополнительные методы для целых типов152153Тип int реализует [`numbers.Integral`](https://python-all.ru/3.3/library/numbers.html#numbers.Integral) [*абстрактный базовый класс*](https://python-all.ru/3.3/glossary.html#term-abstract-base-class). Кроме того, он предоставляет ещё один метод:154155#### `int.bit_length()`156157Возвращает количество битов, необходимое для представления целого числа в двоичном виде, без учёта знака и ведущих нулей:158159```python160>>> n = -37161>>> bin(n)162'-0b100101'163>>> n.bit_length()1646165```166167Точнее, если `x` не равно нулю, то `x.bit_length()` – это единственное положительное целое число `k` такое, что выполняется `2**(k-1) <= abs(x) < 2**k`. Или, что то же самое, когда `abs(x)` достаточно мал для корректного округления логарифма, то `k = 1 + int(log(abs(x), 2))`. Если `x` равно нулю, то `x.bit_length()` возвращает `0`.168169Эквивалентно следующему:170171```python172def bit_length(self):173    s = bin(self)       # двоичное представление:  bin(-37) --> '-0b100101'174    s = s.lstrip('-0b') # удалить ведущие нули и знак минус175    return len(s)       # len('100101') --> 6176```177178Новое в версии 3.1.179180#### `int.to_bytes(length, byteorder, *, signed=False)`181182Возвращает массив байтов, представляющий целое число.183184```python185>>> (1024).to_bytes(2, byteorder='big')186b'\x04\x00'187>>> (1024).to_bytes(10, byteorder='big')188b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'189>>> (-1024).to_bytes(10, byteorder='big', signed=True)190b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'191>>> x = 1000192>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')193b'\xe8\x03'194```195196Целое число представляется с помощью *length* байт. Исключение [`OverflowError`](https://python-all.ru/3.3/library/exceptions.html#OverflowError) возникает, если целое число не может быть представлено указанным количеством байт.197198Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.3/library/sys.html#sys.byteorder) в качестве значения порядка байт.199200Аргумент *signed* определяет, используется ли дополнительный код для представления целого числа. Если *signed* равен `False` и передано отрицательное целое число, возбуждается исключение [`OverflowError`](https://python-all.ru/3.3/library/exceptions.html#OverflowError). Значение по умолчанию для *signed* равно `False`.201202Новое в версии 3.2.203204#### `classmethod int.from_bytes(bytes, byteorder, *, signed=False)`205206Возвращает целое число, представленное заданным массивом байтов.207208```python209>>> int.from_bytes(b'\x00\x10', byteorder='big')21016211>>> int.from_bytes(b'\x00\x10', byteorder='little')2124096213>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)214-1024215>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)21664512217>>> int.from_bytes([255, 0, 0], byteorder='big')21816711680219```220221Аргумент *bytes* должен быть либо [*bytes-подобным объектом*](https://python-all.ru/3.3/glossary.html#term-bytes-like-object), либо итерабельным объектом, производящим байты.222223Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.3/library/sys.html#sys.byteorder) в качестве значения порядка байт.224225Аргумент *signed* указывает, используется ли дополнительный код для представления целого числа.226227Новое в версии 3.2.228229### 4.4.3. Дополнительные методы для Float230231Тип float реализует [`numbers.Real`](https://python-all.ru/3.3/library/numbers.html#numbers.Real) [*абстрактный базовый класс*](https://python-all.ru/3.3/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.232233#### `float.as_integer_ratio()`234235Возвращает пару целых чисел, отношение которых в точности равно исходному числу с плавающей запятой, с положительным знаменателем. Возбуждает [`OverflowError`](https://python-all.ru/3.3/library/exceptions.html#OverflowError) для бесконечностей и [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError) для NaN.236237#### `float.is_integer()`238239Возвращает `True`, если экземпляр float является конечным и имеет целое значение, и `False` в противном случае:240241```python242>>> (-2.0).is_integer()243True244>>> (3.2).is_integer()245False246```247248Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python внутренне хранятся в двоичном виде, преобразование числа с плавающей запятой в строку *decimal* и обратно обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точно представлять и задавать числа с плавающей запятой. Это может быть полезно при отладке и в численных расчётах.249250#### `float.hex()`251252Возвращает представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой такое представление всегда содержит префикс `0x` и суффикс `p` с показателем степени.253254#### `classmethod float.fromhex(s)`255256Метод класса, возвращающий число с плавающей запятой, представленное шестнадцатеричной строкой *s*. Строка *s* может содержать начальные и конечные пробелы.257258Обратите внимание, что [`float.hex()`](https://python-all.ru/3.3/library/stdtypes.html#float.hex) – это метод экземпляра, тогда как [`float.fromhex()`](https://python-all.ru/3.3/library/stdtypes.html#float.fromhex) – это метод класса.259260Шестнадцатеричная строка имеет вид:261262```python263[sign] ['0x'] integer ['.' fraction] ['p' exponent]264```265266где необязательный `знак` может быть `+` или `-`, `целая часть` и `дробная часть` – строки шестнадцатеричных цифр, а `порядок` – десятичное целое с необязательным ведущим знаком. Регистр не имеет значения, и должна быть хотя бы одна шестнадцатеричная цифра либо в целой, либо в дробной части. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и выше. В частности, результат [`float.hex()`](https://python-all.ru/3.3/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде на C или Java, а шестнадцатеричные строки, создаваемые символом формата `%a` в C или методом `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.3/library/stdtypes.html#float.fromhex).267268Обратите внимание, что порядок записывается в десятичном виде, а не в шестнадцатеричном, и что он показывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка `0x3.a7p10` представляет число с плавающей запятой `(3 + 10./16 + 7./16**2) * 2.0**10`, или `3740.0`:269270```python271>>> float.fromhex('0x3.a7p10')2723740.0273```274275Применение обратного преобразования к `3740.0` даёт другую шестнадцатеричную строку, представляющую то же число:276277```python278>>> float.hex(3740.0)279'0x1.d380000000000p+11'280```281282### 4.4.4. Хеширование числовых типов283284Для чисел `x` и `y`, возможно разных типов, требуется, чтобы `hash(x) == hash(y)` всякий раз, когда `x == y` (см. документацию метода [`__hash__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__hash__) для подробностей). Для простоты реализации и эффективности для различных числовых типов (включая [`int`](https://python-all.ru/3.3/library/functions.html#int), [`float`](https://python-all.ru/3.3/library/functions.html#float), [`decimal.Decimal`](https://python-all.ru/3.3/library/decimal.html#decimal.Decimal) и [`fractions.Fraction`](https://python-all.ru/3.3/library/fractions.html#fractions.Fraction)) хеш Python для числовых типов основан на одной математической функции, которая определена для любого рационального числа и, следовательно, применима ко всем экземплярам [`int`](https://python-all.ru/3.3/library/functions.html#int) и [`fractions.Fraction`](https://python-all.ru/3.3/library/fractions.html#fractions.Fraction), а также ко всем конечным экземплярам [`float`](https://python-all.ru/3.3/library/functions.html#float) и [`decimal.Decimal`](https://python-all.ru/3.3/library/decimal.html#decimal.Decimal). По сути, эта функция задаётся приведением по модулю `P` для фиксированного простого числа `P`. Значение `P` доступно в Python как атрибут `modulus` объекта [`sys.hash_info`](https://python-all.ru/3.3/library/sys.html#sys.hash_info).285286**Особенность реализации CPython:** В настоящее время используется простое число `P = 2**31 - 1` на машинах с 32-разрядными C длинными целыми и `P = 2**61 - 1` на машинах с 64-разрядными C длинными целыми.287288Вот подробные правила:289290- Если `x = m / n` – неотрицательное рациональное число и `n` не делится на `P`, определим `hash(x)` как `m * invmod(n, P) % P`, где `invmod(n, P)` даёт обратное к `n` по модулю `P`.291- Если `x = m / n` – неотрицательное рациональное число и `n` делится на `P` (но `m` не делится), то `n` не имеет обратного по модулю `P`, и правило выше не применяется; в этом случае определим `hash(x)` как константу `sys.hash_info.inf`.292- Если `x = m / n` – отрицательное рациональное число, определим `hash(x)` как `-hash(-x)`. Если полученный хеш равен `-1`, заменим его на `-2`.293- Конкретные значения `sys.hash_info.inf`, `-sys.hash_info.inf` и `sys.hash_info.nan` используются как хеш-значения для положительной бесконечности, отрицательной бесконечности или nan (соответственно). (Все хешируемые nan имеют одинаковое хеш-значение.)294- Для комплексного числа [`complex`](https://python-all.ru/3.3/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`.295296Чтобы прояснить приведённые выше правила, вот пример кода Python, эквивалентного встроенной функции hash, для вычисления хеша рационального числа, [`float`](https://python-all.ru/3.3/library/functions.html#float) или [`complex`](https://python-all.ru/3.3/library/functions.html#complex):297298```python299import sys, math300301def hash_fraction(m, n):302    """Вычислить хеш рационального числа m / n.303304    Предполагается, что m и n – целые числа, n положительное.305    Эквивалентно hash(fractions.Fraction(m, n)).306307    """308    P = sys.hash_info.modulus309    # Удалить общие делители P.  (Необязательно, если m и n уже взаимно просты.)310    while m % P == n % P == 0:311        m, n = m // P, n // P312313    if n % P == 0:314        hash_ = sys.hash_info.inf315    else:316        # Малая теорема Ферма: pow(n, P-1, P) равно 1, поэтому317        # pow(n, P-2, P) даёт обратный элемент n по модулю P.318        hash_ = (abs(m) % P) * pow(n, P - 2, P) % P319    if m < 0:320        hash_ = -hash_321    if hash_ == -1:322        hash_ = -2323    return hash_324325def hash_float(x):326    """Вычислить хеш числа с плавающей запятой x."""327328    if math.isnan(x):329        return sys.hash_info.nan330    elif math.isinf(x):331        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf332    else:333        return hash_fraction(*x.as_integer_ratio())334335def hash_complex(z):336    """Вычислить хеш комплексного числа z."""337338    hash_ = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)339    # выполнить знаковое приведение по модулю 2**sys.hash_info.width340    M = 2**(sys.hash_info.width - 1)341    hash_ = (hash_ & (M - 1)) - (hash & M)342    if hash_ == -1:343        hash_ == -2344    return hash_345```346347## 4.5. Типы итераторов348349Python поддерживает концепцию итерации по контейнерам. Это реализовано с помощью двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают методы итерации.350351Для поддержки итерации в объектах-контейнерах необходимо определить один метод:352353#### `container.__iter__()`354355Возвращает объект-итератор. Объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные виды итерации, можно добавить дополнительные методы для явного запроса итераторов для этих типов итерации. (Пример объекта, поддерживающего несколько форм итерации – древовидная структура, которая поддерживает как обход в ширину, так и обход в глубину.) Этот метод соответствует полю [`tp_iter`](https://python-all.ru/3.3/c-api/typeobj.html#PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.356357Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:358359#### `iterator.__iter__()`360361Возвращает сам объект-итератор. Это требуется, чтобы и контейнеры, и итераторы можно было использовать с операторами [`for`](https://python-all.ru/3.3/reference/compound_stmts.html#for) и [`in`](https://python-all.ru/3.3/reference/expressions.html#in). Этот метод соответствует полю [`tp_iter`](https://python-all.ru/3.3/c-api/typeobj.html#PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.362363#### `iterator.__next__()`364365Возвращает следующий элемент из контейнера. Если больше нет элементов, возбуждает исключение [`StopIteration`](https://python-all.ru/3.3/library/exceptions.html#StopIteration). Этот метод соответствует полю [`tp_iternext`](https://python-all.ru/3.3/c-api/typeobj.html#PyTypeObject.tp_iternext) структуры типа для объектов Python в Python/C API.366367Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.368369Как только метод [`__next__()`](https://python-all.ru/3.3/library/stdtypes.html#iterator.__next__) итератора возбуждает [`StopIteration`](https://python-all.ru/3.3/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.370371### 4.5.1. Типы генераторов372373Python’s [*generator*](https://python-all.ru/3.3/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.3/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.3/reference/datamodel.html#object.__iter__) and [`__next__()`](https://python-all.ru/3.3/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.3/reference/expressions.html#yieldexpr).374375## 4.6. Типы последовательностей – [`list`](https://python-all.ru/3.3/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple), [`range`](https://python-all.ru/3.3/library/stdtypes.html#range)376377Существуют три основных типа последовательностей: списки, кортежи и объекты range. Дополнительные типы последовательностей, предназначенные для обработки [*двоичных данных*](https://python-all.ru/3.3/library/stdtypes.html#binaryseq) и [*текстовых строк*](https://python-all.ru/3.3/library/stdtypes.html#textseq), описаны в отдельных разделах.378379### 4.6.1. Общие операции с последовательностями380381Операции в следующей таблице поддерживаются большинством типов последовательностей, как изменяемых, так и неизменяемых. Абстрактный базовый класс [`collections.abc.Sequence`](https://python-all.ru/3.3/library/collections.abc.html#collections.abc.Sequence) предоставляется, чтобы упростить правильную реализацию этих операций для пользовательских типов последовательностей.382383В этой таблице перечислены операции с последовательностями, отсортированные по возрастанию приоритета (операции в одном блоке имеют одинаковый приоритет). В таблице *s* и *t* – это последовательности одного типа, *n*, *i*, *j* и *k* – целые числа, а *x* – произвольный объект, удовлетворяющий любым ограничениям по типу и значению, налагаемым *s*.384385Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` (конкатенация) и `*` (повторение) имеют тот же приоритет, что и соответствующие числовые операции.386387| Операция | Результат | Примечания |388| --- | --- | --- |389| `x в s` | `True`, если элемент *s* равен *x*, иначе `False` | (1) |390| `x не в s` | `False`, если элемент *s* равен *x*, иначе `True` | (1) |391| `s + t` | конкатенация *s* и *t* | (6)(7) |392| `s * n` или `n * s` | *n* поверхностных копий *s*, объединённых | (2)(7) |393| `s[i]` | *i*-й элемент *s*, начиная с 0 | (3) |394| `s[i:j]` | срез *s* от *i* до *j* | (3)(4) |395| `s[i:j:k]` | срез *s* от *i* до *j* с шагом *k* | (3)(5) |396| `len(s)` | длина *s* |  |397| `min(s)` | наименьший элемент *s* |  |398| `max(s)` | наибольший элемент *s* |  |399| `s.index(x[, i[, j]])` | индекс первого вхождения *x* в *s* (начиная с индекса *i* и до индекса *j*) | (8) |400| `s.count(x)` | общее количество вхождений *x* в *s* |  |401402Последовательности одного типа также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равен, а две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в [*Comparisons*](https://python-all.ru/3.3/reference/expressions.html#comparisons) в справочнике по языку.)403404Примечания:4054061. Хотя операции `in` и `not in` в общем случае используются только для простой проверки вхождения, некоторые специализированные последовательности (например, [`str`](https://python-all.ru/3.3/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray)) также используют их для проверки на подпоследовательность:407408   ```python409   >>> "gg" in "eggs"410   True411   ```4122. Значения *n* меньше `0` интерпретируются как `0` (что даёт пустую последовательность того же типа, что и *s*). Также обратите внимание, что копии являются поверхностными; вложенные структуры не копируются. Это часто удивляет новичков в Python; рассмотрите:413414   ```python415   >>> lists = [[]] * 3416   >>> lists417   [[], [], []]418   >>> lists[0].append(3)419   >>> lists420   [[3], [3], [3]]421   ```422423   Произошло следующее: `[[]]` – это список из одного элемента, содержащий пустой список, поэтому все три элемента `[[]] * 3` являются (указателями на) этот единственный пустой список. Модификация любого из элементов `списков` изменяет этот единственный список. Создать список из разных списков можно так:424425   ```python426   >>> lists = [[] for i in range(3)]427   >>> lists[0].append(3)428   >>> lists[1].append(5)429   >>> lists[2].append(7)430   >>> lists431   [[3], [5], [7]]432   ```4333. Если *i* или *j* отрицательно, индекс отсчитывается от конца строки: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание, что `-0` по-прежнему равно `0`.4344. Срез *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, таким что `i <= k < j`. Если *i* или *j* больше `len(s)`, используется `len(s)`. Если *i* опущено или равно `None`, используется `0`. Если *j* опущено или равно `None`, используется `len(s)`. Если *i* больше или равно *j*, срез пуст.4355. Срез *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`.4366. Конкатенация неизменяемых последовательностей всегда приводит к созданию нового объекта. Это означает, что построение последовательности путём многократной конкатенации будет иметь квадратичную временную сложность от общей длины последовательности. Чтобы получить линейную сложность, следует перейти к одному из следующих вариантов:437438   - при конкатенации объектов [`str`](https://python-all.ru/3.3/library/stdtypes.html#str) можно собрать список и в конце применить [`str.join()`](https://python-all.ru/3.3/library/stdtypes.html#str.join), либо записывать в экземпляр [`io.StringIO`](https://python-all.ru/3.3/library/io.html#io.StringIO) и получить его значение после завершения439   - при конкатенации объектов [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) можно аналогично использовать `bytes.join()` или [`io.BytesIO`](https://python-all.ru/3.3/library/io.html#io.BytesIO), либо выполнять конкатенацию на месте с объектом [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray). Объекты [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray) изменяемы и имеют эффективный механизм предварительного выделения памяти440   - при конкатенации [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple)-объектов лучше расширить список [`list`](https://python-all.ru/3.3/library/stdtypes.html#list)441   - для других типов – изучите документацию соответствующего класса4427. Некоторые типы последовательностей (например, [`range`](https://python-all.ru/3.3/library/stdtypes.html#range)) поддерживают только последовательности элементов, которые соответствуют определённым шаблонам, и поэтому не поддерживают конкатенацию или повторение последовательностей.4438. `index` возбуждает [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError), если *x* не найден в *s*. Если поддерживается, дополнительные аргументы метода index позволяют эффективно искать в подотрезках последовательности. Передача дополнительных аргументов примерно эквивалентна использованию `s[i:j].index(x)`, только без копирования данных и с возвращаемым индексом относительно начала последовательности, а не начала среза.444445### 4.6.2. Неизменяемые типы последовательностей446447Единственная операция, которую неизменяемые типы последовательностей обычно реализуют, но не реализуют изменяемые типы последовательностей – это поддержка встроенной функции [`hash()`](https://python-all.ru/3.3/library/functions.html#hash).448449Эта поддержка позволяет использовать неизменяемые последовательности, например экземпляры [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple), в качестве ключей [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict) и хранить в экземплярах [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset).450451Попытка вычислить хеш неизменяемой последовательности, содержащей нехешируемые значения, приведёт к [`TypeError`](https://python-all.ru/3.3/library/exceptions.html#TypeError).452453### 4.6.3. Изменяемые типы последовательностей454455Операции в следующей таблице определены для изменяемых типов последовательностей. Абстрактный базовый класс [`collections.abc.MutableSequence`](https://python-all.ru/3.3/library/collections.abc.html#collections.abc.MutableSequence) предоставляется для упрощения правильной реализации этих операций в пользовательских типах последовательностей.456457В таблице *s* – это экземпляр изменяемого типа последовательности, *t* – любой итерируемый объект, а *x* – произвольный объект, удовлетворяющий всем ограничениям на тип и значение, налагаемым *s* (например, [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray) принимает только целые числа, удовлетворяющие ограничению на значение `0 <= x <= 255`).458459| Операция | Результат | Примечания |460| --- | --- | --- |461| `s[i] = x` | элемент *i* из *s* заменяется на *x* |  |462| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* |  |463| `del s[i:j]` | то же, что `s[i:j] = []` |  |464| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами *t* | (1) |465| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка |  |466| `s.append(x)` | добавляет *x* в конец последовательности (то же, что `s[len(s):len(s)] = [x]`) |  |467| `s.clear()` | удаляет все элементы из `s` (то же, что `del s[:]`) | (5) |468| `s.copy()` | создаёт поверхностную копию `s` (то же, что `s[:]`) | (5) |469| `s.extend(t)` | расширяет *s* содержимым *t* (то же, что и `s[len(s):len(s)] = t`) |  |470| `s.insert(i, x)` | вставляет *x* в *s* по индексу, заданному *i* (то же, что `s[i:i] = [x]`) |  |471| `s.pop([i])` | извлекает элемент по индексу *i* и удаляет его из *s* | (2) |472| `s.remove(x)` | удаляет первый элемент из *s* где `s[i] == x` | (3) |473| `s.reverse()` | переворачивает элементы *s* на месте | (4) |474475Примечания:4764771. *t* должен иметь ту же длину, что и заменяемый срез.4782. Необязательный аргумент *i* по умолчанию равен `-1`, поэтому по умолчанию удаляется и возвращается последний элемент.4793. `remove` вызывает [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError), если *x* не найден в *s*.4804. Метод `reverse()` изменяет последовательность на месте для экономии памяти при обращении большой последовательности. Чтобы напомнить пользователям, что он работает через побочный эффект, он не возвращает обращённую последовательность.4815. `clear()` и `copy()` включены для согласованности с интерфейсами изменяемых контейнеров, которые не поддерживают операции среза (таких как [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict) и [`set`](https://python-all.ru/3.3/library/stdtypes.html#set))482483   Новое в версии 3.3: `clear()` и `copy()` методы.484485### 4.6.4. Списки486487Списки – это изменяемые последовательности, обычно используемые для хранения коллекций однородных элементов (степень однородности может варьироваться в зависимости от приложения).488489#### `class list([iterable])`490491Списки можно создать несколькими способами:492493- Используя пару квадратных скобок для обозначения пустого списка: `[]`494- С использованием квадратных скобок, с разделением элементов запятыми: `[a]`, `[a, b, c]`495- С помощью генератора списка: `[x for x in iterable]`496- С помощью конструктора типа: `list()` или `list(iterable)`497498Конструктор создаёт список, элементы которого совпадают с элементами *iterable* и расположены в том же порядке. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является списком, создаётся и возвращается его копия, аналогично `iterable[:]`. Например, `list('abc')` возвращает `['a', 'b', 'c']` и `list( (1, 2, 3) )` возвращает `[1, 2, 3]`. Если аргумент не передан, конструктор создаёт новый пустой список, `[]`.499500Многие другие операции также создают списки, включая встроенную функцию [`sorted()`](https://python-all.ru/3.3/library/functions.html#sorted).501502Списки реализуют все [*общие*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-common) и [*изменяемые*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-mutable) операции последовательностей. Списки также предоставляют следующий дополнительный метод:503504#### `sort(*, key=None, reverse=None)`505506Этот метод сортирует список на месте, используя только `<` сравнений между элементами. Исключения не подавляются – если какая-либо операция сравнения завершится ошибкой, вся сортировка завершится ошибкой (и список, скорее всего, останется в частично изменённом состоянии).507508Метод [`sort()`](https://python-all.ru/3.3/library/stdtypes.html#list.sort) принимает два аргумента, которые могут передаваться только по ключу ([*аргументы только по ключу*](https://python-all.ru/3.3/glossary.html#keyword-only-parameter)):509510*key* указывает функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка (например, `key=str.lower`). Ключ, соответствующий каждому элементу списка, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию `None` означает, что элементы списка сортируются напрямую, без вычисления отдельного ключа.511512Утилита [`functools.cmp_to_key()`](https://python-all.ru/3.3/library/functools.html#functools.cmp_to_key) доступна для преобразования функции *cmp* стиля 2.x в функцию *key*.513514*reverse* – это логическое значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.515516Этот метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает через побочный эффект, он не возвращает отсортированную последовательность (используйте [`sorted()`](https://python-all.ru/3.3/library/functions.html#sorted) для явного запроса нового экземпляра отсортированного списка).517518Метод [`sort()`](https://python-all.ru/3.3/library/stdtypes.html#list.sort) гарантированно является устойчивым. Сортировка устойчива, если она гарантирует, что не изменит относительный порядок элементов, которые сравниваются как равные – это полезно для сортировки в несколько проходов (например, сначала по отделу, затем по уровню зарплаты).519520**Особенность реализации CPython:** Во время сортировки списка результат попытки изменить или даже просмотреть список не определён. C-реализация Python делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.521522### 4.6.5. Кортежи523524Кортежи – это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (например, кортежи из двух элементов, возвращаемые встроенной функцией [`enumerate()`](https://python-all.ru/3.3/library/functions.html#enumerate)). Кортежи также используются в случаях, когда требуется неизменяемая последовательность однородных данных (например, для хранения в экземпляре [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) или [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict)).525526#### `class tuple([iterable])`527528Кортежи можно создать несколькими способами:529530- Используя пару круглых скобок для обозначения пустого кортежа: `()`531- Использование завершающей запятой для кортежа из одного элемента: `a,` или `(a,)`532- Разделение элементов запятыми: `a, b, c` или `(a, b, c)`533- С помощью встроенной функции [`tuple()`](https://python-all.ru/3.3/library/stdtypes.html#tuple): `tuple()` или `tuple(iterable)`534535Конструктор создаёт кортеж, элементы которого совпадают с элементами *iterable* и расположены в том же порядке. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является кортежем, он возвращается без изменений. Например, `tuple('abc')` возвращает `('a', 'b', 'c')` и `tuple( [1, 2, 3] )` возвращает `(1, 2, 3)`. Если аргумент не передан, конструктор создаёт новый пустой кортеж, `()`.536537Обратите внимание, что кортеж создаётся запятой, а не скобками. Скобки необязательны, за исключением пустого кортежа или случаев, когда они нужны, чтобы избежать синтаксической неоднозначности. Например, `f(a, b, c)` – это вызов функции с тремя аргументами, а `f((a, b, c))` – вызов функции с одним аргументом – кортежем из трёх элементов.538539Кортежи реализуют все [*общие*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-common) операции последовательностей.540541Для разнородных коллекций данных, где доступ по имени понятнее, чем по индексу, [`collections.namedtuple()`](https://python-all.ru/3.3/library/collections.html#collections.namedtuple) может быть более подходящим выбором, чем обычный кортеж.542543### 4.6.6. Диапазоны544545Тип [`range`](https://python-all.ru/3.3/library/stdtypes.html#range) представляет собой неизменяемую последовательность чисел и обычно используется для выполнения цикла определённое количество раз в циклах [`for`](https://python-all.ru/3.3/reference/compound_stmts.html#for).546547#### `class range(stop)`548549#### `class range(start, stop[, step])`550551Аргументы конструктора range должны быть целыми числами (либо встроенный [`int`](https://python-all.ru/3.3/library/functions.html#int), либо любой объект, реализующий специальный метод `__index__`). Если аргумент *step* опущен, по умолчанию он равен `1`. Если аргумент *start* опущен, по умолчанию он равен `0`. Если *step* равен нулю, возбуждается [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError).552553Для положительного *step* содержимое диапазона `r` определяется формулой `r[i] = start + step*i`, где `i >= 0` и `r[i] < stop`.554555Для отрицательного *step* содержимое диапазона по-прежнему определяется формулой `r[i] = start + step*i`, но ограничения: `i >= 0` и `r[i] > stop`.556557Объект range будет пустым, если `r[0]` не удовлетворяет ограничению на значение. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексация с конца последовательности, определённой положительными индексами.558559Диапазоны, содержащие абсолютные значения больше [`sys.maxsize`](https://python-all.ru/3.3/library/sys.html#sys.maxsize), допускаются, но некоторые функции (например, [`len()`](https://python-all.ru/3.3/library/functions.html#len)) могут возбуждать [`OverflowError`](https://python-all.ru/3.3/library/exceptions.html#OverflowError).560561Примеры диапазонов:562563```python564>>> list(range(10))565[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]566>>> list(range(1, 11))567[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]568>>> list(range(0, 30, 5))569[0, 5, 10, 15, 20, 25]570>>> list(range(0, 10, 3))571[0, 3, 6, 9]572>>> list(range(0, -10, -1))573[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]574>>> list(range(0))575[]576>>> list(range(1, 0))577[]578```579580Диапазоны реализуют все [*общие*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-common) операции последовательностей, за исключением конкатенации и повторения (ввиду того, что объекты диапазонов могут представлять только последовательности, следующие строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).581582The advantage of the [`range`](https://python-all.ru/3.3/library/stdtypes.html#range) type over a regular [`list`](https://python-all.ru/3.3/library/stdtypes.html#list) or [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple) is that a [`range`](https://python-all.ru/3.3/library/stdtypes.html#range) object will always take the same (small) amount of memory, no matter the size of the range it represents (as it only stores the `start`, `stop` and `step` values, calculating individual items and subranges as needed).583584Объекты range реализуют абстрактный базовый класс [`collections.abc.Sequence`](https://python-all.ru/3.3/library/collections.abc.html#collections.abc.Sequence) и предоставляют такие возможности, как проверка вхождения, поиск индекса элемента, извлечение среза и поддержка отрицательных индексов (см. [*Sequence Types – list, tuple, range*](https://python-all.ru/3.3/library/stdtypes.html#typesseq)):585586```python587>>> r = range(0, 20, 2)588>>> r589range(0, 20, 2)590>>> 11 in r591False592>>> 10 in r593True594>>> r.index(10)5955596>>> r[5]59710598>>> r[:5]599range(0, 10, 2)600>>> r[-1]60118602```603604Проверка объектов range на равенство с помощью `==` и `!=` сравнивает их как последовательности. То есть два объекта range считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два равных объекта range могут иметь разные атрибуты `start`, `stop` и `step`, например `range(0) == range(2, 1, 3)` или `range(0, 3, 2) == range(0, 4, 2)`).605606Изменено в версии 3.2: Реализует ABC Sequence. Поддерживает срезы и отрицательные индексы. Проверяет принадлежность объектов [`int`](https://python-all.ru/3.3/library/functions.html#int) за константное время вместо перебора всех элементов.607608Изменено в версии 3.3: Определяет ‘==’ и ‘!=’ для сравнения объектов диапазонов на основе последовательности значений, которые они определяют (вместо сравнения по идентичности объектов).609610Новое в версии 3.3: Атрибуты `start`, `stop` и `step`.611612## 4.7. Текстовый тип последовательности – [`str`](https://python-all.ru/3.3/library/stdtypes.html#str)613614Текстовые данные в Python обрабатываются с помощью объектов [`str`](https://python-all.ru/3.3/library/stdtypes.html#str), или *строк*. Строки – это неизменяемые [*последовательности*](https://python-all.ru/3.3/library/stdtypes.html#typesseq) кодовых точек Unicode. Строковые литералы записываются разными способами:615616- Одинарные кавычки: `'allows embedded "double" quotes'`617- Двойные кавычки: `"allows embedded 'single' quotes"`.618- Тройные кавычки: `'''Three single quotes'''`, `"""Three double quotes"""`619620Строки в тройных кавычках могут занимать несколько строк – все сопутствующие пробельные символы будут включены в строковый литерал.621622Строковые литералы, которые являются частью одного выражения и разделены только пробельными символами, будут неявно преобразованы в один строковый литерал. То есть `("spam " "eggs") == "spam eggs"`.623624См. [*String and Bytes literals*](https://python-all.ru/3.3/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах строковых литералов, включая поддерживаемые escape-последовательности, и префикс `r` («сырой»), который отключает обработку большинства escape-последовательностей.625626Строки также могут быть созданы из других объектов с помощью конструктора [`str`](https://python-all.ru/3.3/library/stdtypes.html#str).627628Поскольку отдельного типа «символ» не существует, индексация строки возвращает строки длиной 1. То есть для непустой строки *s*, `s[0] == s[0:1]`.629630Также нет изменяемого строкового типа, но [`str.join()`](https://python-all.ru/3.3/library/stdtypes.html#str.join) или [`io.StringIO`](https://python-all.ru/3.3/library/io.html#io.StringIO) можно использовать для эффективного построения строк из нескольких фрагментов.631632Изменено в версии 3.3: Для обратной совместимости с серией Python 2 префикс `u` снова разрешён в строковых литералах. Он не влияет на смысл строковых литералов и не может сочетаться с префиксом `r`.633634#### `class str(object='')`635636#### `class str(object=b'', encoding='utf-8', errors='strict')`637638Возвращает строковое представление *object* в виде [*строки*](https://python-all.ru/3.3/library/stdtypes.html#textseq). Если *object* не передан, возвращается пустая строка. В противном случае поведение `str()` зависит от того, указаны ли *encoding* или *errors*, как описано ниже.639640Если не указаны ни *encoding*, ни *errors*, `str(object)` возвращает [`object.__str__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__str__), то есть «неформальное» или хорошо выводимое на печать строковое представление *object*. Для строковых объектов это сама строка. Если у *object* нет метода [`__str__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__str__), то [`str()`](https://python-all.ru/3.3/library/stdtypes.html#str) возвращает [`repr(object)`](https://python-all.ru/3.3/library/functions.html#repr).641642Если указан хотя бы один из аргументов *encoding* или *errors*, то *object* должен быть [*объектом, подобным bytes*](https://python-all.ru/3.3/glossary.html#term-bytes-like-object) (например, [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) или [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray)). В этом случае, если *object* является объектом [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) (или [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray)), то `str(bytes, encoding, errors)` эквивалентно [`bytes.decode(encoding, errors)`](https://python-all.ru/3.3/library/stdtypes.html#bytes.decode). В противном случае перед вызовом [`bytes.decode()`](https://python-all.ru/3.3/library/stdtypes.html#bytes.decode) извлекается объект bytes, лежащий в основе буферного объекта. См. [*Binary Sequence Types – bytes, bytearray, memoryview*](https://python-all.ru/3.3/library/stdtypes.html#binaryseq) и [*Буферный протокол*](https://python-all.ru/3.3/c-api/buffer.html#bufferobjects) для получения информации о буферных объектах.643644Передача объекта [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) в [`str()`](https://python-all.ru/3.3/library/stdtypes.html#str) без аргументов *encoding* или *errors* относится к первому случаю – возврату неформального строкового представления (см. также опцию командной строки [*-b*](https://python-all.ru/3.3/using/cmdline.html#cmdoption-b) для Python). Например:645646```python647>>> str(b'Zoot!')648"b'Zoot!'"649```650651Дополнительную информацию о классе `str` и его методах см. в разделе [*Тип последовательности текста – str*](https://python-all.ru/3.3/library/stdtypes.html#textseq) и разделе [*Методы строк*](https://python-all.ru/3.3/library/stdtypes.html#string-methods) ниже. Для вывода форматированных строк см. раздел [*Форматирование строк*](https://python-all.ru/3.3/library/string.html#string-formatting). Кроме того, см. раздел [*Службы обработки текста*](https://python-all.ru/3.3/library/text.html#stringservices).652653### 4.7.1. Методы строк654655Строки реализуют все [*общие*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-common) операции с последовательностями, а также дополнительные методы, описанные ниже.656657Строки также поддерживают два стиля форматирования: один обеспечивает высокую гибкость и настройку (см. [`str.format()`](https://python-all.ru/3.3/library/stdtypes.html#str.format), [*Синтаксис форматной строки*](https://python-all.ru/3.3/library/string.html#formatstrings) и [*Форматирование строк*](https://python-all.ru/3.3/library/string.html#string-formatting)), а другой основан на стиле C `printf`, который обрабатывает более узкий набор типов и немного сложнее в правильном использовании, но часто быстрее для тех случаев, которые он может обработать ([*Форматирование строк в стиле printf*](https://python-all.ru/3.3/library/stdtypes.html#old-string-formatting)).658659Раздел [*Службы обработки текста*](https://python-all.ru/3.3/library/text.html#textservices) стандартной библиотеки охватывает ряд других модулей, предоставляющих различные утилиты, связанные с текстом (включая поддержку регулярных выражений в модуле [`re`](https://python-all.ru/3.3/library/re.html#module-re)).660661#### `str.capitalize()`662663Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.664665#### `str.casefold()`666667Возвращает копию строки, преобразованную для регистронезависимого сравнения. Такие строки могут использоваться для сравнения без учёта регистра.668669Casefolding (преобразование регистра для сравнения) похоже на приведение к нижнему регистру, но более агрессивно, поскольку предназначено для удаления всех различий в регистре строки. Например, немецкая строчная буква `'ß'` эквивалентна `"ss"`. Поскольку она уже в нижнем регистре, [`lower()`](https://python-all.ru/3.3/library/stdtypes.html#str.lower) ничего не сделало бы с `'ß'`; [`casefold()`](https://python-all.ru/3.3/library/stdtypes.html#str.casefold) преобразует её в `"ss"`.670671Алгоритм casefolding описан в разделе 3.13 стандарта Unicode.672673Новое в версии 3.3.674675#### `str.center(width[, fillchar])`676677Возвращает строку длины *width*, в которой исходная строка располагается по центру. Заполнение выполняется с использованием указанного символа *fillchar* (по умолчанию пробел).678679#### `str.count(sub[, start[, end]])`680681Возвращает количество непересекающихся вхождений подстроки *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов.682683#### `str.encode(encoding="utf-8", errors="strict")`684685Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* можно задать для указания другой схемы обработки ошибок. Значение *errors* по умолчанию – `'strict'`, что означает, что ошибки кодирования вызывают исключение [`UnicodeError`](https://python-all.ru/3.3/library/exceptions.html#UnicodeError). Другими возможными значениями являются `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'`, а также любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.3/library/codecs.html#codecs.register_error); см. раздел [*Базовые классы кодеков*](https://python-all.ru/3.3/library/codecs.html#codec-base-classes). Список возможных кодировок приведён в разделе [*Стандартные кодировки*](https://python-all.ru/3.3/library/codecs.html#standard-encodings).686687Изменено в версии 3.1: Добавлена поддержка именованных аргументов.688689#### `str.endswith(suffix[, start[, end]])`690691Возвращает `True`, если строка заканчивается указанным *suffix*, иначе возвращает `False`. *suffix* также может быть кортежем суффиксов, которые нужно искать. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение останавливается на этой позиции.692693#### `str.expandtabs([tabsize])`694695Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции находятся через каждые *tabsize* символов (по умолчанию 8, что дает позиции табуляции в колонках 0, 8, 16 и т.д.). Для расширения строки текущая колонка устанавливается в ноль, и строка просматривается посимвольно. Если символ является табуляцией (`\t`), в результат вставляются один или несколько пробелов, пока текущая колонка не достигнет следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символ является переводом строки (`\n`) или возвратом каретки (`\r`), он копируется, и текущая колонка сбрасывается в ноль. Любой другой символ копируется без изменений, и текущая колонка увеличивается на единицу независимо от того, как символ представлен при печати.696697```python698>>> '01\t012\t0123\t01234'.expandtabs()699'01      012     0123    01234'700>>> '01\t012\t0123\t01234'.expandtabs(4)701'01  012 0123    01234'702```703704#### `str.find(sub[, start[, end]])`705706Возвращает наименьший индекс в строке, где найдена подстрока *sub*, такой что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.707708> **Примечание**709>710> Метод [`find()`](https://python-all.ru/3.3/library/stdtypes.html#str.find) следует использовать только если нужно узнать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.3/reference/expressions.html#in):711>712> ```python713> >>> 'Py' in 'Python'714> True715> ```716717#### `str.format(*args, **kwargs)`718719Выполняет операцию форматирования строки. Строка, к которой применяется этот метод, может содержать буквальный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию строки, в которой каждое поле замены заменено строковым значением соответствующего аргумента.720721```python722>>> "The sum of 1 + 2 is {0}".format(1+2)723'The sum of 1 + 2 is 3'724```725726См. [*Синтаксис форматных строк*](https://python-all.ru/3.3/library/string.html#formatstrings) для описания различных параметров форматирования, которые можно указать в форматных строках.727728#### `str.format_map(mapping)`729730Аналогично `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую и не копируется в [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict). Это полезно, если, например, `mapping` является подклассом dict:731732```python733>>> class Default(dict):734...     def __missing__(self, key):735...         return key736...737>>> '{name} was born in {country}'.format_map(Default(name='Guido'))738'Guido was born in country'739```740741Новое в версии 3.2.742743#### `str.index(sub[, start[, end]])`744745Как [`find()`](https://python-all.ru/3.3/library/stdtypes.html#str.find), но вызывает [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError), если подстрока не найдена.746747#### `str.isalnum()`748749Возвращает true, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе false. Символ `c` является буквенно-цифровым, если один из следующих методов возвращает `True`: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()` или `c.isnumeric()`.750751#### `str.isalpha()`752753Возвращает true, если все символы в строке являются буквенными и есть хотя бы один символ, иначе false. Буквенные символы – это символы, определённые в базе данных символов Unicode как «Letter», т.е. те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Unicode.754755#### `str.isdecimal()`756757Возвращает true, если все символы в строке являются десятичными символами и есть хотя бы один символ, иначе false. Десятичные символы относятся к общей категории «Nd». Эта категория включает цифры и все символы, которые можно использовать для формирования чисел с десятичным основанием, например U+0660, АРАБСКО-ИНДИЙСКАЯ ЦИФРА НОЛЬ.758759#### `str.isdigit()`760761Возвращает true, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false. Цифры включают десятичные символы и цифры, требующие специальной обработки, например совместимые надстрочные цифры. Формально цифрой является символ со значением свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.762763#### `str.isidentifier()`764765Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, раздел [*Идентификаторы и ключевые слова*](https://python-all.ru/3.3/reference/lexical_analysis.html#identifiers).766767Используйте [`keyword.iskeyword()`](https://python-all.ru/3.3/library/keyword.html#keyword.iskeyword) для проверки зарезервированных идентификаторов, таких как [`def`](https://python-all.ru/3.3/reference/compound_stmts.html#def) и [`class`](https://python-all.ru/3.3/reference/compound_stmts.html#class).768769#### `str.islower()`770771Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.3/library/stdtypes.html#id13) в строке являются строчными и есть хотя бы один буквенный символ, иначе false.772773#### `str.isnumeric()`774775Возвращает true, если все символы в строке являются числовыми символами и есть хотя бы один символ, иначе false. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы – это символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric.776777#### `str.isprintable()`778779Возвращает true, если все символы строки являются печатаемыми или строка пуста, иначе false. Непечатаемые символы – это те, которые определены в базе данных Unicode как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатаемым. (Обратите внимание, что печатаемые символы в данном контексте – это те, которые не должны экранироваться при вызове [`repr()`](https://python-all.ru/3.3/library/functions.html#repr) для строки. Это не влияет на обработку строк, записываемых в [`sys.stdout`](https://python-all.ru/3.3/library/sys.html#sys.stdout) или [`sys.stderr`](https://python-all.ru/3.3/library/sys.html#sys.stderr).)780781#### `str.isspace()`782783Возвращает true, если в строке есть только пробельные символы и есть хотя бы один символ, иначе false. Пробельные символы – это символы, определённые в базе данных символов Unicode как «Other» или «Separator», а также символы со свойством двунаправленности, являющимся одним из «WS», «B» или «S».784785#### `str.istitle()`786787Возвращает true, если строка является строкой в заглавном регистре (titlecased) и есть хотя бы один символ, например прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. Иначе возвращает false.788789#### `str.isupper()`790791Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.3/library/stdtypes.html#id13) в строке являются прописными и есть хотя бы один буквенный символ, иначе false.792793#### `str.join(iterable)`794795Возвращает строку, которая является объединением строк в [*итерируемый объект*](https://python-all.ru/3.3/glossary.html#term-iterable) *итерируемый объект*. Исключение [`TypeError`](https://python-all.ru/3.3/library/exceptions.html#TypeError) будет возбуждено, если в *итерируемый объект* есть значения, не являющиеся строками, включая объекты [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes). Разделителем между элементами служит строка, предоставляющая этот метод.796797#### `str.ljust(width[, fillchar])`798799Возвращает строку, выровненную по левому краю в строке длины *width*. Заполнение выполняется с помощью указанного символа *fillchar* (по умолчанию пробел). Исходная строка возвращается, если *width* меньше или равно `len(s)`.800801#### `str.lower()`802803Возвращает копию строки, в которой все символы, имеющие регистр, [\[4\]](https://python-all.ru/3.3/library/stdtypes.html#id13) преобразованы в нижний регистр.804805Используемый алгоритм приведения к нижнему регистру описан в разделе 3.13 стандарта Юникода.806807#### `str.lstrip([chars])`808809Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом; удаляются все комбинации его значений:810811```python812>>> '   spacious   '.lstrip()813'spacious   '814>>> 'www.example.com'.lstrip('cmowz.')815'example.com'816```817818#### `static str.maketrans(x[, y[, z]])`819820Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.3/library/stdtypes.html#str.translate).821822Если передан только один аргумент, это должен быть словарь, отображающий коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или None. Ключи-символы при этом будут преобразованы в коды.823824Если передано два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ из x будет сопоставлен символу на той же позиции в y. Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены None в результате.825826#### `str.partition(sep)`827828Разделяет строку по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.829830#### `str.replace(old, new[, count])`831832Возвращает копию строки, в которой все вхождения подстроки *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.833834#### `str.rfind(sub[, start[, end]])`835836Возвращает наибольший индекс в строке, на котором найдена подстрока *sub*, такой, что *sub* содержится в `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1` при неудаче.837838#### `str.rindex(sub[, start[, end]])`839840Похож на [`rfind()`](https://python-all.ru/3.3/library/stdtypes.html#str.rfind), но возбуждает [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError), когда подстрока *sub* не найдена.841842#### `str.rjust(width[, fillchar])`843844Возвращает строку, выровненную по правому краю в строке длины *width*. Заполнение выполняется с помощью указанного символа *fillchar* (по умолчанию пробел). Исходная строка возвращается, если *width* меньше или равно `len(s)`.845846#### `str.rpartition(sep)`847848Разделяет строку по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.849850#### `str.rsplit(sep=None, maxsplit=-1)`851852Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, причём *справа* Если *sep* не указан или равен `None`, разделителем считается любая строка из пробельных символов. За исключением разбиения справа, [`rsplit()`](https://python-all.ru/3.3/library/stdtypes.html#str.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.3/library/stdtypes.html#str.split), который подробно описан ниже.853854#### `str.rstrip([chars])`855856Возвращает копию строки с удалёнными конечными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является суффиксом; удаляются все комбинации его значений:857858```python859>>> '   spacious   '.rstrip()860'   spacious'861>>> 'mississippi'.rstrip('ipz')862'mississ'863```864865#### `str.split(sep=None, maxsplit=-1)`866867Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то ограничение на количество разбиений отсутствует (выполняются все возможные разбиения).868869Если указан *sep*, то последовательные разделители не объединяются в один, а считаются ограничителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов (например, `'1<>2<>3'.split('<>')` возвращает `['1', '2', '3']`). Разбиение пустой строки с указанным разделителем возвращает `['']`.870871Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и в результате не будет пустых строк в начале или конце, если строка начинается или заканчивается пробелами. Соответственно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.872873Например, `' 1 2 3 '.split()'` возвращает `['1', '2', '3']`, а `' 1 2 3 '.split(None, 1)` возвращает `['1', '2 3 ']`.874875#### `str.splitlines([keepends])`876877Возвращает список строк из строки, разбивая по границам строк. Этот метод использует подход [*универсальных новых строк*](https://python-all.ru/3.3/glossary.html#term-universal-newlines) для разбиения строк. Символы перевода строки не включаются в результирующий список, если только *keepends* не задан и истинен.878879Например, `'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']`.880881В отличие от [`split()`](https://python-all.ru/3.3/library/stdtypes.html#str.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и конечный перевод строки не приводит к добавлению дополнительной строки.882883#### `str.startswith(prefix[, start[, end]])`884885Возвращает `True`, если строка начинается с префикса *prefix*, иначе возвращает `False`. *prefix* также может быть кортежем искомых префиксов. С необязательным *start* проверка начинается с указанной позиции. С необязательным *end* сравнение строки завершается на указанной позиции.886887#### `str.strip([chars])`888889Возвращает копию строки с удалёнными ведущими и завершающими символами. Аргумент *chars* – строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:890891```python892>>> '   spacious   '.strip()893'spacious'894>>> 'www.example.com'.strip('cmowz.')895'example'896```897898#### `str.swapcase()`899900Возвращает копию строки, в которой символы верхнего регистра преобразованы в нижний и наоборот. Обратите внимание, что `s.swapcase().swapcase() == s` не обязательно равно.901902#### `str.title()`903904Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.905906Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:907908```python909>>> "they're bill's friends from the UK".title()910"They'Re Bill'S Friends From The Uk"911```912913Обходной путь для апострофов можно построить с помощью регулярных выражений:914915```python916>>> import re917>>> def titlecase(s):918...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",919...                   lambda mo: mo.group(0)[0].upper() +920...                              mo.group(0)[1:].lower(),921...                   s)922...923>>> titlecase("they're bill's friends.")924"They're Bill's Friends."925```926927#### `str.translate(map)`928929Возвращает копию *s*, в которой все символы преобразованы с помощью *map*, который должен быть словарём, отображающим коды Unicode (целые числа) в коды Unicode, строки или `None`. Неотображённые символы остаются без изменений. Символы, отображённые на `None`, удаляются.930931Для создания таблицы трансляции из символьных отображений в разных форматах можно использовать [`str.maketrans()`](https://python-all.ru/3.3/library/stdtypes.html#str.maketrans).932933> **Примечание**934>935> Ещё более гибкий подход – создать собственный кодек отображения символов с помощью модуля [`codecs`](https://python-all.ru/3.3/library/codecs.html#module-codecs) (см. `encodings.cp1251` в качестве примера).936937#### `str.upper()`938939Возвращает копию строки, в которой все символы [\[4\]](https://python-all.ru/3.3/library/stdtypes.html#id13), имеющие регистр, преобразованы в верхний регистр. Обратите внимание, что `str.upper().isupper()` может быть `False`, если `s` содержит символы без регистра или если категория Unicode результирующего символа не “Lu” (буква, верхний регистр), а, например, “Lt” (буква, заглавная).940941Алгоритм перевода в верхний регистр описан в разделе 3.13 стандарта Unicode.942943#### `str.zfill(width)`944945Возвращает числовую строку, дополненную слева нулями до длины *width*. Знак префикса обрабатывается корректно. Исходная строка возвращается, если *width* меньше или равно `len(s)`.946947### 4.7.2. Форматирование строк в стиле `printf`948949> **Примечание**950>951> Описанные здесь операции форматирования имеют ряд особенностей, которые приводят к распространённым ошибкам (например, некорректному отображению кортежей и словарей). Использование нового интерфейса [`str.format()`](https://python-all.ru/3.3/library/stdtypes.html#str.format) помогает избежать этих ошибок, а также предоставляет в целом более мощный, гибкий и расширяемый подход к форматированию текста.952953У строковых объектов есть одна уникальная встроенная операция: оператор `%` (модуль). Он также известен как оператор форматирования *formatting* или интерполяции *interpolation* строк. Для `format % values` (где *format* – строка) спецификации преобразования `%` в *format* заменяются на ноль или более элементов из *values*. Результат аналогичен использованию `sprintf()` в языке C.954955Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [\[5\]](https://python-all.ru/3.3/library/stdtypes.html#id14) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).956957Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:9589591. Символ `'%'`, обозначающий начало спецификатора.9602. Ключ отображения (необязательно), состоящий из последовательности символов в скобках (например, `(somename)`).9613. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.9624. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.9635. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.9646. Модификатор длины (необязательно).9657. Тип преобразования.966967Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:968969```python970>>> print('%(language)s has %(number)03d quote types.' %971...       {'language': "Python", "number": 2})972Python has 002 quote types.973```974975В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).976977Символы флагов преобразования:978979| Флаг | Значение |980| --- | --- |981| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |982| `'0'` | Для числовых значений преобразование будет дополняться нулями. |983| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |984| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |985| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |986987Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, так как не нужен для Python – например, `%ld` идентично `%d`.988989Типы преобразования:990991| Преобразование | Значение | Примечания |992| --- | --- | --- |993| `'d'` | Десятичное целое со знаком. |  |994| `'i'` | Десятичное целое со знаком. |  |995| `'o'` | Восьмеричное значение со знаком. | (1) |996| `'u'` | Устаревший тип – он идентичен `'d'`. | (7) |997| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |998| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |999| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |1000| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |1001| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |1002| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |1003| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1004| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1005| `'c'` | Один символ (принимает целое число или строку из одного символа). |  |1006| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.3/library/functions.html#repr)). | (5) |1007| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.3/library/stdtypes.html#str)). | (5) |1008| `'a'` | Строка (преобразует любой объект Python с помощью [`ascii()`](https://python-all.ru/3.3/library/functions.html#ascii)). | (5) |1009| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |10101011Примечания:101210131. Альтернативная форма приводит к вставке ведущего нуля (`'0'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.10142. Альтернативная форма приводит к вставке ведущего `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.10153. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.10161017   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.10184. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.10191020   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.10215. Если точность равна `N`, вывод обрезается до `N` символов.102210237. См. [**PEP 237**](https://python-all.ru/3.3/library/stdtypes.html).10241025Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.10261027Изменено в версии 3.1: преобразования `%f` для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.10281029## 4.8. Типы двоичных последовательностей – [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes), [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray), [`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview)10301031Основные встроенные типы для работы с двоичными данными – это [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray). Они поддерживаются [`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview), который использует [*буферный протокол*](https://python-all.ru/3.3/c-api/buffer.html#bufferobjects) для доступа к памяти других двоичных объектов без необходимости создавать копию.10321033Модуль [`array`](https://python-all.ru/3.3/library/array.html#module-array) поддерживает эффективное хранение базовых типов данных, таких как 32-битные целые числа и числа с плавающей запятой двойной точности IEEE754.10341035### 4.8.1. Байты10361037Объекты bytes – это неизменяемые последовательности отдельных байтов. Поскольку многие основные бинарные протоколы основаны на текстовой кодировке ASCII, объекты bytes предоставляют несколько методов, которые действительны только при работе с данными, совместимыми с ASCII, и тесно связаны со строковыми объектами во многих других отношениях.10381039Во-первых, синтаксис литералов bytes в основном такой же, как для строковых литералов, за исключением того, что добавляется префикс `b`:10401041- Одинарные кавычки: `b'still allows embedded "double" quotes'`1042- Двойные кавычки: `b"still allows embedded 'single' quotes"`.1043- Тройные кавычки: `b'''3 single quotes'''`, `b"""3 double quotes"""`10441045В литералах bytes допускаются только символы ASCII (независимо от объявленной кодировки исходного кода). Любые двоичные значения больше 127 должны вводиться в литералы bytes с помощью соответствующей управляющей последовательности.10461047Как и строковые литералы, литералы bytes также могут использовать префикс `r` для отключения обработки escape-последовательностей. См. [*Строковые и байтовые литералы*](https://python-all.ru/3.3/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах литерала bytes, включая поддерживаемые escape-последовательности.10481049Хотя литералы bytes и их представления основаны на тексте ASCII, объекты bytes на самом деле ведут себя как неизменяемые последовательности целых чисел, где каждое значение в последовательности ограничено так, что `0 <= x < 256` (попытки нарушить это ограничение вызовут [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError)). Это сделано намеренно, чтобы подчеркнуть, что хотя многие двоичные форматы включают элементы на основе ASCII и могут быть полезно обработаны некоторыми текстовыми алгоритмами, в общем случае это не так для произвольных двоичных данных (слепое применение алгоритмов обработки текста к двоичным форматам, несовместимым с ASCII, обычно приводит к повреждению данных).10501051Помимо литералов, объекты bytes могут быть созданы несколькими другими способами:10521053- Объект bytes, заполненный нулями заданной длины: `bytes(10)`1054- Из итерируемого объекта целых чисел: `bytes(range(20))`1055- Копирование существующих двоичных данных через буферный протокол: `bytes(obj)`10561057См. также встроенную функцию [*bytes*](https://python-all.ru/3.3/library/functions.html#func-bytes).10581059Поскольку объекты bytes являются последовательностями целых чисел, для объекта bytes *b*, `b[0]` будет целым числом, тогда как `b[0:1]` будет объектом bytes длиной 1. (Это отличается от текстовых строк, где и индексация, и срез дают строку длиной 1.)10601061Представление объектов bytes использует формат литерала (`b'...'`), поскольку это часто полезнее, чем, например, `bytes([46, 46, 46])`. Всегда можно преобразовать объект bytes в список целых чисел с помощью `list(b)`.10621063> **Примечание**1064>1065> Для пользователей Python 2.x: В серии Python 2.x допускался ряд неявных преобразований между 8-битными строками (ближайший аналог встроенного двоичного типа данных в 2.x) и строками Unicode. Это был обходной путь для обратной совместимости, учитывающий тот факт, что Python изначально поддерживал только 8-битный текст, а текст Unicode был добавлен позже. В Python 3.x эти неявные преобразования устранены – преобразования между 8-битными двоичными данными и текстом Unicode должны быть явными, а объекты bytes и string всегда сравниваются как неравные.10661067### 4.8.2. Объекты bytearray10681069Объекты [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray) являются изменяемым аналогом объектов [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes). Для объектов bytearray нет специального синтаксиса литералов, вместо этого они всегда создаются вызовом конструктора:10701071- Создание пустого экземпляра: `bytearray()`1072- Создание экземпляра, заполненного нулями заданной длины: `bytearray(10)`1073- Из итерируемого объекта целых чисел: `bytearray(range(20))`1074- Копирование существующих двоичных данных через буферный протокол: `bytearray(b'Hi!')`10751076Поскольку объекты bytearray являются изменяемыми, они поддерживают [*изменяемые*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-mutable) операции последовательности в дополнение к общим операциям bytes и bytearray, описанным в [*Операции с bytes и bytearray*](https://python-all.ru/3.3/library/stdtypes.html#bytes-methods).10771078См. также встроенную функцию [*bytearray*](https://python-all.ru/3.3/library/functions.html#func-bytearray).10791080### 4.8.3. Операции с bytes и bytearray10811082Объекты bytes и bytearray поддерживают [*общие*](https://python-all.ru/3.3/library/stdtypes.html#typesseq-common) операции с последовательностями. Они взаимодействуют не только с операндами того же типа, но и с любым объектом, поддерживающим [*буферный протокол*](https://python-all.ru/3.3/c-api/buffer.html#bufferobjects). Благодаря этой гибкости их можно свободно смешивать в операциях без ошибок. Однако тип возвращаемого результата может зависеть от порядка операндов.10831084Из-за широкого использования ASCII-текста как основы двоичных протоколов объекты bytes и bytearray предоставляют почти все методы, имеющиеся у текстовых строк, за исключением:10851086- [`str.encode()`](https://python-all.ru/3.3/library/stdtypes.html#str.encode) (преобразует текстовые строки в объекты bytes)1087- [`str.format()`](https://python-all.ru/3.3/library/stdtypes.html#str.format) и [`str.format_map()`](https://python-all.ru/3.3/library/stdtypes.html#str.format_map) (используются для форматирования текста для отображения пользователям)1088- [`str.isidentifier()`](https://python-all.ru/3.3/library/stdtypes.html#str.isidentifier), [`str.isnumeric()`](https://python-all.ru/3.3/library/stdtypes.html#str.isnumeric), [`str.isdecimal()`](https://python-all.ru/3.3/library/stdtypes.html#str.isdecimal), [`str.isprintable()`](https://python-all.ru/3.3/library/stdtypes.html#str.isprintable) (используются для проверки различных свойств текстовых строк, которые обычно не применимы к двоичным протоколам).10891090Все остальные строковые методы поддерживаются, хотя иногда с небольшими различиями в функциональности и семантике (как описано ниже).10911092> **Примечание**1093>1094> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать:1095>1096> ```python1097> a = "abc"1098> b = a.replace("a", "f")1099> ```1100>1101> и:1102>1103> ```python1104> a = b"abc"1105> b = a.replace(b"a", b"f")1106> ```11071108Всякий раз, когда методу bytes или bytearray требуется интерпретировать байты как символы (например, методы `is...()`, `split()`, `strip()`), предполагается набор символов ASCII (текстовые строки используют семантику Unicode).11091110> **Примечание**1111>1112> Использование этих методов, основанных на ASCII, для обработки двоичных данных, которые не хранятся в формате на основе ASCII, может привести к повреждению данных.11131114Операции поиска ([`in`](https://python-all.ru/3.3/reference/expressions.html#in), `count()`, `find()`, `index()`, `rfind()` и `rindex()`) принимают как целые числа в диапазоне от 0 до 255 включительно, так и последовательности bytes и bytearray.11151116Изменено в версии 3.3: Все методы поиска также принимают целое число в диапазоне от 0 до 255 включительно в качестве первого аргумента.11171118Каждый экземпляр bytes и bytearray предоставляет удобный метод [`decode()`](https://python-all.ru/3.3/library/stdtypes.html#bytes.decode), являющийся обратным к [`str.encode()`](https://python-all.ru/3.3/library/stdtypes.html#str.encode):11191120#### `bytes.decode(encoding="utf-8", errors="strict")`11211122#### `bytearray.decode(encoding="utf-8", errors="strict")`11231124Возвращает строку, декодированную из заданных байтов. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* можно задать для выбора другой схемы обработки ошибок. По умолчанию *errors* равен `'strict'`, что означает, что ошибки кодирования вызывают [`UnicodeError`](https://python-all.ru/3.3/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.3/library/codecs.html#codecs.register_error); см. раздел [*Базовые классы кодеков*](https://python-all.ru/3.3/library/codecs.html#codec-base-classes). Список возможных кодировок – в разделе [*Стандартные кодировки*](https://python-all.ru/3.3/library/codecs.html#standard-encodings).11251126Изменено в версии 3.1: Добавлена поддержка именованных аргументов.11271128Поскольку две шестнадцатеричные цифры точно соответствуют одному байту, шестнадцатеричные числа – это распространённый формат для описания двоичных данных. Соответственно, типы bytes и bytearray имеют дополнительный метод класса для чтения данных в этом формате:11291130#### `classmethod bytes.fromhex(string)`11311132#### `classmethod bytearray.fromhex(string)`11331134Этот метод класса [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) возвращает объект bytes или bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, пробелы игнорируются.11351136```python1137>>> bytes.fromhex('2Ef0 F1f2  ')1138b'.\xf0\xf1\xf2'1139```11401141Методы maketrans и translate отличаются семантикой от версий, доступных для строк:11421143#### `bytes.translate(table[, delete])`11441145#### `bytearray.translate(table[, delete])`11461147Возвращает копию объекта bytes или bytearray, из которой удалены все байты, входящие в необязательный аргумент *delete*, а оставшиеся байты преобразованы через заданную таблицу перевода, которая должна быть объектом bytes длиной 256.11481149Для создания таблицы перевода можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.3/library/stdtypes.html#bytes.maketrans).11501151Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:11521153```python1154>>> b'read this short text'.translate(None, b'aeiou')1155b'rd ths shrt txt'1156```11571158#### `static bytes.maketrans(from, to)`11591160#### `static bytearray.maketrans(from, to)`11611162Этот статический метод возвращает таблицу перевода, пригодную для использования в [`bytes.translate()`](https://python-all.ru/3.3/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* должны быть объектами bytes и иметь одинаковую длину.11631164Новое в версии 3.1.11651166### 4.8.4. Представления памяти11671168Объекты [`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [*протокол буфера*](https://python-all.ru/3.3/c-api/buffer.html#bufferobjects), без копирования.11691170#### `class memoryview(obj)`11711172Создаёт [`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview), ссылающийся на *obj*. *obj* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray).11731174[`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview) имеет понятие *элемента* – атомарной единицы памяти, с которой работает исходный объект *obj*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray), элемент представляет собой один байт, но другие типы, такие как [`array.array`](https://python-all.ru/3.3/library/array.html#array.array), могут иметь элементы большего размера.11751176`len(view)` равно длине [`tolist`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.tolist). Если `view.ndim = 0`, длина равна 1. Если `view.ndim = 1`, длина равна количеству элементов в представлении. Для более высоких размерностей длина равна длине вложенного спискового представления представления. Атрибут [`itemsize`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.itemsize) даёт количество байт в одном элементе.11771178[`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview) поддерживает срезы для доступа к своим данным. Если [`format`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.format) является одним из собственных спецификаторов формата из модуля [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct), то индексирование вернёт один элемент правильного типа. Полный срез вернёт подпредставление:11791180```python1181>>> v = memoryview(b'abcefg')1182>>> v[1]1183981184>>> v[-1]11851031186>>> v[1:4]1187<memory at 0x7f3ddc9f4350>1188>>> bytes(v[1:4])1189b'bce'1190```11911192Другие собственные форматы:11931194```python1195>>> import array1196>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])1197>>> a[0]1198-111111111199>>> a[-1]1200444444441201>>> a[2:3].tolist()1202[-33333333]1203>>> a[::2].tolist()1204[-11111111, -33333333]1205>>> a[::-1].tolist()1206[44444444, -33333333, 22222222, -11111111]1207```12081209Новое в версии 3.3.12101211Если базовый объект допускает запись, memoryview поддерживает присваивание срезу. Изменение размера не разрешено:12121213```python1214>>> data = bytearray(b'abcefg')1215>>> v = memoryview(data)1216>>> v.readonly1217False1218>>> v[0] = ord(b'z')1219>>> data1220bytearray(b'zbcefg')1221>>> v[1:4] = b'123'1222>>> data1223bytearray(b'z123fg')1224>>> v[2:3] = b'spam'1225Traceback (most recent call last):1226  File "<stdin>", line 1, in <module>1227ValueError: memoryview assignment: lvalue and rvalue have different structures1228>>> v[2:6] = b'spam'1229>>> data1230bytearray(b'z1spam')1231```12321233Одномерные представления памяти хешируемых (только для чтения) типов с форматами 'B', 'b' или 'c' также являются хешируемыми. Хеш определяется как `hash(m) == hash(m.tobytes())`:12341235```python1236>>> v = memoryview(b'abcefg')1237>>> hash(v) == hash(b'abcefg')1238True1239>>> hash(v[2:4]) == hash(b'ce')1240True1241>>> hash(v[::-2]) == hash(b'abcefg'[::-2])1242True1243```12441245Изменено в версии 3.3: Одномерные представления памяти с форматами 'B', 'b' или 'c' теперь являются хешируемыми.12461247[`memoryview`](https://python-all.ru/3.3/library/stdtypes.html#memoryview) имеет несколько методов:12481249#### `__eq__(exporter)`12501251Объект memoryview и экспортёр [**PEP 3118**](https://python-all.ru/3.3/library/stdtypes.html) равны, если их формы эквивалентны и все соответствующие значения равны, когда коды формата операндов интерпретируются с использованием синтаксиса [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct).12521253Для подмножества строк формата [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct), поддерживаемых в настоящее время [`tolist()`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.tolist), `v` и `w` равны, если `v.tolist() == w.tolist()`:12541255```python1256>>> import array1257>>> a = array.array('I', [1, 2, 3, 4, 5])1258>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])1259>>> c = array.array('b', [5, 3, 1])1260>>> x = memoryview(a)1261>>> y = memoryview(b)1262>>> x == a == y == b1263True1264>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()1265True1266>>> z = y[::-2]1267>>> z == c1268True1269>>> z.tolist() == c.tolist()1270True1271```12721273Если хотя бы одна из строк формата не поддерживается модулем [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct), то объекты всегда будут считаться неравными (даже если строки формата и содержимое буфера идентичны):12741275```python1276>>> from ctypes import BigEndianStructure, c_long1277>>> class BEPoint(BigEndianStructure):1278...     _fields_ = [("x", c_long), ("y", c_long)]1279...1280>>> point = BEPoint(100, 200)1281>>> a = memoryview(point)1282>>> b = memoryview(point)1283>>> a == point1284False1285>>> a == b1286False1287```12881289Обратите внимание, что, как и в случае с числами с плавающей запятой, для объектов memoryview `v is w` *не* подразумевает `v == w`.12901291Изменено в версии 3.3: В предыдущих версиях сравнивалась необработанная память без учёта формата элемента и логической структуры массива.12921293#### `tobytes()`12941295Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.3/library/functions.html#bytes) для данного представления памяти.12961297```python1298>>> m = memoryview(b"abc")1299>>> m.tobytes()1300b'abc'1301>>> bytes(m)1302b'abc'1303```13041305Для несплошных массивов результат равен сплющенному списковому представлению со всеми элементами, преобразованными в байты. [`tobytes()`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.tobytes) поддерживает все строки формата, включая те, которые не входят в синтаксис модуля [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct).13061307#### `tolist()`13081309Возвращает данные в буфере в виде списка элементов.13101311```python1312>>> memoryview(b'abc').tolist()1313[97, 98, 99]1314>>> import array1315>>> a = array.array('d', [1.1, 2.2, 3.3])1316>>> m = memoryview(a)1317>>> m.tolist()1318[1.1, 2.2, 3.3]1319```13201321Изменено в версии 3.3: [`tolist()`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.tolist) теперь поддерживает все односимвольные собственные форматы в синтаксисе модуля [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct), а также многомерные представления.13221323#### `release()`13241325Освобождает базовый буфер, предоставленный объектом memoryview. Многие объекты выполняют специальные действия, пока на них удерживается представление (например, [`bytearray`](https://python-all.ru/3.3/library/functions.html#bytearray) временно запрещает изменение размера); поэтому вызов release() удобен для снятия этих ограничений (и освобождения любых висящих ресурсов) как можно скорее.13261327После вызова этого метода любая дальнейшая операция над представлением вызывает исключение [`ValueError`](https://python-all.ru/3.3/library/exceptions.html#ValueError) (за исключением самого [`release()`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.release), который можно вызывать многократно):13281329```python1330>>> m = memoryview(b'abc')1331>>> m.release()1332>>> m[0]1333Traceback (most recent call last):1334  File "<stdin>", line 1, in <module>1335ValueError: operation forbidden on released memoryview object1336```13371338Протокол управления контекстом можно использовать для аналогичного эффекта, применяя оператор `with`:13391340```python1341>>> with memoryview(b'abc') as m:1342...     m[0]1343...1344971345>>> m[0]1346Traceback (most recent call last):1347  File "<stdin>", line 1, in <module>1348ValueError: operation forbidden on released memoryview object1349```13501351Новое в версии 3.2.13521353#### `cast(format[, shape])`13541355Преобразует memoryview в новый формат или форму. *shape* по умолчанию равен `[byte_length//new_itemsize]`, что означает, что результирующее представление будет одномерным. Возвращаемое значение – новый memoryview, но сам буфер не копируется. Поддерживаемые преобразования: 1D -\> C-непрерывный и C-непрерывный -\> 1D.13561357Оба формата ограничены одноэлементными нативными форматами в синтаксисе модуля [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct). Один из форматов должен быть байтовым форматом ('B', 'b' или 'c'). Длина результата в байтах должна совпадать с исходной длиной.13581359Преобразование 1D/long в 1D/unsigned bytes:13601361```python1362>>> import array1363>>> a = array.array('l', [1,2,3])1364>>> x = memoryview(a)1365>>> x.format1366'l'1367>>> x.itemsize136881369>>> len(x)137031371>>> x.nbytes1372241373>>> y = x.cast('B')1374>>> y.format1375'B'1376>>> y.itemsize137711378>>> len(y)1379241380>>> y.nbytes1381241382```13831384Преобразование 1D/unsigned bytes в 1D/char:13851386```python1387>>> b = bytearray(b'zyz')1388>>> x = memoryview(b)1389>>> x[0] = b'a'1390Traceback (most recent call last):1391  File "<stdin>", line 1, in <module>1392ValueError: memoryview: invalid value for format "B"1393>>> y = x.cast('c')1394>>> y[0] = b'a'1395>>> b1396bytearray(b'ayz')1397```13981399Преобразование 1D/bytes в 3D/ints в 1D/signed char:14001401```python1402>>> import struct1403>>> buf = struct.pack("i"*12, *list(range(12)))1404>>> x = memoryview(buf)1405>>> y = x.cast('i', shape=[2,2,3])1406>>> y.tolist()1407[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]1408>>> y.format1409'i'1410>>> y.itemsize141141412>>> len(y)141321414>>> y.nbytes1415481416>>> z = y.cast('b')1417>>> z.format1418'b'1419>>> z.itemsize142011421>>> len(z)1422481423>>> z.nbytes1424481425```14261427Преобразовать 1D/unsigned char в 2D/unsigned long:14281429```python1430>>> buf = struct.pack("L"*6, *list(range(6)))1431>>> x = memoryview(buf)1432>>> y = x.cast('L', shape=[2,3])1433>>> len(y)143421435>>> y.nbytes1436481437>>> y.tolist()1438[[0, 1, 2], [3, 4, 5]]1439```14401441Новое в версии 3.3.14421443Также доступно несколько атрибутов только для чтения:14441445#### `obj`14461447Базовый объект memoryview:14481449```python1450>>> b  = bytearray(b'xyz')1451>>> m = memoryview(b)1452>>> m.obj is b1453True1454```14551456Новое в версии 3.3.14571458#### `nbytes`14591460`nbytes == product(shape) * itemsize == len(m.tobytes())`. Это объём в байтах, который массив занял бы в непрерывном представлении. Он не обязательно равен len(m):14611462```python1463>>> import array1464>>> a = array.array('i', [1,2,3,4,5])1465>>> m = memoryview(a)1466>>> len(m)146751468>>> m.nbytes1469201470>>> y = m[::2]1471>>> len(y)147231473>>> y.nbytes1474121475>>> len(y.tobytes())1476121477```14781479Многомерные массивы:14801481```python1482>>> import struct1483>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])1484>>> x = memoryview(buf)1485>>> y = x.cast('d', shape=[3,4])1486>>> y.tolist()1487[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]1488>>> len(y)148931490>>> y.nbytes1491961492```14931494Новое в версии 3.3.14951496#### `readonly`14971498Логическое значение bool, указывающее, доступна ли память только для чтения.14991500#### `format`15011502Строка, содержащая формат (в стиле модуля [`struct`](https://python-all.ru/3.3/library/struct.html#module-struct)) для каждого элемента представления. Memoryview можно создать из экспортёров с произвольными строками формата, но некоторые методы (например, [`tolist()`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.tolist)) ограничены нативными одноэлементными форматами.15031504Изменено в версии 3.3: формат `'B'` теперь обрабатывается в соответствии с синтаксисом модуля struct. Это означает, что `memoryview(b'abc')[0] == b'abc'[0] == 97`.15051506#### `itemsize`15071508Размер в байтах каждого элемента memoryview:15091510```python1511>>> import array, struct1512>>> m = memoryview(array.array('H', [32000, 32001, 32002]))1513>>> m.itemsize151421515>>> m[0]1516320001517>>> struct.calcsize('H') == m.itemsize1518True1519```15201521#### `ndim`15221523Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.15241525#### `shape`15261527Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.ndim), задающий форму памяти в виде N-мерного массива.15281529Изменено в версии 3.3: Пустой кортеж вместо None, когда ndim = 0.15301531#### `strides`15321533Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.3/library/stdtypes.html#memoryview.ndim), задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.15341535Изменено в версии 3.3: Пустой кортеж вместо None, когда ndim = 0.15361537#### `suboffsets`15381539Используется внутри для массивов в стиле PIL. Значение носит только информационный характер.15401541#### `c_contiguous`15421543Логическое значение, указывающее, является ли память C-непрерывной.15441545Новое в версии 3.3.15461547#### `f_contiguous`15481549Логическое значение, указывающее, является ли память непрерывной по Фортрану.15501551Новое в версии 3.3.15521553#### `contiguous`15541555Логическое значение, указывающее, является ли память непрерывной.15561557Новое в версии 3.3.15581559## 4.9. Типы множеств – [`set`](https://python-all.ru/3.3/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset)15601561Объект *set* – это неупорядоченная коллекция различных [*хэшируемых*](https://python-all.ru/3.3/glossary.html#term-hashable) объектов. Обычно используется для проверки принадлежности, удаления дубликатов из последовательности и выполнения математических операций, таких как пересечение, объединение, разность и симметрическая разность. (Другие контейнеры см. во встроенных классах [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.3/library/stdtypes.html#list) и [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple), а также в модуле [`collections`](https://python-all.ru/3.3/library/collections.html#module-collections).)15621563Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множества не сохраняют позицию элемента или порядок вставки. Соответственно, множества не поддерживают индексацию, срезы или другое поведение, подобное последовательностям.15641565В настоящее время существует два встроенных типа множеств: [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset). Тип [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) является изменяемым – его содержимое можно менять с помощью методов [`add()`](https://python-all.ru/3.3/library/stdtypes.html#set.add) и [`remove()`](https://python-all.ru/3.3/library/stdtypes.html#set.remove). Поскольку он изменяем, у него нет хэш-значения, и он не может использоваться ни как ключ словаря, ни как элемент другого множества. Тип [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset) является неизменяемым и [*хэшируемым*](https://python-all.ru/3.3/glossary.html#term-hashable) – его содержимое нельзя изменить после создания; поэтому он может использоваться как ключ словаря или как элемент другого множества.15661567Непустые множества (не frozenset) можно создать, перечислив элементы через запятую в фигурных скобках, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.3/library/stdtypes.html#set).15681569Конструкторы обоих классов работают одинаково:15701571#### `class set([iterable])`15721573#### `class frozenset([iterable])`15741575Return a new set or frozenset object whose elements are taken from *iterable*. The elements of a set must be [*hashable*](https://python-all.ru/3.3/glossary.html#term-hashable). To represent sets of sets, the inner sets must be [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset) objects. If *iterable* is not specified, a new empty set is returned.15761577Instances of [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset) provide the following operations:15781579#### `len(s)`15801581Return the cardinality of set *s*.15821583#### `x in s`15841585Проверяет принадлежность *x* множеству *s*.15861587#### `x not in s`15881589Проверяет отсутствие *x* в множестве *s*.15901591#### `isdisjoint(other)`15921593Return `True` if the set has no elements in common with *other*. Sets are disjoint if and only if their intersection is the empty set.15941595#### `issubset(other)`15961597#### `set <= other`15981599Проверяет, принадлежит ли каждый элемент множества множеству *other*.16001601#### `set < other`16021603Test whether the set is a proper subset of *other*, that is, `set <= other and set != other`.16041605#### `issuperset(other)`16061607#### `set >= other`16081609Проверяет, принадлежит ли каждый элемент *other* множеству.16101611#### `set > other`16121613Test whether the set is a proper superset of *other*, that is, `set >= other and set != other`.16141615#### `union(other, ...)`16161617#### `set | other | ...`16181619Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.16201621#### `intersection(other, ...)`16221623#### `set & other & ...`16241625Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.16261627#### `difference(other, ...)`16281629#### `set - other - ...`16301631Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.16321633#### `symmetric_difference(other)`16341635#### `set ^ other`16361637Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в *other*, но не в обоих.16381639#### `copy()`16401641Возвращает новое множество с поверхностной копией *s*.16421643Note, the non-operator versions of [`union()`](https://python-all.ru/3.3/library/stdtypes.html#set.union), [`intersection()`](https://python-all.ru/3.3/library/stdtypes.html#set.intersection), [`difference()`](https://python-all.ru/3.3/library/stdtypes.html#set.difference), and [`symmetric_difference()`](https://python-all.ru/3.3/library/stdtypes.html#set.symmetric_difference), [`issubset()`](https://python-all.ru/3.3/library/stdtypes.html#set.issubset), and [`issuperset()`](https://python-all.ru/3.3/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')`.16441645Both [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.3/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).16461647Instances of [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) are compared to instances of [`frozenset`](https://python-all.ru/3.3/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')])`.16481649The subset and equality comparisons do not generalize to a total ordering function. For example, any two nonempty disjoint sets are not equal and are not subsets of each other, so *all* of the following return `False`: `a<b`, `a==b`, or `a>b`.16501651Поскольку множества определяют только частичный порядок (отношения подмножества), результат работы метода [`list.sort()`](https://python-all.ru/3.3/library/stdtypes.html#list.sort) не определён для списков множеств.16521653Элементы множества, как и ключи словаря, должны быть [*хэшируемыми*](https://python-all.ru/3.3/glossary.html#term-hashable).16541655Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset).16561657В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.3/library/stdtypes.html#set), которые не применяются к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.3/library/stdtypes.html#frozenset):16581659#### `update(other, ...)`16601661#### `set |= other | ...`16621663Обновляет множество, добавляя элементы из всех других.16641665#### `intersection_update(other, ...)`16661667#### `set &= other & ...`16681669Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.16701671#### `difference_update(other, ...)`16721673#### `set -= other | ...`16741675Обновляет множество, удаляя элементы, найденные в других.16761677#### `symmetric_difference_update(other)`16781679#### `set ^= other`16801681Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.16821683#### `add(elem)`16841685Добавляет элемент *elem* в множество.16861687#### `remove(elem)`16881689Удаляет элемент *elem* из множества. Вызывает [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError), если *elem* не содержится во множестве.16901691#### `discard(elem)`16921693Удаляет элемент *elem* из множества, если он присутствует.16941695#### `pop()`16961697Удаляет и возвращает произвольный элемент из множества. Вызывает [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError), если множество пусто.16981699#### `clear()`17001701Удаляет все элементы из множества.17021703Обратите внимание: версии методов [`update()`](https://python-all.ru/3.3/library/stdtypes.html#set.update), [`intersection_update()`](https://python-all.ru/3.3/library/stdtypes.html#set.intersection_update), [`difference_update()`](https://python-all.ru/3.3/library/stdtypes.html#set.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.3/library/stdtypes.html#set.symmetric_difference_update), не использующие операторы, принимают любой итерируемый объект в качестве аргумента.17041705Обратите внимание: аргумент *elem* методов [`__contains__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.3/library/stdtypes.html#set.remove) и [`discard()`](https://python-all.ru/3.3/library/stdtypes.html#set.discard) может быть множеством. Для поддержки поиска эквивалентного неизменяемого множества (frozenset) множество *elem* временно изменяется во время поиска, а затем восстанавливается. Во время поиска не следует читать или изменять множество *elem*, так как оно не имеет осмысленного значения.17061707## 4.10. Типы отображений – [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict)17081709Объект [*отображения*](https://python-all.ru/3.3/glossary.html#term-mapping) сопоставляет [*хешируемые*](https://python-all.ru/3.3/glossary.html#term-hashable) значения с произвольными объектами. Отображения – изменяемые объекты. В настоящее время существует только один стандартный тип отображения – *словарь*. (Другие контейнеры см. во встроенных классах [`list`](https://python-all.ru/3.3/library/stdtypes.html#list), [`set`](https://python-all.ru/3.3/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.3/library/stdtypes.html#tuple), а также в модуле [`collections`](https://python-all.ru/3.3/library/collections.html#module-collections).)17101711Ключи словаря могут быть *почти* любыми значениями. Значения, которые не являются [*хэшируемыми*](https://python-all.ru/3.3/glossary.html#term-hashable), то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, `1` и `1.0`), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)17121713Словари можно создать, поместив разделённый запятыми список пар `ключ: значение` в фигурные скобки, например: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`, или с помощью конструктора [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict).17141715#### `class dict(**kwarg)`17161717#### `class dict(mapping, **kwarg)`17181719#### `class dict(iterable, **kwarg)`17201721Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.17221723Если позиционный аргумент не передан, создаётся пустой словарь. Если позиционный аргумент передан и является отображением (mapping), создаётся словарь с теми же парами ключ-значение, что и у объекта-отображения. В противном случае позиционный аргумент должен быть [*итератором*](https://python-all.ru/3.3/glossary.html#term-iterator). Каждый элемент итерируемого объекта сам должен быть итератором ровно из двух объектов. Первый объект каждого элемента становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.17241725Если переданы именованные аргументы, они и их значения добавляются в словарь, созданный из позиционного аргумента. Если добавляемый ключ уже присутствует, значение из именованного аргумента заменяет значение из позиционного аргумента.17261727В качестве иллюстрации следующие примеры все возвращают словарь, равный `{"one": 1, "two": 2, "three": 3}`:17281729```python1730>>> a = dict(one=1, two=2, three=3)1731>>> b = {'one': 1, 'two': 2, 'three': 3}1732>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))1733>>> d = dict([('two', 2), ('one', 1), ('three', 3)])1734>>> e = dict({'three': 3, 'one': 1, 'two': 2})1735>>> a == b == c == d == e1736True1737```17381739Передача именованных аргументов, как в первом примере, работает только для ключей, являющихся допустимыми идентификаторами Python. В противном случае можно использовать любые допустимые ключи.17401741Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):17421743#### `len(d)`17441745Возвращает количество элементов в словаре *d*.17461747#### `d[key]`17481749Возвращает элемент *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError), если *key* отсутствует в отображении.17501751Если подкласс dict определяет метод `__missing__()`, то если ключ *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает то, что было возвращено или возбуждено вызовом `__missing__(key)`, если ключ отсутствует. Никакие другие операции или методы не вызывают `__missing__()`. Если `__missing__()` не определён, возбуждается [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError). `__missing__()` должен быть методом; он не может быть переменной экземпляра:17521753```python1754>>> class Counter(dict):1755...     def __missing__(self, key):1756...         return 01757>>> c = Counter()1758>>> c['red']175901760>>> c['red'] += 11761>>> c['red']176211763```17641765Смотрите [`collections.Counter`](https://python-all.ru/3.3/library/collections.html#collections.Counter) для полной реализации, включающей другие методы, полезные для накопления и управления подсчётами.17661767#### `d[key] = value`17681769Устанавливает `d[key]` в *value*.17701771#### `del d[key]`17721773Remove `d[key]` from *d*. Raises a [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError) if *key* is not in the map.17741775#### `key in d`17761777Возвращает `True`, если *d* содержит ключ *key*, иначе `False`.17781779#### `key not in d`17801781Эквивалентно `not key in d`.17821783#### `iter(d)`17841785Возвращает итератор по ключам словаря. Это более короткая запись для `iter(d.keys())`.17861787#### `clear()`17881789Удаляет все элементы из словаря.17901791#### `copy()`17921793Возвращает поверхностную копию словаря.17941795#### `classmethod fromkeys(seq[, value])`17961797Создаёт новый словарь, ключи которого берутся из *seq*, а значения устанавливаются равными *value*.17981799[`fromkeys()`](https://python-all.ru/3.3/library/stdtypes.html#dict.fromkeys) – это метод класса, который возвращает новый словарь. *value* по умолчанию равен `None`.18001801#### `get(key[, default])`18021803Возвращает значение для *key*, если *key* есть в словаре, иначе *default*. Если *default* не указан, он по умолчанию равен `None`, так что этот метод никогда не вызывает [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError).18041805#### `items()`18061807Возвращает новое представление элементов словаря (пары `(key, value)`). См. [*документацию о представлениях*](https://python-all.ru/3.3/library/stdtypes.html#dict-views).18081809#### `keys()`18101811Возвращает новое представление ключей словаря. См. [*документацию по объектам-представлениям*](https://python-all.ru/3.3/library/stdtypes.html#dict-views).18121813#### `pop(key[, default])`18141815Если *key* есть в словаре, удаляет его и возвращает его значение, иначе возвращает *default*. Если *default* не указан и *key* отсутствует в словаре, вызывается [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError).18161817#### `popitem()`18181819Удаляет и возвращает произвольную пару `(key, value)` из словаря.18201821[`popitem()`](https://python-all.ru/3.3/library/stdtypes.html#dict.popitem) удобна для разрушающего перебора словаря, что часто используется в алгоритмах над множествами. Если словарь пуст, вызов [`popitem()`](https://python-all.ru/3.3/library/stdtypes.html#dict.popitem) вызывает [`KeyError`](https://python-all.ru/3.3/library/exceptions.html#KeyError).18221823#### `setdefault(key[, default])`18241825Если *key* есть в словаре, возвращает его значение. Если нет, вставляет *key* со значением *default* и возвращает *default*. *default* по умолчанию равен `None`.18261827#### `update([other])`18281829Обновляет словарь парами ключ/значение из *other*, перезаписывая существующие ключи. Возвращает `None`.18301831[`update()`](https://python-all.ru/3.3/library/stdtypes.html#dict.update) принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (кортежи или другие итерабельные объекты длиной два). Если указаны именованные аргументы, словарь обновляется этими парами ключ/значение: `d.update(red=1, blue=2)`.18321833#### `values()`18341835Возвращает новое представление (view) значений словаря. См. [*документацию по объектам-представлениям*](https://python-all.ru/3.3/library/stdtypes.html#dict-views).18361837> **См. также**1838>1839> [`types.MappingProxyType`](https://python-all.ru/3.3/library/types.html#types.MappingProxyType) можно использовать для создания представления только для чтения для [`dict`](https://python-all.ru/3.3/library/stdtypes.html#dict).18401841### 4.10.1. Объекты-представления словаря18421843Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.3/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.3/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.3/library/stdtypes.html#dict.items), являются *представлениями*. Они предоставляют динамическое представление содержимого словаря: при изменении словаря представление отражает эти изменения.18441845Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:18461847#### `len(dictview)`18481849Возвращает количество записей в словаре.18501851#### `iter(dictview)`18521853Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) словаря.18541855Ключи и значения итерируются в произвольном порядке, который не является случайным, варьируется в разных реализациях Python и зависит от истории вставок и удалений в словаре. Если представления ключей, значений и элементов итерируются без промежуточных изменений словаря, порядок элементов будет прямо соответствовать друг другу. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.3/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать тот же список: `pairs = [(v, k) for (k, v) in d.items()]`.18561857Итерация по представлениям во время добавления или удаления записей в словаре может вызвать [`RuntimeError`](https://python-all.ru/3.3/library/exceptions.html#RuntimeError) или не выполнить итерацию по всем записям.18581859#### `x in dictview`18601861Возвращает `True`, если *x* находится среди ключей, значений или элементов базового словаря (в последнем случае *x* должен быть кортежем `(key, value)`).18621863Представления ключей ведут себя как множества, поскольку их записи уникальны и хешируемы. Если все значения хешируемы, так что пары `(key, value)` уникальны и хешируемы, то представление элементов также ведёт себя как множество. (Представления значений не считаются множествами, так как их записи обычно не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса [`collections.abc.Set`](https://python-all.ru/3.3/library/collections.abc.html#collections.abc.Set) (например, `==`, `<` или `^`).18641865Пример использования представления словаря:18661867```python1868>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}1869>>> keys = dishes.keys()1870>>> values = dishes.values()18711872>>> # итерация1873>>> n = 01874>>> for val in values:1875...     n += val1876>>> print(n)187750418781879>>> # ключи и значения перебираются в одном и том же порядке1880>>> list(keys)1881['eggs', 'bacon', 'sausage', 'spam']1882>>> list(values)1883[2, 1, 1, 500]18841885>>> # объекты представления динамичны и отражают изменения словаря1886>>> del dishes['eggs']1887>>> del dishes['sausage']1888>>> list(keys)1889['spam', 'bacon']18901891>>> # операции над множествами1892>>> keys & {'eggs', 'bacon', 'salad'}1893{'bacon'}1894>>> keys ^ {'sausage', 'juice'}1895{'juice', 'sausage', 'bacon', 'spam'}1896```18971898## 4.11. Типы контекстных менеджеров18991900Оператор [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with) в Python поддерживает концепцию контекста выполнения, определяемого менеджером контекста. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который вводится перед выполнением тела оператора и завершается при окончании оператора:19011902#### `contextmanager.__enter__()`19031904Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, привязывается к идентификатору в предложении [`as`](https://python-all.ru/3.3/reference/compound_stmts.html#as) оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with), использующего данный менеджер контекста.19051906Примером менеджера контекста, который возвращает самого себя, является [*файловый объект*](https://python-all.ru/3.3/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить [`open()`](https://python-all.ru/3.3/library/functions.html#open) использовать в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with).19071908Примером менеджера контекста, возвращающего связанный объект, является тот, который возвращается [`decimal.localcontext()`](https://python-all.ru/3.3/library/decimal.html#decimal.localcontext). Эти менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста, а затем возвращают копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with), не затрагивая код вне оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with).19091910#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`19111912Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если во время выполнения тела оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with) произошло исключение, аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.19131914Возврат истинного значения из этого метода заставит оператор [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with) подавить исключение и продолжить выполнение с оператора, следующего непосредственно за оператором [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with). В противном случае исключение продолжает распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, произошедшее в теле оператора [`with`](https://python-all.ru/3.3/reference/compound_stmts.html#with).19151916Переданное исключение никогда не следует явно возбуждать повторно – вместо этого метод должен возвращать ложное значение, показывая, что метод выполнен успешно и не подавляет возникшее исключение. Это позволяет коду управления контекстом (например, `contextlib.nested`) легко определить, завершился ли метод [`__exit__()`](https://python-all.ru/3.3/library/stdtypes.html#contextmanager.__exit__) неудачей.19171918Python определяет несколько менеджеров контекста для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов и более простого управления активным десятичным контекстом. Конкретные типы не обрабатываются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.3/library/contextlib.html#module-contextlib) для примеров.19191920[*Генераторы*](https://python-all.ru/3.3/glossary.html#term-generator) Python и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.3/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором [`contextlib.contextmanager`](https://python-all.ru/3.3/library/contextlib.html#contextlib.contextmanager), она вернёт менеджер контекста, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.3/reference/datamodel.html#object.__exit__), а не итератор, создаваемый недекорированной функцией-генератором.19211922Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.19231924## 4.12. Другие встроенные типы19251926Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.19271928### 4.12.1. Модули19291930Единственная специальная операция над модулем – это доступ к атрибуту: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.3/reference/simple_stmts.html#import), строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, скорее он требует (внешнего) *определения* для модуля с именем *foo* где-либо.)19311932Специальным атрибутом каждого модуля является [`__dict__`](https://python-all.ru/3.3/library/stdtypes.html#object.__dict__). Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически изменит таблицу символов модуля, но прямое присваивание атрибуту `__dict__` невозможно (можно написать `m.__dict__['a'] = 1`, что определяет `m.a` как `1`, но нельзя написать `m.__dict__ = {}`). Изменять `__dict__` напрямую не рекомендуется.19331934Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.19351936### 4.12.2. Классы и экземпляры классов19371938См. [*Объекты, значения и типы*](https://python-all.ru/3.3/reference/datamodel.html#objects) и [*Определения классов*](https://python-all.ru/3.3/reference/compound_stmts.html#class).19391940### 4.12.3. Функции19411942Объекты функций создаются определениями функций. Единственная операция над объектом функции – это его вызов: `func(argument-list)`.19431944На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.19451946Дополнительную информацию см. в разделе [*Определения функций*](https://python-all.ru/3.3/reference/compound_stmts.html#function).19471948### 4.12.4. Методы19491950Методы – это функции, которые вызываются с использованием точечной нотации. Существует две разновидности: встроенные методы (например, `append()` у списков) и методы экземпляров классов. Встроенные методы описываются вместе с типами, которые их поддерживают.19511952Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, получается специальный объект: объект *связанного метода* (также называемый *методом экземпляра*). При вызове он добавляет аргумент `self` в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: `m.__self__` – это объект, над которым выполняется метод, а `m.__func__` – это функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.19531954Как и объекты функций, объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции (`meth.__func__`), установка атрибутов метода на связанных методах запрещена. Попытка установить атрибут у метода приводит к возбуждению [`AttributeError`](https://python-all.ru/3.3/library/exceptions.html#AttributeError). Чтобы установить атрибут метода, нужно явно установить его в базовом объекте функции:19551956```python1957>>> class C:1958...     def method(self):1959...         pass1960...1961>>> c = C()1962>>> c.method.whoami = 'my name is method'  # нельзя установить на методе1963Traceback (most recent call last):1964  File "<stdin>", line 1, in <module>1965AttributeError: 'method' object has no attribute 'whoami'1966>>> c.method.__func__.whoami = 'my name is method'1967>>> c.method.whoami1968'my name is method'1969```19701971Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.3/reference/datamodel.html#types).19721973### 4.12.5. Объекты кода19741975Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, например, тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.3/library/functions.html#compile) и могут быть извлечены из объектов функций через их атрибут `__code__`. См. также модуль [`code`](https://python-all.ru/3.3/library/code.html#module-code).19761977Объект кода может быть выполнен или вычислен путём передачи его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.3/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.3/library/functions.html#eval).19781979Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.3/reference/datamodel.html#types).19801981### 4.12.6. Объекты типов19821983Объекты типов представляют различные типы объектов. Тип объекта доступен через встроенную функцию [`type()`](https://python-all.ru/3.3/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.3/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.19841985Типы записываются так: `<class 'int'>`.19861987### 4.12.7. Объект None19881989Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один пустой объект с именем `None` (встроенное имя). `type(None)()` создаёт тот же самый синглтон.19901991Он записывается как `None`.19921993### 4.12.8. Объект Ellipsis19941995Этот объект обычно используется при срезах (см. [*Срезы*](https://python-all.ru/3.3/reference/expressions.html#slicings)). Он не поддерживает специальных операций. Существует ровно один объект-многоточие с именем [`Ellipsis`](https://python-all.ru/3.3/library/constants.html#Ellipsis) (встроенное имя). `type(Ellipsis)()` создаёт синглтон [`Ellipsis`](https://python-all.ru/3.3/library/constants.html#Ellipsis).19961997Оно записывается как `Ellipsis` или `...`.19981999### 4.12.9. Объект NotImplemented20002001Этот объект возвращается из операций сравнения и бинарных операций, когда их просят работать с типами, которые они не поддерживают. См. [*Сравнения*](https://python-all.ru/3.3/reference/expressions.html#comparisons) для получения дополнительной информации. Существует ровно один объект `NotImplemented`. `type(NotImplemented)()` создаёт единственный экземпляр.20022003Оно записывается как `NotImplemented`.20042005### 4.12.10. Булевы значения20062007Логические значения – это два константных объекта `False` и `True`. Они используются для представления истинностных значений (хотя другие значения также могут считаться ложными или истинными). В числовом контексте (например, при использовании в качестве аргумента арифметического оператора) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция [`bool()`](https://python-all.ru/3.3/library/functions.html#bool) может использоваться для преобразования любого значения в логическое, если это значение может быть интерпретировано как истинностное (см. раздел [*Проверка истинности*](https://python-all.ru/3.3/library/stdtypes.html#truth) выше).20082009Они записываются как `False` и `True` соответственно.20102011### 4.12.11. Внутренние объекты20122013См. [*Стандартная иерархия типов*](https://python-all.ru/3.3/reference/datamodel.html#types) для получения этой информации. В нем описываются объекты стековых кадров, объекты трассировки и объекты срезов.20142015## 4.13. Специальные атрибуты20162017Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где они уместны. Некоторые из них не возвращаются встроенной функцией [`dir()`](https://python-all.ru/3.3/library/functions.html#dir).20182019#### `object.__dict__`20202021Словарь или другой отображающий объект, используемый для хранения (изменяемых) атрибутов объекта.20222023#### `instance.__class__`20242025Класс, которому принадлежит экземпляр класса.20262027#### `class.__bases__`20282029Кортеж базовых классов объекта класса.20302031#### `class.__name__`20322033Имя класса или типа.20342035#### `class.__qualname__`20362037[*Квалифицированное имя*](https://python-all.ru/3.3/glossary.html#term-qualified-name) класса или типа.20382039Новое в версии 3.3.20402041#### `class.__mro__`20422043Этот атрибут представляет собой кортеж классов, которые учитываются при поиске базовых классов во время разрешения методов.20442045#### `class.mro()`20462047Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в [`__mro__`](https://python-all.ru/3.3/library/stdtypes.html#class.__mro__).20482049#### `class.__subclasses__()`20502051Каждый класс хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех ещё существующих ссылок. Пример:20522053```python2054>>> int.__subclasses__()2055[<class 'bool'>]2056```20572058Сноски20592060| [\[1\]](https://python-all.ru/3.3/library/stdtypes.html#id1) | Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([*Базовая настройка*](https://python-all.ru/3.3/reference/datamodel.html#customization)). |2061| --- | --- |20622063| [\[2\]](https://python-all.ru/3.3/library/stdtypes.html#id2) | Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей. |2064| --- | --- |20652066| \[3\] | Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов. |2067| --- | --- |20682069| \[4\] | *([1](https://python-all.ru/3.3/library/stdtypes.html#id5), [2](https://python-all.ru/3.3/library/stdtypes.html#id6), [3](https://python-all.ru/3.3/library/stdtypes.html#id7), [4](https://python-all.ru/3.3/library/stdtypes.html#id8))* Символы с регистром – это те, у которых свойство общей категории равно «Lu» (Letter, uppercase), «Ll» (Letter, lowercase) или «Lt» (Letter, titlecase). |2070| --- | --- |20712072| [\[5\]](https://python-all.ru/3.3/library/stdtypes.html#id9) | Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж. |2073| --- | --- |2074