stdtypes.md

1> **Источник:** https://python-all.ru/3.4/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.4/library/functions.html#repr) или несколько отличной функции [`str()`](https://python-all.ru/3.4/library/stdtypes.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.4/library/functions.html#print).1617## 4.1. Проверка истинности1819Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.4/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.4/reference/compound_stmts.html#while) или в качестве операнда логических операций ниже. Следующие значения считаются ложными:2021>2223- `None`24- `False`25- ноль любого числового типа, например, `0`, `0.0`, `0j`.26- любая пустая последовательность, например, `''`, `()`, `[]`.27- любое пустое отображение, например, `{}`.28- экземпляры пользовательских классов, если класс определяет метод [`__bool__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__bool__) или [`__len__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__len__), когда этот метод возвращает целое ноль или логическое значение [`bool`](https://python-all.ru/3.4/library/functions.html#bool) `False`. [\[1\]](https://python-all.ru/3.4/library/stdtypes.html#id11)2930Все остальные значения считаются истинными – поэтому объекты многих типов всегда истинны.3132Операции и встроенные функции, возвращающие логический результат, всегда возвращают `0` или `False` для false и `1` или `True` для true, если не указано иное. (Важное исключение: логические операции `or` и `and` всегда возвращают один из своих операндов.)3334## 4.2. Логические операции – [`and`](https://python-all.ru/3.4/reference/expressions.html#and), [`or`](https://python-all.ru/3.4/reference/expressions.html#or), [`not`](https://python-all.ru/3.4/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.4/library/constants.html#False).472. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`True`](https://python-all.ru/3.4/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.4/library/exceptions.html#TypeError) при сравнении комплексного числа с другим встроенным числовым типом, когда объекты имеют разные типы, которые нельзя сравнивать, или в других случаях, когда не определён порядок.6869Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет метод [`__eq__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__eq__).7071Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или к объектам других типов, если класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__ge__) (в общем случае достаточно [`__lt__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__lt__) и [`__eq__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__eq__), если нужны обычные значения операторов сравнения).7273Поведение операторов [`is`](https://python-all.ru/3.4/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.4/reference/expressions.html#is-not) не может быть настроено; они также могут применяться к любым двум объектам и никогда не вызывают исключение.7475Ещё две операции с тем же синтаксическим приоритетом, [`in`](https://python-all.ru/3.4/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.4/reference/expressions.html#not-in), поддерживаются только типами последовательностей (см. ниже).7677## 4.4. Числовые типы – [`int`](https://python-all.ru/3.4/library/functions.html#int), [`float`](https://python-all.ru/3.4/library/functions.html#float), [`complex`](https://python-all.ru/3.4/library/functions.html#complex)7879Существует три различных числовых типа: *целые числа*, *числа с плавающей точкой* и *комплексные числа*. Кроме того, логические значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью `double` в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.4/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы: [`fractions`](https://python-all.ru/3.4/library/fractions.html#module-fractions) для рациональных чисел и [`decimal`](https://python-all.ru/3.4/library/decimal.html#module-decimal) для чисел с плавающей точкой с настраиваемой точностью.)8081Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Простые целые литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно прибавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.8283Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до типа другого, где целое уже, чем с плавающей точкой, а то, в свою очередь, уже, чем комплексное. Сравнения чисел смешанного типа используют то же правило. [\[2\]](https://python-all.ru/3.4/library/stdtypes.html#id12) Конструкторы [`int()`](https://python-all.ru/3.4/library/functions.html#int), [`float()`](https://python-all.ru/3.4/library/functions.html#float) и [`complex()`](https://python-all.ru/3.4/library/functions.html#complex) можно использовать для создания чисел определённого типа.8485Все числовые типы (кроме complex) поддерживают следующие операции, отсортированные по возрастанию приоритета (все числовые операции имеют более высокий приоритет, чем операции сравнения):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.4/library/functions.html#abs) |98| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.4/library/functions.html#int) |99| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.4/library/functions.html#float) |100| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.4/library/functions.html#complex) |101| `c.conjugate()` | сопряжённое комплексного числа *c* |  |  |102| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.4/library/functions.html#divmod) |103| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.4/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.4/library/functions.html#abs), если это уместно.1103. Преобразование из числа с плавающей запятой в целое может округлять или усекать как в C; см. функции [`math.floor()`](https://python-all.ru/3.4/library/math.html#math.floor) и [`math.ceil()`](https://python-all.ru/3.4/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   См. [http://www.unicode.org/Public/6.3.0/ucd/extracted/DerivedNumericType.txt](https://python-all.ru/3.4/library/stdtypes.html) для полного списка кодовых точек со свойством `Nd`.116117Все типы [`numbers.Real`](https://python-all.ru/3.4/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.4/library/functions.html#int) и [`float`](https://python-all.ru/3.4/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.4/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.4/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.4/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.4/library/numbers.html#numbers.Integral) [*абстрактный базовый класс*](https://python-all.ru/3.4/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.4/library/exceptions.html#OverflowError) возникает, если целое число не может быть представлено указанным количеством байт.197198Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.4/library/sys.html#sys.byteorder) в качестве значения порядка байт.199200Аргумент *signed* определяет, используется ли дополнительный код для представления целого числа. Если *signed* равен `False` и передано отрицательное целое число, возбуждается исключение [`OverflowError`](https://python-all.ru/3.4/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.4/glossary.html#term-bytes-like-object), либо итерабельным объектом, производящим байты.222223Аргумент *byteorder* определяет порядок байт, используемый для представления целого числа. Если *byteorder* равен `"big"`, старший байт находится в начале массива байт. Если *byteorder* равен `"little"`, старший байт находится в конце массива байт. Чтобы запросить собственный порядок байт хост-системы, используйте [`sys.byteorder`](https://python-all.ru/3.4/library/sys.html#sys.byteorder) в качестве значения порядка байт.224225Аргумент *signed* указывает, используется ли дополнительный код для представления целого числа.226227Новое в версии 3.2.228229### 4.4.3. Дополнительные методы для Float230231Тип float реализует [`numbers.Real`](https://python-all.ru/3.4/library/numbers.html#numbers.Real) [*абстрактный базовый класс*](https://python-all.ru/3.4/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.232233#### `float.as_integer_ratio()`234235Возвращает пару целых чисел, отношение которых в точности равно исходному числу с плавающей запятой, с положительным знаменателем. Возбуждает [`OverflowError`](https://python-all.ru/3.4/library/exceptions.html#OverflowError) для бесконечностей и [`ValueError`](https://python-all.ru/3.4/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.4/library/stdtypes.html#float.hex) – это метод экземпляра, тогда как [`float.fromhex()`](https://python-all.ru/3.4/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.4/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде на C или Java, а шестнадцатеричные строки, создаваемые символом формата `%a` в C или методом `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.4/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.4/reference/datamodel.html#object.__hash__) для подробностей). Для простоты реализации и эффективности для различных числовых типов (включая [`int`](https://python-all.ru/3.4/library/functions.html#int), [`float`](https://python-all.ru/3.4/library/functions.html#float), [`decimal.Decimal`](https://python-all.ru/3.4/library/decimal.html#decimal.Decimal) и [`fractions.Fraction`](https://python-all.ru/3.4/library/fractions.html#fractions.Fraction)) хеш Python для числовых типов основан на одной математической функции, которая определена для любого рационального числа и, следовательно, применима ко всем экземплярам [`int`](https://python-all.ru/3.4/library/functions.html#int) и [`fractions.Fraction`](https://python-all.ru/3.4/library/fractions.html#fractions.Fraction), а также ко всем конечным экземплярам [`float`](https://python-all.ru/3.4/library/functions.html#float) и [`decimal.Decimal`](https://python-all.ru/3.4/library/decimal.html#decimal.Decimal). По сути, эта функция задаётся приведением по модулю `P` для фиксированного простого числа `P`. Значение `P` доступно в Python как атрибут `modulus` объекта [`sys.hash_info`](https://python-all.ru/3.4/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.4/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.4/library/functions.html#float) или [`complex`](https://python-all.ru/3.4/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.4/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.356357Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:358359#### `iterator.__iter__()`360361Возвращает сам объект-итератор. Это требуется, чтобы и контейнеры, и итераторы можно было использовать с операторами [`for`](https://python-all.ru/3.4/reference/compound_stmts.html#for) и [`in`](https://python-all.ru/3.4/reference/expressions.html#in). Этот метод соответствует полю [`tp_iter`](https://python-all.ru/3.4/c-api/typeobj.html#c.PyTypeObject.tp_iter) структуры типа для объектов Python в Python/C API.362363#### `iterator.__next__()`364365Возвращает следующий элемент из контейнера. Если больше нет элементов, возбуждает исключение [`StopIteration`](https://python-all.ru/3.4/library/exceptions.html#StopIteration). Этот метод соответствует полю [`tp_iternext`](https://python-all.ru/3.4/c-api/typeobj.html#c.PyTypeObject.tp_iternext) структуры типа для объектов Python в Python/C API.366367Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.368369Как только метод [`__next__()`](https://python-all.ru/3.4/library/stdtypes.html#iterator.__next__) итератора возбуждает [`StopIteration`](https://python-all.ru/3.4/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.370371### 4.5.1. Типы генераторов372373Python’s [*generator*](https://python-all.ru/3.4/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.4/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.4/reference/datamodel.html#object.__iter__) and [`__next__()`](https://python-all.ru/3.4/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.4/reference/expressions.html#yieldexpr).374375## 4.6. Типы последовательностей – [`list`](https://python-all.ru/3.4/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple), [`range`](https://python-all.ru/3.4/library/stdtypes.html#range)376377Существуют три основных типа последовательностей: списки, кортежи и объекты range. Дополнительные типы последовательностей, предназначенные для обработки [*двоичных данных*](https://python-all.ru/3.4/library/stdtypes.html#binaryseq) и [*текстовых строк*](https://python-all.ru/3.4/library/stdtypes.html#textseq), описаны в отдельных разделах.378379### 4.6.1. Общие операции с последовательностями380381Операции в следующей таблице поддерживаются большинством типов последовательностей, как изменяемых, так и неизменяемых. Абстрактный базовый класс [`collections.abc.Sequence`](https://python-all.ru/3.4/library/collections.abc.html#collections.abc.Sequence) предоставляется, чтобы упростить правильную реализацию этих операций для пользовательских типов последовательностей.382383В этой таблице перечислены операции с последовательностями, отсортированные по возрастанию приоритета. В таблице *s* и *t* – последовательности одного типа, *n*, *i*, *j* и *k* – целые числа, а *x* – произвольный объект, удовлетворяющий любым ограничениям на тип и значение, накладываемым *s*.384385Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` (конкатенация) и `*` (повторение) имеют тот же приоритет, что и соответствующие числовые операции. [\[3\]](https://python-all.ru/3.4/library/stdtypes.html#id13)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` | эквивалентно сложению *s* с собой *n* раз | (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.4/reference/expressions.html#comparisons) в справочнике по языку.)403404Примечания:4054061. Хотя операции `in` и `not in` в общем случае используются только для простой проверки вхождения, некоторые специализированные последовательности (например, [`str`](https://python-all.ru/3.4/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray)) также используют их для проверки на подпоследовательность:407408   ```python409   >>> "gg" in "eggs"410   True411   ```4122. Значения *n* меньше `0` трактуются как `0` (что даёт пустую последовательность того же типа, что и *s*). Обратите внимание: элементы последовательности *s* не копируются; на них ссылаются многократно. Это часто преследует начинающих программистов Python; рассмотрите:413414   ```python415   >>> lists = [[]] * 3416   >>> lists417   [[], [], []]418   >>> lists[0].append(3)419   >>> lists420   [[3], [3], [3]]421   ```422423   Дело в том, что `[[]]` – это список из одного элемента, содержащего пустой список, поэтому все три элемента `[[]] * 3` являются ссылками на этот единственный пустой список. Изменение любого из элементов `lists` изменяет этот единственный список. Чтобы создать список из разных списков, можно поступить так: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   ```433434   Подробное объяснение доступно в разделе FAQ [*Как создать многомерный список?*](https://python-all.ru/3.4/faq/programming.html#faq-multidimensional-list).4353. Если *i* или *j* отрицательно, индекс отсчитывается от конца строки: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание, что `-0` по-прежнему равно `0`.4364. Срез *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, таким что `i <= k < j`. Если *i* или *j* больше `len(s)`, используется `len(s)`. Если *i* опущено или равно `None`, используется `0`. Если *j* опущено или равно `None`, используется `len(s)`. Если *i* больше или равно *j*, срез пуст.4375. Срез *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`.4386. Конкатенация неизменяемых последовательностей всегда приводит к созданию нового объекта. Это означает, что построение последовательности путём многократной конкатенации будет иметь квадратичную временную сложность от общей длины последовательности. Чтобы получить линейную сложность, следует перейти к одному из следующих вариантов:439440   - при конкатенации [`str`](https://python-all.ru/3.4/library/stdtypes.html#str)-объектов можно собрать список и в конце использовать [`str.join()`](https://python-all.ru/3.4/library/stdtypes.html#str.join), либо записывать в экземпляр [`io.StringIO`](https://python-all.ru/3.4/library/io.html#io.StringIO) и получить его значение по завершении441   - при конкатенации [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes)-объектов можно аналогично использовать [`bytes.join()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.join) или [`io.BytesIO`](https://python-all.ru/3.4/library/io.html#io.BytesIO), либо выполнить конкатенацию на месте с помощью объекта [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray). Объекты [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray) изменяемы и имеют эффективный механизм перераспределения памяти.442   - при конкатенации [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple)-объектов лучше расширить список [`list`](https://python-all.ru/3.4/library/stdtypes.html#list)443   - для других типов – изучите документацию соответствующего класса4447. Некоторые типы последовательностей (например, [`range`](https://python-all.ru/3.4/library/stdtypes.html#range)) поддерживают только последовательности элементов, которые соответствуют определённым шаблонам, и поэтому не поддерживают конкатенацию или повторение последовательностей.4458. `index` возбуждает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), если *x* не найден в *s*. Если поддерживается, дополнительные аргументы метода index позволяют эффективно искать в подотрезках последовательности. Передача дополнительных аргументов примерно эквивалентна использованию `s[i:j].index(x)`, только без копирования данных и с возвращаемым индексом относительно начала последовательности, а не начала среза.446447### 4.6.2. Неизменяемые типы последовательностей448449Единственная операция, которую неизменяемые типы последовательностей обычно реализуют, но не реализуют изменяемые типы последовательностей – это поддержка встроенной функции [`hash()`](https://python-all.ru/3.4/library/functions.html#hash).450451Эта поддержка позволяет использовать неизменяемые последовательности, например экземпляры [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple), в качестве ключей [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict) и хранить в экземплярах [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset).452453Попытка вычислить хеш неизменяемой последовательности, содержащей нехешируемые значения, приведёт к [`TypeError`](https://python-all.ru/3.4/library/exceptions.html#TypeError).454455### 4.6.3. Изменяемые типы последовательностей456457Операции в следующей таблице определены для изменяемых типов последовательностей. Абстрактный базовый класс [`collections.abc.MutableSequence`](https://python-all.ru/3.4/library/collections.abc.html#collections.abc.MutableSequence) предоставляется для упрощения правильной реализации этих операций в пользовательских типах последовательностей.458459В таблице *s* – это экземпляр изменяемого типа последовательности, *t* – любой итерируемый объект, а *x* – произвольный объект, удовлетворяющий всем ограничениям на тип и значение, налагаемым *s* (например, [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray) принимает только целые числа, удовлетворяющие ограничению на значение `0 <= x <= 255`).460461| Операция | Результат | Примечания |462| --- | --- | --- |463| `s[i] = x` | элемент *i* из *s* заменяется на *x* |  |464| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* |  |465| `del s[i:j]` | то же, что `s[i:j] = []` |  |466| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами *t* | (1) |467| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка |  |468| `s.append(x)` | добавляет *x* в конец последовательности (то же, что `s[len(s):len(s)] = [x]`) |  |469| `s.clear()` | удаляет все элементы из `s` (то же, что `del s[:]`) | (5) |470| `s.copy()` | создаёт поверхностную копию `s` (то же, что `s[:]`) | (5) |471| `s.extend(t)` или `s += t` | расширяет *s* содержимым *t* (по большей части то же, что `s[len(s):len(s)] = t`) |  |472| `s *= n` | обновляет *s*, повторяя его содержимое *n* раз | (6) |473| `s.insert(i, x)` | вставляет *x* в *s* по индексу, заданному *i* (то же, что `s[i:i] = [x]`) |  |474| `s.pop([i])` | извлекает элемент по индексу *i* и удаляет его из *s* | (2) |475| `s.remove(x)` | удаляет первый элемент из *s* где `s[i] == x` | (3) |476| `s.reverse()` | переворачивает элементы *s* на месте | (4) |477478Примечания:4794801. *t* должен иметь ту же длину, что и заменяемый срез.4812. Необязательный аргумент *i* по умолчанию равен `-1`, поэтому по умолчанию удаляется и возвращается последний элемент.4823. `remove` вызывает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), если *x* не найден в *s*.4834. Метод `reverse()` изменяет последовательность на месте для экономии памяти при обращении большой последовательности. Чтобы напомнить пользователям, что он работает через побочный эффект, он не возвращает обращённую последовательность.4845. `clear()` и `copy()` включены для согласованности с интерфейсами изменяемых контейнеров, которые не поддерживают операции среза (таких как [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict) и [`set`](https://python-all.ru/3.4/library/stdtypes.html#set))485486   Новое в версии 3.3: `clear()` и `copy()` методы.4876. Значение *n* должно быть целым числом или объектом, реализующим [`__index__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__index__). Нулевые и отрицательные значения *n* очищают последовательность. Элементы последовательности не копируются; на них ссылаются несколько раз, как объяснено для `s * n` в разделе [*Общие операции с последовательностями*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common).488489### 4.6.4. Списки490491Списки – это изменяемые последовательности, обычно используемые для хранения коллекций однородных элементов (степень однородности может варьироваться в зависимости от приложения).492493#### `class list([iterable])`494495Списки можно создать несколькими способами:496497- Используя пару квадратных скобок для обозначения пустого списка: `[]`498- С использованием квадратных скобок, с разделением элементов запятыми: `[a]`, `[a, b, c]`499- С помощью генератора списка: `[x for x in iterable]`500- С помощью конструктора типа: `list()` или `list(iterable)`501502Конструктор создаёт список, элементы которого совпадают с элементами *iterable* и расположены в том же порядке. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является списком, создаётся и возвращается его копия, аналогично `iterable[:]`. Например, `list('abc')` возвращает `['a', 'b', 'c']` и `list( (1, 2, 3) )` возвращает `[1, 2, 3]`. Если аргумент не передан, конструктор создаёт новый пустой список, `[]`.503504Многие другие операции также создают списки, включая встроенную функцию [`sorted()`](https://python-all.ru/3.4/library/functions.html#sorted).505506Списки реализуют все [*общие*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common) и [*изменяемые*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-mutable) операции последовательностей. Списки также предоставляют следующий дополнительный метод:507508#### `sort(*, key=None, reverse=None)`509510Этот метод сортирует список на месте, используя только `<` сравнений между элементами. Исключения не подавляются – если какая-либо операция сравнения завершится ошибкой, вся сортировка завершится ошибкой (и список, скорее всего, останется в частично изменённом состоянии).511512Метод [`sort()`](https://python-all.ru/3.4/library/stdtypes.html#list.sort) принимает два аргумента, которые могут передаваться только по ключу ([*аргументы только по ключу*](https://python-all.ru/3.4/glossary.html#keyword-only-parameter)):513514*key* указывает функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка (например, `key=str.lower`). Ключ, соответствующий каждому элементу списка, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию `None` означает, что элементы списка сортируются напрямую, без вычисления отдельного ключа.515516Утилита [`functools.cmp_to_key()`](https://python-all.ru/3.4/library/functools.html#functools.cmp_to_key) доступна для преобразования функции *cmp* стиля 2.x в функцию *key*.517518*reverse* – это логическое значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.519520Этот метод изменяет последовательность на месте для экономии памяти при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает через побочный эффект, он не возвращает отсортированную последовательность (используйте [`sorted()`](https://python-all.ru/3.4/library/functions.html#sorted) для явного запроса нового экземпляра отсортированного списка).521522Метод [`sort()`](https://python-all.ru/3.4/library/stdtypes.html#list.sort) гарантированно является устойчивым. Сортировка устойчива, если она гарантирует, что не изменит относительный порядок элементов, которые сравниваются как равные – это полезно для сортировки в несколько проходов (например, сначала по отделу, затем по уровню зарплаты).523524**Особенность реализации CPython:** Во время сортировки списка результат попытки изменить или даже просмотреть список не определён. C-реализация Python делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.525526### 4.6.5. Кортежи527528Кортежи – это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных (например, кортежи из двух элементов, возвращаемые встроенной функцией [`enumerate()`](https://python-all.ru/3.4/library/functions.html#enumerate)). Кортежи также используются в случаях, когда требуется неизменяемая последовательность однородных данных (например, для хранения в экземпляре [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) или [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict)).529530#### `class tuple([iterable])`531532Кортежи можно создать несколькими способами:533534- Используя пару круглых скобок для обозначения пустого кортежа: `()`535- Использование завершающей запятой для кортежа из одного элемента: `a,` или `(a,)`536- Разделение элементов запятыми: `a, b, c` или `(a, b, c)`537- С помощью встроенной функции [`tuple()`](https://python-all.ru/3.4/library/stdtypes.html#tuple): `tuple()` или `tuple(iterable)`538539Конструктор создаёт кортеж, элементы которого совпадают с элементами *iterable* и расположены в том же порядке. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является кортежем, он возвращается без изменений. Например, `tuple('abc')` возвращает `('a', 'b', 'c')` и `tuple( [1, 2, 3] )` возвращает `(1, 2, 3)`. Если аргумент не передан, конструктор создаёт новый пустой кортеж, `()`.540541Обратите внимание, что кортеж создаётся запятой, а не скобками. Скобки необязательны, за исключением пустого кортежа или случаев, когда они нужны, чтобы избежать синтаксической неоднозначности. Например, `f(a, b, c)` – это вызов функции с тремя аргументами, а `f((a, b, c))` – вызов функции с одним аргументом – кортежем из трёх элементов.542543Кортежи реализуют все [*общие*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common) операции последовательностей.544545Для разнородных коллекций данных, где доступ по имени понятнее, чем по индексу, [`collections.namedtuple()`](https://python-all.ru/3.4/library/collections.html#collections.namedtuple) может быть более подходящим выбором, чем обычный кортеж.546547### 4.6.6. Диапазоны548549Тип [`range`](https://python-all.ru/3.4/library/stdtypes.html#range) представляет собой неизменяемую последовательность чисел и обычно используется для выполнения цикла определённое количество раз в циклах [`for`](https://python-all.ru/3.4/reference/compound_stmts.html#for).550551#### `class range(stop)`552553#### `class range(start, stop[, step])`554555Аргументы конструктора range должны быть целыми числами (либо встроенный [`int`](https://python-all.ru/3.4/library/functions.html#int), либо любой объект, реализующий специальный метод `__index__`). Если аргумент *step* опущен, по умолчанию он равен `1`. Если аргумент *start* опущен, по умолчанию он равен `0`. Если *step* равен нулю, возбуждается [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError).556557Для положительного *step* содержимое диапазона `r` определяется формулой `r[i] = start + step*i`, где `i >= 0` и `r[i] < stop`.558559Для отрицательного *step* содержимое диапазона по-прежнему определяется формулой `r[i] = start + step*i`, но ограничения: `i >= 0` и `r[i] > stop`.560561Объект range будет пустым, если `r[0]` не удовлетворяет ограничению на значение. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексация с конца последовательности, определённой положительными индексами.562563Диапазоны, содержащие абсолютные значения больше [`sys.maxsize`](https://python-all.ru/3.4/library/sys.html#sys.maxsize), допускаются, но некоторые функции (например, [`len()`](https://python-all.ru/3.4/library/functions.html#len)) могут возбуждать [`OverflowError`](https://python-all.ru/3.4/library/exceptions.html#OverflowError).564565Примеры диапазонов:566567```python568>>> list(range(10))569[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]570>>> list(range(1, 11))571[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]572>>> list(range(0, 30, 5))573[0, 5, 10, 15, 20, 25]574>>> list(range(0, 10, 3))575[0, 3, 6, 9]576>>> list(range(0, -10, -1))577[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]578>>> list(range(0))579[]580>>> list(range(1, 0))581[]582```583584Диапазоны реализуют все [*общие*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common) операции последовательностей, за исключением конкатенации и повторения (ввиду того, что объекты диапазонов могут представлять только последовательности, следующие строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).585586The advantage of the [`range`](https://python-all.ru/3.4/library/stdtypes.html#range) type over a regular [`list`](https://python-all.ru/3.4/library/stdtypes.html#list) or [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple) is that a [`range`](https://python-all.ru/3.4/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).587588Объекты range реализуют абстрактный базовый класс [`collections.abc.Sequence`](https://python-all.ru/3.4/library/collections.abc.html#collections.abc.Sequence) и предоставляют такие возможности, как проверка вхождения, поиск индекса элемента, извлечение среза и поддержка отрицательных индексов (см. [*Sequence Types – list, tuple, range*](https://python-all.ru/3.4/library/stdtypes.html#typesseq)):589590```python591>>> r = range(0, 20, 2)592>>> r593range(0, 20, 2)594>>> 11 in r595False596>>> 10 in r597True598>>> r.index(10)5995600>>> r[5]60110602>>> r[:5]603range(0, 10, 2)604>>> r[-1]60518606```607608Проверка объектов range на равенство с помощью `==` и `!=` сравнивает их как последовательности. То есть два объекта range считаются равными, если они представляют одну и ту же последовательность значений. (Обратите внимание, что два равных объекта range могут иметь разные атрибуты `start`, `stop` и `step`, например `range(0) == range(2, 1, 3)` или `range(0, 3, 2) == range(0, 4, 2)`).609610Изменено в версии 3.2: Реализует ABC Sequence. Поддерживает срезы и отрицательные индексы. Проверяет принадлежность объектов [`int`](https://python-all.ru/3.4/library/functions.html#int) за константное время вместо перебора всех элементов.611612Изменено в версии 3.3: Определяет ‘==’ и ‘!=’ для сравнения объектов диапазонов на основе последовательности значений, которые они определяют (вместо сравнения по идентичности объектов).613614Новое в версии 3.3: Атрибуты `start`, `stop` и `step`.615616## 4.7. Текстовый тип последовательности – [`str`](https://python-all.ru/3.4/library/stdtypes.html#str)617618Текстовые данные в Python обрабатываются с помощью объектов [`str`](https://python-all.ru/3.4/library/stdtypes.html#str), или *строк*. Строки – это неизменяемые [*последовательности*](https://python-all.ru/3.4/library/stdtypes.html#typesseq) кодовых точек Unicode. Строковые литералы записываются разными способами:619620- Одинарные кавычки: `'allows embedded "double" quotes'`621- Двойные кавычки: `"allows embedded 'single' quotes"`.622- Тройные кавычки: `'''Three single quotes'''`, `"""Three double quotes"""`623624Строки в тройных кавычках могут занимать несколько строк – все сопутствующие пробельные символы будут включены в строковый литерал.625626Строковые литералы, которые являются частью одного выражения и разделены только пробельными символами, будут неявно преобразованы в один строковый литерал. То есть `("spam " "eggs") == "spam eggs"`.627628См. [*String and Bytes literals*](https://python-all.ru/3.4/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах строковых литералов, включая поддерживаемые escape-последовательности, и префикс `r` («сырой»), который отключает обработку большинства escape-последовательностей.629630Строки также могут быть созданы из других объектов с помощью конструктора [`str`](https://python-all.ru/3.4/library/stdtypes.html#str).631632Поскольку отдельного типа «символ» не существует, индексация строки возвращает строки длиной 1. То есть для непустой строки *s*, `s[0] == s[0:1]`.633634Также нет изменяемого строкового типа, но [`str.join()`](https://python-all.ru/3.4/library/stdtypes.html#str.join) или [`io.StringIO`](https://python-all.ru/3.4/library/io.html#io.StringIO) можно использовать для эффективного построения строк из нескольких фрагментов.635636Изменено в версии 3.3: Для обратной совместимости с серией Python 2 префикс `u` снова разрешён в строковых литералах. Он не влияет на смысл строковых литералов и не может сочетаться с префиксом `r`.637638#### `class str(object='')`639640#### `class str(object=b'', encoding='utf-8', errors='strict')`641642Возвращает строковое представление *object* в виде [*строки*](https://python-all.ru/3.4/library/stdtypes.html#textseq). Если *object* не передан, возвращается пустая строка. В противном случае поведение `str()` зависит от того, указаны ли *encoding* или *errors*, как описано ниже.643644Если не указаны ни *encoding*, ни *errors*, `str(object)` возвращает [`object.__str__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__str__), то есть «неформальное» или хорошо выводимое на печать строковое представление *object*. Для строковых объектов это сама строка. Если у *object* нет метода [`__str__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__str__), то [`str()`](https://python-all.ru/3.4/library/stdtypes.html#str) возвращает [`repr(object)`](https://python-all.ru/3.4/library/functions.html#repr).645646Если указан хотя бы один из аргументов *encoding* или *errors*, то *object* должен быть [*объектом, подобным bytes*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) (например, [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) или [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray)). В этом случае, если *object* является объектом [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) (или [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray)), то `str(bytes, encoding, errors)` эквивалентно [`bytes.decode(encoding, errors)`](https://python-all.ru/3.4/library/stdtypes.html#bytes.decode). В противном случае перед вызовом [`bytes.decode()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.decode) извлекается объект bytes, лежащий в основе буферного объекта. См. [*Binary Sequence Types – bytes, bytearray, memoryview*](https://python-all.ru/3.4/library/stdtypes.html#binaryseq) и [*Буферный протокол*](https://python-all.ru/3.4/c-api/buffer.html#bufferobjects) для получения информации о буферных объектах.647648Передача объекта [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) в [`str()`](https://python-all.ru/3.4/library/stdtypes.html#str) без аргументов *encoding* или *errors* относится к первому случаю – возврату неформального строкового представления (см. также опцию командной строки [*-b*](https://python-all.ru/3.4/using/cmdline.html#cmdoption-b) для Python). Например:649650```python651>>> str(b'Zoot!')652"b'Zoot!'"653```654655Дополнительную информацию о классе `str` и его методах см. в разделе [*Тип последовательности текста – str*](https://python-all.ru/3.4/library/stdtypes.html#textseq) и разделе [*Методы строк*](https://python-all.ru/3.4/library/stdtypes.html#string-methods) ниже. Для вывода форматированных строк см. раздел [*Форматирование строк*](https://python-all.ru/3.4/library/string.html#string-formatting). Кроме того, см. раздел [*Службы обработки текста*](https://python-all.ru/3.4/library/text.html#stringservices).656657### 4.7.1. Методы строк658659Строки реализуют все [*общие*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common) операции с последовательностями, а также дополнительные методы, описанные ниже.660661Строки также поддерживают два стиля форматирования: один обеспечивает высокую гибкость и настройку (см. [`str.format()`](https://python-all.ru/3.4/library/stdtypes.html#str.format), [*Синтаксис форматной строки*](https://python-all.ru/3.4/library/string.html#formatstrings) и [*Форматирование строк*](https://python-all.ru/3.4/library/string.html#string-formatting)), а другой основан на стиле C `printf`, который обрабатывает более узкий набор типов и немного сложнее в правильном использовании, но часто быстрее для тех случаев, которые он может обработать ([*Форматирование строк в стиле printf*](https://python-all.ru/3.4/library/stdtypes.html#old-string-formatting)).662663Раздел [*Службы обработки текста*](https://python-all.ru/3.4/library/text.html#textservices) стандартной библиотеки охватывает ряд других модулей, предоставляющих различные утилиты, связанные с текстом (включая поддержку регулярных выражений в модуле [`re`](https://python-all.ru/3.4/library/re.html#module-re)).664665#### `str.capitalize()`666667Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.668669#### `str.casefold()`670671Возвращает копию строки, преобразованную для регистронезависимого сравнения. Такие строки могут использоваться для сравнения без учёта регистра.672673Casefolding (преобразование регистра для сравнения) похоже на приведение к нижнему регистру, но более агрессивно, поскольку предназначено для удаления всех различий в регистре строки. Например, немецкая строчная буква `'ß'` эквивалентна `"ss"`. Поскольку она уже в нижнем регистре, [`lower()`](https://python-all.ru/3.4/library/stdtypes.html#str.lower) ничего не сделало бы с `'ß'`; [`casefold()`](https://python-all.ru/3.4/library/stdtypes.html#str.casefold) преобразует её в `"ss"`.674675Алгоритм casefolding описан в разделе 3.13 стандарта Unicode.676677Новое в версии 3.3.678679#### `str.center(width[, fillchar])`680681Возвращает строку, центрированную в строке длины *width*. Заполнение выполняется с помощью указанного *fillchar* (по умолчанию пробел ASCII). Исходная строка возвращается, если *width* меньше или равно `len(s)`.682683#### `str.count(sub[, start[, end]])`684685Возвращает количество непересекающихся вхождений подстроки *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов.686687#### `str.encode(encoding="utf-8", errors="strict")`688689Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* может быть задан для выбора другой схемы обработки ошибок. Значение по умолчанию для *errors* – `'strict'`, что означает, что ошибки кодирования вызывают [`UnicodeError`](https://python-all.ru/3.4/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'` и любые другие имена, зарегистрированные через [`codecs.register_error()`](https://python-all.ru/3.4/library/codecs.html#codecs.register_error); см. раздел [*Обработчики ошибок*](https://python-all.ru/3.4/library/codecs.html#error-handlers). Список возможных кодировок см. в разделе [*Стандартные кодировки*](https://python-all.ru/3.4/library/codecs.html#standard-encodings).690691Изменено в версии 3.1: Добавлена поддержка именованных аргументов.692693#### `str.endswith(suffix[, start[, end]])`694695Возвращает `True`, если строка заканчивается указанным *suffix*, иначе возвращает `False`. *suffix* также может быть кортежем суффиксов, которые нужно искать. С необязательным *start* проверка начинается с этой позиции. С необязательным *end* сравнение останавливается на этой позиции.696697#### `str.expandtabs(tabsize=8)`698699Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции находятся через каждые *tabsize* символов (по умолчанию 8, что дает позиции табуляции в колонках 0, 8, 16 и т.д.). Для расширения строки текущая колонка устанавливается в ноль, и строка просматривается посимвольно. Если символ является табуляцией (`\t`), в результат вставляются один или несколько пробелов, пока текущая колонка не достигнет следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символ является переводом строки (`\n`) или возвратом каретки (`\r`), он копируется, и текущая колонка сбрасывается в ноль. Любой другой символ копируется без изменений, и текущая колонка увеличивается на единицу независимо от того, как символ представлен при печати.700701```python702>>> '01\t012\t0123\t01234'.expandtabs()703'01      012     0123    01234'704>>> '01\t012\t0123\t01234'.expandtabs(4)705'01  012 0123    01234'706```707708#### `str.find(sub[, start[, end]])`709710Возвращает наименьший индекс в строке, где подстрока *sub* находится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.711712> **Примечание**713>714> Метод [`find()`](https://python-all.ru/3.4/library/stdtypes.html#str.find) следует использовать только тогда, когда нужно узнать положение *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.4/reference/expressions.html#in):715>716> ```python717> >>> 'Py' in 'Python'718> True719> ```720721#### `str.format(*args, **kwargs)`722723Выполняет операцию форматирования строки. Строка, к которой применяется этот метод, может содержать буквальный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию строки, в которой каждое поле замены заменено строковым значением соответствующего аргумента.724725```python726>>> "The sum of 1 + 2 is {0}".format(1+2)727'The sum of 1 + 2 is 3'728```729730См. [*Синтаксис форматных строк*](https://python-all.ru/3.4/library/string.html#formatstrings) для описания различных параметров форматирования, которые можно указать в форматных строках.731732#### `str.format_map(mapping)`733734Аналогично `str.format(**mapping)`, за исключением того, что `mapping` используется напрямую и не копируется в [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict). Это полезно, если, например, `mapping` является подклассом dict:735736```python737>>> class Default(dict):738...     def __missing__(self, key):739...         return key740...741>>> '{name} was born in {country}'.format_map(Default(name='Guido'))742'Guido was born in country'743```744745Новое в версии 3.2.746747#### `str.index(sub[, start[, end]])`748749Как и [`find()`](https://python-all.ru/3.4/library/stdtypes.html#str.find), но вызывает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), когда подстрока не найдена.750751#### `str.isalnum()`752753Возвращает true, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе false. Символ `c` является буквенно-цифровым, если один из следующих методов возвращает `True`: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()` или `c.isnumeric()`.754755#### `str.isalpha()`756757Возвращает true, если все символы в строке являются буквенными и есть хотя бы один символ, иначе false. Буквенные символы – это символы, определённые в базе данных символов Unicode как «Letter», т.е. те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Unicode.758759#### `str.isdecimal()`760761Возвращает true, если все символы в строке являются десятичными символами и есть хотя бы один символ, иначе false. Десятичные символы относятся к общей категории «Nd». Эта категория включает цифры и все символы, которые можно использовать для формирования чисел с десятичным основанием, например U+0660, АРАБСКО-ИНДИЙСКАЯ ЦИФРА НОЛЬ.762763#### `str.isdigit()`764765Возвращает true, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false. Цифры включают десятичные символы и цифры, требующие специальной обработки, например совместимые надстрочные цифры. Формально цифрой является символ со значением свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.766767#### `str.isidentifier()`768769Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, раздел [*Идентификаторы и ключевые слова*](https://python-all.ru/3.4/reference/lexical_analysis.html#identifiers).770771Используйте [`keyword.iskeyword()`](https://python-all.ru/3.4/library/keyword.html#keyword.iskeyword) для проверки зарезервированных идентификаторов, таких как [`def`](https://python-all.ru/3.4/reference/compound_stmts.html#def) и [`class`](https://python-all.ru/3.4/reference/compound_stmts.html#class).772773#### `str.islower()`774775Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.4/library/stdtypes.html#id14) в строке являются строчными и есть хотя бы один буквенный символ, иначе false.776777#### `str.isnumeric()`778779Возвращает true, если все символы в строке являются числовыми символами и есть хотя бы один символ, иначе false. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы – это символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric.780781#### `str.isprintable()`782783Возвращает true, если все символы строки являются печатаемыми или строка пуста, иначе false. Непечатаемые символы – это те, которые определены в базе данных Unicode как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатаемым. (Обратите внимание, что печатаемые символы в данном контексте – это те, которые не должны экранироваться при вызове [`repr()`](https://python-all.ru/3.4/library/functions.html#repr) для строки. Это не влияет на обработку строк, записываемых в [`sys.stdout`](https://python-all.ru/3.4/library/sys.html#sys.stdout) или [`sys.stderr`](https://python-all.ru/3.4/library/sys.html#sys.stderr).)784785#### `str.isspace()`786787Возвращает true, если в строке есть только пробельные символы и есть хотя бы один символ, иначе false. Пробельные символы – это символы, определённые в базе данных символов Unicode как «Other» или «Separator», а также символы со свойством двунаправленности, являющимся одним из «WS», «B» или «S».788789#### `str.istitle()`790791Возвращает true, если строка является строкой в заглавном регистре (titlecased) и есть хотя бы один символ, например прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. Иначе возвращает false.792793#### `str.isupper()`794795Возвращает true, если все буквенные символы [\[4\]](https://python-all.ru/3.4/library/stdtypes.html#id14) в строке являются прописными и есть хотя бы один буквенный символ, иначе false.796797#### `str.join(iterable)`798799Возвращает строку, которая является объединением строк в [*итерируемый объект*](https://python-all.ru/3.4/glossary.html#term-iterable) *итерируемый объект*. Исключение [`TypeError`](https://python-all.ru/3.4/library/exceptions.html#TypeError) будет возбуждено, если в *итерируемый объект* есть значения, не являющиеся строками, включая объекты [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes). Разделителем между элементами служит строка, предоставляющая этот метод.800801#### `str.ljust(width[, fillchar])`802803Возвращает строку, выровненную по левому краю в строке длины *width*. Заполнение выполняется с использованием указанного символа *fillchar* (по умолчанию – пробел ASCII). Исходная строка возвращается, если *width* меньше или равен `len(s)`.804805#### `str.lower()`806807Возвращает копию строки, в которой все символы, имеющие регистр, [\[4\]](https://python-all.ru/3.4/library/stdtypes.html#id14) преобразованы в нижний регистр.808809Используемый алгоритм приведения к нижнему регистру описан в разделе 3.13 стандарта Юникода.810811#### `str.lstrip([chars])`812813Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом; удаляются все комбинации его значений:814815```python816>>> '   spacious   '.lstrip()817'spacious   '818>>> 'www.example.com'.lstrip('cmowz.')819'example.com'820```821822#### `static str.maketrans(x[, y[, z]])`823824Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.4/library/stdtypes.html#str.translate).825826Если передан только один аргумент, это должен быть словарь, отображающий коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или None. Ключи-символы при этом будут преобразованы в коды.827828Если передано два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ из x будет сопоставлен символу на той же позиции в y. Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены None в результате.829830#### `str.partition(sep)`831832Разделяет строку по первому вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.833834#### `str.replace(old, new[, count])`835836Возвращает копию строки, в которой все вхождения подстроки *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.837838#### `str.rfind(sub[, start[, end]])`839840Возвращает наибольший индекс в строке, на котором найдена подстрока *sub*, такой, что *sub* содержится в `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1` при неудаче.841842#### `str.rindex(sub[, start[, end]])`843844Похож на [`rfind()`](https://python-all.ru/3.4/library/stdtypes.html#str.rfind), но возбуждает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), когда подстрока *sub* не найдена.845846#### `str.rjust(width[, fillchar])`847848Возвращает строку, выровненную по правому краю в строке длины *width*. Заполнение выполняется с использованием указанного символа *fillchar* (по умолчанию – пробел ASCII). Исходная строка возвращается, если *width* меньше или равен `len(s)`.849850#### `str.rpartition(sep)`851852Разделяет строку по последнему вхождению *sep* и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.853854#### `str.rsplit(sep=None, maxsplit=-1)`855856Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, причём *справа* Если *sep* не указан или равен `None`, разделителем считается любая строка из пробельных символов. За исключением разбиения справа, [`rsplit()`](https://python-all.ru/3.4/library/stdtypes.html#str.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.4/library/stdtypes.html#str.split), который подробно описан ниже.857858#### `str.rstrip([chars])`859860Возвращает копию строки с удалёнными конечными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является суффиксом; удаляются все комбинации его значений:861862```python863>>> '   spacious   '.rstrip()864'   spacious'865>>> 'mississippi'.rstrip('ipz')866'mississ'867```868869#### `str.split(sep=None, maxsplit=-1)`870871Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то ограничение на количество разбиений отсутствует (выполняются все возможные разбиения).872873Если указан *sep*, то последовательные разделители не объединяются в один, а считаются ограничителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов (например, `'1<>2<>3'.split('<>')` возвращает `['1', '2', '3']`). Разбиение пустой строки с указанным разделителем возвращает `['']`.874875Например:876877```python878>>> '1,2,3'.split(',')879['1', '2', '3']880>>> '1,2,3'.split(',', maxsplit=1)881['1', '2,3']882>>> '1,2,,3,'.split(',')883['1', '2', '', '3', '']884```885886Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и в результате не будет пустых строк в начале или конце, если строка начинается или заканчивается пробелами. Соответственно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.887888Например:889890```python891>>> '1 2 3'.split()892['1', '2', '3']893>>> '1 2 3'.split(maxsplit=1)894['1', '2 3']895>>> '   1   2   3   '.split()896['1', '2', '3']897```898899#### `str.splitlines([keepends])`900901Возвращает список строк в строке, разбивая её по границам строк. Символы перевода строки не включаются в результирующий список, если только *keepends* не задан и не равен true.902903Этот метод разбивает строку по следующим границам строк. В частности, эти границы являются расширенным набором [*универсальных символов перевода строки*](https://python-all.ru/3.4/glossary.html#term-universal-newlines).904905| Представление | Описание |906| --- | --- |907| `\n` | Перевод строки (LF) |908| `\r` | Возврат каретки (CR) |909| `\r\n` | Возврат каретки + перевод строки (CR+LF) |910| `\v` or `\x0b` | Линейная табуляция |911| `\f` or `\x0c` | Перевод страницы |912| `\x1c` | Разделитель файлов |913| `\x1d` | Разделитель групп |914| `\x1e` | Разделитель записей |915| `\x85` | Следующая строка (управляющий код C1) |916| `\u2028` | Разделитель строк |917| `\u2029` | Разделитель абзацев |918919Изменено в версии 3.2: `\v` и `\f` добавлены в список границ строк.920921Например:922923```python924>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()925['ab c', '', 'de fg', 'kl']926>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)927['ab c\n', '\n', 'de fg\r', 'kl\r\n']928```929930В отличие от [`split()`](https://python-all.ru/3.4/library/stdtypes.html#str.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, а завершающий перенос строки не приводит к появлению дополнительной строки:931932```python933>>> "".splitlines()934[]935>>> "One line\n".splitlines()936['One line']937```938939Для сравнения, `split('\n')` даёт:940941```python942>>> ''.split('\n')943['']944>>> 'Two lines\n'.split('\n')945['Two lines', '']946```947948#### `str.startswith(prefix[, start[, end]])`949950Возвращает `True`, если строка начинается с префикса *prefix*, иначе возвращает `False`. *prefix* также может быть кортежем искомых префиксов. С необязательным *start* проверка начинается с указанной позиции. С необязательным *end* сравнение строки завершается на указанной позиции.951952#### `str.strip([chars])`953954Возвращает копию строки с удалёнными ведущими и завершающими символами. Аргумент *chars* – строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:955956```python957>>> '   spacious   '.strip()958'spacious'959>>> 'www.example.com'.strip('cmowz.')960'example'961```962963#### `str.swapcase()`964965Возвращает копию строки, в которой символы верхнего регистра преобразованы в нижний и наоборот. Обратите внимание, что `s.swapcase().swapcase() == s` не обязательно равно.966967#### `str.title()`968969Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.970971Например:972973```python974>>> 'Hello world'.title()975'Hello World'976```977978Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:979980```python981>>> "they're bill's friends from the UK".title()982"They'Re Bill'S Friends From The Uk"983```984985Обходной путь для апострофов можно построить с помощью регулярных выражений:986987```python988>>> import re989>>> def titlecase(s):990...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",991...                   lambda mo: mo.group(0)[0].upper() +992...                              mo.group(0)[1:].lower(),993...                   s)994...995>>> titlecase("they're bill's friends.")996"They're Bill's Friends."997```998999#### `str.translate(table)`10001001Возвращает копию строки, в которой каждый символ преобразован с помощью заданной таблицы трансляции. Таблица должна быть объектом, поддерживающим индексацию через [`__getitem__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__getitem__), обычно это [*отображение*](https://python-all.ru/3.4/glossary.html#term-mapping) или [*последовательность*](https://python-all.ru/3.4/glossary.html#term-sequence). При индексации по коду Unicode (целое число) объект таблицы может делать следующее: возвращать код Unicode или строку для отображения символа в один или несколько других символов; возвращать `None` для удаления символа из результирующей строки; или возбуждать исключение [`LookupError`](https://python-all.ru/3.4/library/exceptions.html#LookupError), чтобы отобразить символ на самого себя.10021003Для создания таблицы трансляции из символьных отображений в разных форматах можно использовать [`str.maketrans()`](https://python-all.ru/3.4/library/stdtypes.html#str.maketrans).10041005См. также модуль [`codecs`](https://python-all.ru/3.4/library/codecs.html#module-codecs) для более гибкого подхода к пользовательским символьным отображениям.10061007#### `str.upper()`10081009Возвращает копию строки, в которой все символы [\[4\]](https://python-all.ru/3.4/library/stdtypes.html#id14), имеющие регистр, преобразованы в верхний регистр. Обратите внимание, что `str.upper().isupper()` может быть `False`, если `s` содержит символы без регистра или если категория Unicode результирующего символа не “Lu” (буква, верхний регистр), а, например, “Lt” (буква, заглавная).10101011Алгоритм перевода в верхний регистр описан в разделе 3.13 стандарта Unicode.10121013#### `str.zfill(width)`10141015Возвращает копию строки, дополненную слева цифрами `'0'` ASCII, чтобы получить строку длины *width*. Ведущий знак (`'+'`/`'-'`) обрабатывается вставкой заполнителя *после* знака, а не перед ним. Исходная строка возвращается, если *width* меньше или равно `len(s)`.10161017Например:10181019```python1020>>> "42".zfill(5)1021'00042'1022>>> "-42".zfill(5)1023'-0042'1024```10251026### 4.7.2. Форматирование строк в стиле `printf`10271028> **Примечание**1029>1030> Описанные здесь операции форматирования имеют ряд особенностей, которые приводят к распространённым ошибкам (например, некорректному отображению кортежей и словарей). Использование нового интерфейса [`str.format()`](https://python-all.ru/3.4/library/stdtypes.html#str.format) помогает избежать этих ошибок, а также предоставляет в целом более мощный, гибкий и расширяемый подход к форматированию текста.10311032У строковых объектов есть одна уникальная встроенная операция: оператор `%` (модуль). Он также известен как оператор форматирования *formatting* или интерполяции *interpolation* строк. Для `format % values` (где *format* – строка) спецификации преобразования `%` в *format* заменяются на ноль или более элементов из *values*. Результат аналогичен использованию `sprintf()` в языке C.10331034Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [\[5\]](https://python-all.ru/3.4/library/stdtypes.html#id15) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).10351036Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:103710381. Символ `'%'`, обозначающий начало спецификатора.10392. Ключ отображения (необязательно), состоящий из последовательности символов в скобках (например, `(somename)`).10403. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.10414. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.10425. Точность (необязательно), задаётся как `'.'` (точка), после которой следует значение точности. Если указана как `'*'` (звёздочка), фактическая точность берётся из следующего элемента кортежа в *values*, и преобразуемое значение следует после точности.10436. Модификатор длины (необязательно).10447. Тип преобразования.10451046Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:10471048```python1049>>> print('%(language)s has %(number)03d quote types.' %1050...       {'language': "Python", "number": 2})1051Python has 002 quote types.1052```10531054В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).10551056Символы флагов преобразования:10571058| Флаг | Значение |1059| --- | --- |1060| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |1061| `'0'` | Для числовых значений преобразование будет дополняться нулями. |1062| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |1063| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |1064| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |10651066Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, так как не нужен для Python – например, `%ld` идентично `%d`.10671068Типы преобразования:10691070| Преобразование | Значение | Примечания |1071| --- | --- | --- |1072| `'d'` | Десятичное целое со знаком. |  |1073| `'i'` | Десятичное целое со знаком. |  |1074| `'o'` | Восьмеричное значение со знаком. | (1) |1075| `'u'` | Устаревший тип – он идентичен `'d'`. | (7) |1076| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |1077| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |1078| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |1079| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |1080| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |1081| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |1082| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1083| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |1084| `'c'` | Один символ (принимает целое число или строку из одного символа). |  |1085| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.4/library/functions.html#repr)). | (5) |1086| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.4/library/stdtypes.html#str)). | (5) |1087| `'a'` | Строка (преобразует любой объект Python с помощью [`ascii()`](https://python-all.ru/3.4/library/functions.html#ascii)). | (5) |1088| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |10891090Примечания:109110921. Альтернативная форма приводит к вставке ведущего нуля (`'0'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.10932. Альтернативная форма приводит к вставке ведущего `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.10943. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.10951096   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.10974. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.10981099   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.11005. Если точность равна `N`, вывод обрезается до `N` символов.110111027. См. [**PEP 237**](https://python-all.ru/3.4/library/stdtypes.html).11031104Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.11051106Изменено в версии 3.1: преобразования `%f` для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.11071108## 4.8. Типы двоичных последовательностей – [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes), [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray), [`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview)11091110Основные встроенные типы для работы с двоичными данными – это [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray). Они поддерживаются [`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview), который использует [*буферный протокол*](https://python-all.ru/3.4/c-api/buffer.html#bufferobjects) для доступа к памяти других двоичных объектов без необходимости создавать копию.11111112Модуль [`array`](https://python-all.ru/3.4/library/array.html#module-array) поддерживает эффективное хранение базовых типов данных, таких как 32-битные целые числа и числа с плавающей запятой двойной точности IEEE754.11131114### 4.8.1. Байты11151116Объекты bytes – это неизменяемые последовательности отдельных байтов. Поскольку многие основные бинарные протоколы основаны на текстовой кодировке ASCII, объекты bytes предоставляют несколько методов, которые действительны только при работе с данными, совместимыми с ASCII, и тесно связаны со строковыми объектами во многих других отношениях.11171118Во-первых, синтаксис литералов bytes в основном такой же, как для строковых литералов, за исключением того, что добавляется префикс `b`:11191120- Одинарные кавычки: `b'still allows embedded "double" quotes'`1121- Двойные кавычки: `b"still allows embedded 'single' quotes"`.1122- Тройные кавычки: `b'''3 single quotes'''`, `b"""3 double quotes"""`11231124В литералах bytes допускаются только символы ASCII (независимо от объявленной кодировки исходного кода). Любые двоичные значения больше 127 должны вводиться в литералы bytes с помощью соответствующей управляющей последовательности.11251126Как и строковые литералы, литералы bytes также могут использовать префикс `r` для отключения обработки escape-последовательностей. См. [*Строковые и байтовые литералы*](https://python-all.ru/3.4/reference/lexical_analysis.html#strings) для получения дополнительной информации о различных формах литерала bytes, включая поддерживаемые escape-последовательности.11271128Хотя литералы bytes и их представления основаны на тексте ASCII, объекты bytes на самом деле ведут себя как неизменяемые последовательности целых чисел, где каждое значение в последовательности ограничено так, что `0 <= x < 256` (попытки нарушить это ограничение вызовут [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError)). Это сделано намеренно, чтобы подчеркнуть, что хотя многие двоичные форматы включают элементы на основе ASCII и могут быть полезно обработаны некоторыми текстовыми алгоритмами, в общем случае это не так для произвольных двоичных данных (слепое применение алгоритмов обработки текста к двоичным форматам, несовместимым с ASCII, обычно приводит к повреждению данных).11291130Помимо литералов, объекты bytes могут быть созданы несколькими другими способами:11311132- Объект bytes, заполненный нулями заданной длины: `bytes(10)`1133- Из итерируемого объекта целых чисел: `bytes(range(20))`1134- Копирование существующих двоичных данных через буферный протокол: `bytes(obj)`11351136См. также встроенную функцию [*bytes*](https://python-all.ru/3.4/library/functions.html#func-bytes).11371138Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа являются широко используемым форматом для описания двоичных данных. Соответственно, тип bytes имеет дополнительный метод класса для чтения данных в этом формате:11391140#### `classmethod bytes.fromhex(string)`11411142Этот метод класса [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) возвращает объект bytes, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробелы ASCII игнорируются.11431144```python1145>>> bytes.fromhex('2Ef0 F1f2  ')1146b'.\xf0\xf1\xf2'1147```11481149Поскольку объекты bytes являются последовательностями целых чисел (похоже на кортеж), для объекта bytes *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytes длины 1. (Это отличается от текстовых строк, где и индексация, и срез дают строку длины 1.)11501151Представление объектов bytes использует формат литерала (`b'...'`), поскольку это часто полезнее, чем, например, `bytes([46, 46, 46])`. Всегда можно преобразовать объект bytes в список целых чисел с помощью `list(b)`.11521153> **Примечание**1154>1155> Для пользователей Python 2.x: В серии Python 2.x допускался ряд неявных преобразований между 8-битными строками (ближайший аналог встроенного двоичного типа данных в 2.x) и строками Unicode. Это был обходной путь для обратной совместимости, учитывающий тот факт, что Python изначально поддерживал только 8-битный текст, а текст Unicode был добавлен позже. В Python 3.x эти неявные преобразования устранены – преобразования между 8-битными двоичными данными и текстом Unicode должны быть явными, а объекты bytes и string всегда сравниваются как неравные.11561157### 4.8.2. Объекты bytearray11581159Объекты [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray) являются изменяемым аналогом объектов [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes). Для объектов bytearray нет специального синтаксиса литералов, вместо этого они всегда создаются вызовом конструктора:11601161- Создание пустого экземпляра: `bytearray()`1162- Создание экземпляра, заполненного нулями заданной длины: `bytearray(10)`1163- Из итерируемого объекта целых чисел: `bytearray(range(20))`1164- Копирование существующих двоичных данных через буферный протокол: `bytearray(b'Hi!')`11651166Поскольку объекты bytearray являются изменяемыми, они поддерживают [*изменяемые*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-mutable) операции последовательности в дополнение к общим операциям bytes и bytearray, описанным в [*Операции с bytes и bytearray*](https://python-all.ru/3.4/library/stdtypes.html#bytes-methods).11671168См. также встроенную функцию [*bytearray*](https://python-all.ru/3.4/library/functions.html#func-bytearray).11691170Поскольку две шестнадцатеричные цифры соответствуют ровно одному байту, шестнадцатеричные числа часто используются для описания двоичных данных. Соответственно, тип bytearray имеет дополнительный метод класса для чтения данных в этом формате:11711172#### `classmethod bytearray.fromhex(string)`11731174Этот метод класса [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray) возвращает объект bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, при этом пробелы ASCII игнорируются.11751176```python1177>>> bytearray.fromhex('2Ef0 F1f2  ')1178bytearray(b'.\xf0\xf1\xf2')1179```11801181Поскольку объекты bytearray являются последовательностями целых чисел (похоже на список), для объекта bytearray *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytearray длины 1. (Это отличается от текстовых строк, где и индексация, и срез дают строку длины 1.)11821183Представление объектов bytearray использует формат литерала bytes (`bytearray(b'...')`), поскольку это часто полезнее, чем, например, `bytearray([46, 46, 46])`. Всегда можно преобразовать объект bytearray в список целых чисел с помощью `list(b)`.11841185### 4.8.3. Операции с bytes и bytearray11861187Объекты bytes и bytearray поддерживают [*общие*](https://python-all.ru/3.4/library/stdtypes.html#typesseq-common) операции последовательности. Они взаимодействуют не только с операндами того же типа, но и с любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object). Благодаря такой гибкости их можно свободно смешивать в операциях, не вызывая ошибок. Однако тип возвращаемого результата может зависеть от порядка операндов.11881189> **Примечание**1190>1191> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать:1192>1193> ```python1194> a = "abc"1195> b = a.replace("a", "f")1196> ```1197>1198> и:1199>1200> ```python1201> a = b"abc"1202> b = a.replace(b"a", b"f")1203> ```12041205Некоторые операции с bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и поэтому их следует избегать при работе с произвольными двоичными данными. Эти ограничения описаны ниже.12061207> **Примечание**1208>1209> Использование этих операций на основе ASCII для манипуляции двоичными данными, которые не хранятся в формате на основе ASCII, может привести к повреждению данных.12101211Следующие методы объектов bytes и bytearray могут использоваться с произвольными двоичными данными.12121213#### `bytes.count(sub[, start[, end]])`12141215#### `bytearray.count(sub[, start[, end]])`12161217Возвращает количество непересекающихся вхождений подпоследовательности *sub* в диапазоне \[*start*, *end*\]. Необязательные аргументы *start* и *end* интерпретируются как в нотации среза.12181219Подпоследовательность для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.12201221Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.12221223#### `bytes.decode(encoding="utf-8", errors="strict")`12241225#### `bytearray.decode(encoding="utf-8", errors="strict")`12261227Возвращает строку, декодированную из заданных байтов. Кодировка по умолчанию – `'utf-8'`. Параметр *errors* может быть задан для выбора другой схемы обработки ошибок. Значение по умолчанию для *errors* – `'strict'`, то есть ошибки кодирования вызывают [`UnicodeError`](https://python-all.ru/3.4/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.4/library/codecs.html#codecs.register_error); см. раздел [*Обработчики ошибок*](https://python-all.ru/3.4/library/codecs.html#error-handlers). Список возможных кодировок см. в разделе [*Стандартные кодировки*](https://python-all.ru/3.4/library/codecs.html#standard-encodings).12281229> **Примечание**1230>1231> Передача аргумента *encoding* в [`str`](https://python-all.ru/3.4/library/stdtypes.html#str) позволяет декодировать любой [*байтоподобный объект*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) напрямую, без необходимости создавать временный объект bytes или bytearray.12321233Изменено в версии 3.1: Добавлена поддержка именованных аргументов.12341235#### `bytes.endswith(suffix[, start[, end]])`12361237#### `bytearray.endswith(suffix[, start[, end]])`12381239Возвращает `True`, если двоичные данные оканчиваются указанным *suffix*, иначе возвращает `False`. *suffix* может также быть кортежем суффиксов для поиска. При наличии необязательного *start* проверка начинается с этой позиции. При наличии необязательного *end* сравнение прекращается на этой позиции.12401241Искомый суффикс (или суффиксы) может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).12421243#### `bytes.find(sub[, start[, end]])`12441245#### `bytearray.find(sub[, start[, end]])`12461247Возвращает наименьший индекс в данных, где встречается подпоследовательность *sub*, такой, что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.12481249Подпоследовательность для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.12501251> **Примечание**1252>1253> Метод [`find()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.find) следует использовать только если нужно узнать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.4/reference/expressions.html#in):1254>1255> ```python1256> >>> b'Py' in b'Python'1257> True1258> ```12591260Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.12611262#### `bytes.index(sub[, start[, end]])`12631264#### `bytearray.index(sub[, start[, end]])`12651266Как и [`find()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.find), но вызывает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), если подпоследовательность не найдена.12671268Подпоследовательность для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.12691270Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.12711272#### `bytes.join(iterable)`12731274#### `bytearray.join(iterable)`12751276Возвращает объект bytes или bytearray, который является конкатенацией последовательностей двоичных данных из [*iterable*](https://python-all.ru/3.4/glossary.html#term-iterable) *iterable*. Будет вызвано [`TypeError`](https://python-all.ru/3.4/library/exceptions.html#TypeError), если в *iterable* есть значения, не являющиеся [*байтоподобными объектами*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object), включая объекты [`str`](https://python-all.ru/3.4/library/stdtypes.html#str). Разделителем между элементами служит содержимое объекта bytes или bytearray, предоставляющего этот метод.12771278#### `static bytes.maketrans(from, to)`12791280#### `static bytearray.maketrans(from, to)`12811282Этот статический метод возвращает таблицу перекодировки, пригодную для [`bytes.translate()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* оба должны быть [*байтоподобными объектами*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) и иметь одинаковую длину.12831284Новое в версии 3.1.12851286#### `bytes.partition(sep)`12871288#### `bytearray.partition(sep)`12891290Разделяет последовательность по первому вхождению *sep* и возвращает кортеж из трёх элементов, содержащий часть до разделителя, разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий копию исходной последовательности, за которой следуют два пустых объекта bytes или bytearray.12911292Разделитель для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).12931294#### `bytes.replace(old, new[, count])`12951296#### `bytearray.replace(old, new[, count])`12971298Возвращает копию последовательности, в которой все вхождения подпоследовательности *old* заменены на *new*. Если задан необязательный аргумент *count*, заменяются только первые *count* вхождений.12991300Искомая подпоследовательность и её замена могут быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).13011302> **Примечание**1303>1304> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.13051306#### `bytes.rfind(sub[, start[, end]])`13071308#### `bytearray.rfind(sub[, start[, end]])`13091310Возвращает наибольший индекс в последовательности, где встречается подпоследовательность *sub*, такой, что *sub* содержится в `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1` в случае неудачи.13111312Подпоследовательность для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.13131314Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.13151316#### `bytes.rindex(sub[, start[, end]])`13171318#### `bytearray.rindex(sub[, start[, end]])`13191320Как и [`rfind()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.rfind), но вызывает [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError), если подпоследовательность *sub* не найдена.13211322Подпоследовательность для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object) или целым числом от 0 до 255.13231324Изменено в версии 3.3: Теперь также принимает целое число от 0 до 255 в качестве подпоследовательности.13251326#### `bytes.rpartition(sep)`13271328#### `bytearray.rpartition(sep)`13291330Разделяет последовательность по последнему вхождению *sep* и возвращает кортеж из трёх элементов, содержащий часть до разделителя, разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий копию исходной последовательности, за которой следуют два пустых объекта bytes или bytearray.13311332Разделитель для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).13331334#### `bytes.startswith(prefix[, start[, end]])`13351336#### `bytearray.startswith(prefix[, start[, end]])`13371338Возвращает `True`, если двоичные данные начинаются с указанного *prefix*, иначе возвращает `False`. *prefix* может также быть кортежем префиксов для поиска. При наличии необязательного *start* проверка начинается с этой позиции. При наличии необязательного *end* сравнение прекращается на этой позиции.13391340Префикс(ы) для поиска может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).13411342#### `bytes.translate(table[, delete])`13431344#### `bytearray.translate(table[, delete])`13451346Возвращает копию объекта bytes или bytearray, из которой удалены все байты, встречающиеся в необязательном аргументе *delete*, а оставшиеся байты преобразованы через заданную таблицу перекодировки, которая должна быть объектом bytes длиной 256.13471348Для создания таблицы перекодировки можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.maketrans).13491350Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:13511352```python1353>>> b'read this short text'.translate(None, b'aeiou')1354b'rd ths shrt txt'1355```13561357Следующие методы объектов bytes и bytearray имеют поведение по умолчанию, предполагающее использование бинарных форматов, совместимых с ASCII, но их можно использовать с произвольными двоичными данными, передав соответствующие аргументы. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а вместо этого создают новые объекты.13581359#### `bytes.center(width[, fillbyte])`13601361#### `bytearray.center(width[, fillbyte])`13621363Возвращает копию объекта, выровненного по центру в последовательности длины *width*. Заполнение выполняется указанным *fillbyte* (по умолчанию – ASCII-пробел). Для объектов [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.13641365> **Примечание**1366>1367> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.13681369#### `bytes.ljust(width[, fillbyte])`13701371#### `bytearray.ljust(width[, fillbyte])`13721373Возвращает копию объекта, выровненного по левому краю в последовательности длины *width*. Заполнение выполняется указанным *fillbyte* (по умолчанию – ASCII-пробел). Для объектов [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.13741375> **Примечание**1376>1377> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.13781379#### `bytes.lstrip([chars])`13801381#### `bytearray.lstrip([chars])`13821383Return a copy of the sequence with specified leading bytes removed. The *chars* argument is a binary sequence specifying the set of byte values to be removed - the name refers to the fact this method is usually used with ASCII characters. If omitted or `None`, the *chars* argument defaults to removing ASCII whitespace. The *chars* argument is not a prefix; rather, all combinations of its values are stripped:13841385```python1386>>> b'   spacious   '.lstrip()1387b'spacious   '1388>>> b'www.example.com'.lstrip(b'cmowz.')1389b'example.com'1390```13911392Двоичная последовательность удаляемых байтов может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).13931394> **Примечание**1395>1396> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.13971398#### `bytes.rjust(width[, fillbyte])`13991400#### `bytearray.rjust(width[, fillbyte])`14011402Возвращает копию объекта, выровненного по правому краю в последовательности длины *width*. Заполнение выполняется указанным *fillbyte* (по умолчанию – ASCII-пробел). Для объектов [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(s)`.14031404> **Примечание**1405>1406> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.14071408#### `bytes.rsplit(sep=None, maxsplit=-1)`14091410#### `bytearray.rsplit(sep=None, maxsplit=-1)`14111412Разделяет бинарную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений, а именно *самых правых*. Если *sep* не указан или равен `None`, любая подпоследовательность, состоящая только из пробельных символов ASCII, считается разделителем. За исключением разбиения справа, [`rsplit()`](https://python-all.ru/3.4/library/stdtypes.html#bytearray.rsplit) ведёт себя как [`split()`](https://python-all.ru/3.4/library/stdtypes.html#bytearray.split), который подробно описан ниже.14131414#### `bytes.rstrip([chars])`14151416#### `bytearray.rstrip([chars])`14171418Return a copy of the sequence with specified trailing bytes removed. The *chars* argument is a binary sequence specifying the set of byte values to be removed - the name refers to the fact this method is usually used with ASCII characters. If omitted or `None`, the *chars* argument defaults to removing ASCII whitespace. The *chars* argument is not a suffix; rather, all combinations of its values are stripped:14191420```python1421>>> b'   spacious   '.rstrip()1422b'   spacious'1423>>> b'mississippi'.rstrip(b'ipz')1424b'mississ'1425```14261427Двоичная последовательность удаляемых байтов может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).14281429> **Примечание**1430>1431> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.14321433#### `bytes.split(sep=None, maxsplit=-1)`14341435#### `bytearray.split(sep=None, maxsplit=-1)`14361437Разделяет бинарную последовательность на подпоследовательности того же типа, используя *sep* в качестве строки-разделителя. Если указан *maxsplit* и он неотрицателен, выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан или равен `-1`, то количество разбиений не ограничено (выполняются все возможные разбиения).14381439Если указан *sep*, последовательные разделители не группируются и считаются разделяющими пустые подпоследовательности (например, `b'1,,2'.split(b',')` возвращает `[b'1', b'', b'2']`). Аргумент *sep* может состоять из многобайтовой последовательности (например, `b'1<>2<>3'.split(b'<>')` возвращает `[b'1', b'2', b'3']`). Разбиение пустой последовательности с указанным разделителем возвращает `[b'']` или `[bytearray(b'')]` в зависимости от типа разбиваемого объекта. Аргумент *sep* может быть любым [*bytes-подобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).14401441Например:14421443```python1444>>> b'1,2,3'.split(b',')1445[b'1', b'2', b'3']1446>>> b'1,2,3'.split(b',', maxsplit=1)1447[b'1', b'2,3']1448>>> b'1,2,,3,'.split(b',')1449[b'1', b'2', b'', b'3', b'']1450```14511452Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности подряд идущих пробельных символов ASCII считаются одним разделителем, и результат не будет содержать пустых строк в начале или конце, если последовательность содержит начальные или конечные пробелы. Следовательно, разбиение пустой последовательности или последовательности, состоящей только из пробельных символов ASCII, без указания разделителя возвращает `[]`.14531454Например:14551456```python1457>>> b'1 2 3'.split()1458[b'1', b'2', b'3']1459>>> b'1 2 3'.split(maxsplit=1)1460[b'1', b'2 3']1461>>> b'   1   2   3   '.split()1462[b'1', b'2', b'3']1463```14641465#### `bytes.strip([chars])`14661467#### `bytearray.strip([chars])`14681469Возвращает копию последовательности с удалёнными указанными начальными и конечными байтами. Аргумент *chars* – это бинарная последовательность, задающая набор байтовых значений, которые будут удалены. Название связано с тем, что этот метод обычно используется с символами ASCII. Если опущен или равен `None`, то аргумент *chars* по умолчанию удаляет пробельные символы ASCII. Аргумент *chars* не является префиксом или суффиксом; напротив, удаляются все комбинации его значений:14701471```python1472>>> b'   spacious   '.strip()1473b'spacious'1474>>> b'www.example.com'.strip(b'cmowz.')1475b'example'1476```14771478Двоичная последовательность удаляемых байтов может быть любым [*байтоподобным объектом*](https://python-all.ru/3.4/glossary.html#term-bytes-like-object).14791480> **Примечание**1481>1482> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если никаких изменений не было.14831484Следующие методы для объектов bytes и bytearray предполагают использование двоичных форматов, совместимых с ASCII, и не должны применяться к произвольным двоичным данным. Обратите внимание, что все методы bytearray в этом разделе *не* работают на месте, а создают новые объекты.14851486#### `bytes.capitalize()`14871488#### `bytearray.capitalize()`14891490Возвращает копию последовательности, где каждый байт интерпретируется как символ ASCII, первый байт преобразуется в верхний регистр, а остальные – в нижний. Не-ASCII байты передаются без изменений.14911492> **Примечание**1493>1494> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.14951496#### `bytes.expandtabs(tabsize=8)`14971498#### `bytearray.expandtabs(tabsize=8)`14991500Возвращает копию последовательности, в которой все символы табуляции ASCII заменены на один или несколько пробелов ASCII в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции располагаются через каждые *tabsize* байт (по умолчанию 8, что даёт позиции табуляции на колонках 0, 8, 16 и так далее). Для разворачивания последовательности текущая колонка устанавливается в ноль, и последовательность просматривается побайтово. Если байт является символом табуляции ASCII (`b'\t'`), в результат вставляется один или несколько пробелов до тех пор, пока текущая колонка не сравняется со следующей позицией табуляции (сам символ табуляции не копируется). Если текущий байт – символ новой строки ASCII (`b'\n'`) или возврата каретки (`b'\r'`), он копируется, а текущая колонка сбрасывается в ноль. Любое другое байтовое значение копируется без изменений, и текущая колонка увеличивается на единицу независимо от того, как это значение представлено при печати:15011502```python1503>>> b'01\t012\t0123\t01234'.expandtabs()1504b'01      012     0123    01234'1505>>> b'01\t012\t0123\t01234'.expandtabs(4)1506b'01  012 0123    01234'1507```15081509> **Примечание**1510>1511> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.15121513#### `bytes.isalnum()`15141515#### `bytearray.isalnum()`15161517Возвращает True, если все байты в последовательности являются буквенными символами ASCII или десятичными цифрами ASCII и последовательность не пуста, и False в противном случае. Буквенные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Десятичные цифры ASCII – это байтовые значения из последовательности `b'0123456789'`.15181519Например:15201521```python1522>>> b'ABCabc1'.isalnum()1523True1524>>> b'ABC abc1'.isalnum()1525False1526```15271528#### `bytes.isalpha()`15291530#### `bytearray.isalpha()`15311532Возвращает True, если все байты в последовательности являются буквенными символами ASCII и последовательность не пуста, и False в противном случае. Буквенные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'`.15331534Например:15351536```python1537>>> b'ABCabc'.isalpha()1538True1539>>> b'ABCabc1'.isalpha()1540False1541```15421543#### `bytes.isdigit()`15441545#### `bytearray.isdigit()`15461547Возвращает True, если все байты в последовательности являются десятичными цифрами ASCII и последовательность не пуста, и False в противном случае. Десятичные цифры ASCII – это байтовые значения из последовательности `b'0123456789'`.15481549Например:15501551```python1552>>> b'1234'.isdigit()1553True1554>>> b'1.23'.isdigit()1555False1556```15571558#### `bytes.islower()`15591560#### `bytearray.islower()`15611562Возвращает true, если в последовательности есть хотя бы один строчный ASCII-символ и нет ни одного прописного ASCII-символа, иначе false.15631564Например:15651566```python1567>>> b'hello world'.islower()1568True1569>>> b'Hello world'.islower()1570False1571```15721573Строчные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные символы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.15741575#### `bytes.isspace()`15761577#### `bytearray.isspace()`15781579Возвращает True, если все байты в последовательности являются пробельными символами ASCII и последовательность не пуста, и False в противном случае. Пробельные символы ASCII – это байтовые значения из последовательности `b' \t\n\r\x0b\f'` (пробел, табуляция, перевод строки, возврат каретки, вертикальная табуляция, перевод страницы).15801581#### `bytes.istitle()`15821583#### `bytearray.istitle()`15841585Возвращает True, если последовательность находится в регистре заголовка ASCII и не пуста, и False в противном случае. Подробнее об определении «регистр заголовка» см. [`bytes.title()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.title).15861587Например:15881589```python1590>>> b'Hello World'.istitle()1591True1592>>> b'Hello world'.istitle()1593False1594```15951596#### `bytes.isupper()`15971598#### `bytearray.isupper()`15991600Возвращает true, если в последовательности есть хотя бы один прописной буквенный ASCII-символ и нет ни одного строчного ASCII-символа, иначе false.16011602Например:16031604```python1605>>> b'HELLO WORLD'.isupper()1606True1607>>> b'Hello world'.isupper()1608False1609```16101611Строчные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные символы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.16121613#### `bytes.lower()`16141615#### `bytearray.lower()`16161617Возвращает копию последовательности, в которой все символы ASCII в верхнем регистре преобразованы в соответствующие символы нижнего регистра.16181619Например:16201621```python1622>>> b'Hello World'.lower()1623b'hello world'1624```16251626Строчные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные символы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.16271628> **Примечание**1629>1630> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.16311632#### `bytes.splitlines(keepends=False)`16331634#### `bytearray.splitlines(keepends=False)`16351636Возвращает список строк в двоичной последовательности, разбивая по границам строк ASCII. Этот метод использует подход [*универсального перевода строк*](https://python-all.ru/3.4/glossary.html#term-universal-newlines) для разделения строк. Разрывы строк не включаются в итоговый список, если только *keepends* не задано и не равно true.16371638Например:16391640```python1641>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()1642[b'ab c', b'', b'de fg', b'kl']1643>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)1644[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']1645```16461647В отличие от [`split()`](https://python-all.ru/3.4/library/stdtypes.html#bytes.split), когда задана строка-разделитель *sep*, этот метод возвращает пустой список для пустой строки, и завершающий разрыв строки не приводит к появлению дополнительной строки:16481649```python1650>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')1651([b''], [b'Two lines', b''])1652>>> b"".splitlines(), b"One line\n".splitlines()1653([], [b'One line'])1654```16551656#### `bytes.swapcase()`16571658#### `bytearray.swapcase()`16591660Возвращает копию последовательности, в которой все символы ASCII в нижнем регистре преобразованы в соответствующие символы верхнего регистра и наоборот.16611662Например:16631664```python1665>>> b'Hello World'.swapcase()1666b'hELLO wORLD'1667```16681669Строчные символы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные символы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.16701671В отличие от [`str.swapcase()`](https://python-all.ru/3.4/library/stdtypes.html#str.swapcase), для двоичных версий всегда выполняется `bin.swapcase().swapcase() == bin`. Преобразования регистра в ASCII симметричны, хотя это в общем случае неверно для произвольных кодовых точек Unicode.16721673> **Примечание**1674>1675> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.16761677#### `bytes.title()`16781679#### `bytearray.title()`16801681Возвращает версию двоичной последовательности, в которой каждое слово начинается с заглавной буквы ASCII, а остальные символы – строчные. Байтовые значения без регистра остаются без изменений.16821683Например:16841685```python1686>>> b'Hello world'.title()1687b'Hello World'1688```16891690Строчные буквы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные буквы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`. Все остальные байтовые значения не имеют регистра.16911692Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:16931694```python1695>>> b"they're bill's friends from the UK".title()1696b"They'Re Bill'S Friends From The Uk"1697```16981699Обходной путь для апострофов можно построить с помощью регулярных выражений:17001701```python1702>>> import re1703>>> def titlecase(s):1704...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",1705...                   lambda mo: mo.group(0)[0:1].upper() +1706...                              mo.group(0)[1:].lower(),1707...                   s)1708...1709>>> titlecase(b"they're bill's friends.")1710b"They're Bill's Friends."1711```17121713> **Примечание**1714>1715> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.17161717#### `bytes.upper()`17181719#### `bytearray.upper()`17201721Возвращает копию последовательности, в которой все строчные ASCII-символы преобразованы в соответствующие заглавные.17221723Например:17241725```python1726>>> b'Hello World'.upper()1727b'HELLO WORLD'1728```17291730Строчные буквы ASCII – это байтовые значения из последовательности `b'abcdefghijklmnopqrstuvwxyz'`. Заглавные буквы ASCII – это байтовые значения из последовательности `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`.17311732> **Примечание**1733>1734> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.17351736#### `bytes.zfill(width)`17371738#### `bytearray.zfill(width)`17391740Возвращает копию последовательности, дополненную слева цифрами ASCII `b'0'`, чтобы получить последовательность длины *width*. Начальный знак (`b'+'`/ `b'-'`) обрабатывается вставкой заполнения *после* знака, а не перед ним. Для объектов [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) исходная последовательность возвращается, если *width* меньше или равно `len(seq)`.17411742Например:17431744```python1745>>> b"42".zfill(5)1746b'00042'1747>>> b"-42".zfill(5)1748b'-0042'1749```17501751> **Примечание**1752>1753> Версия этого метода для bytearray *не* работает на месте – она всегда создаёт новый объект, даже если изменения не вносились.17541755### 4.8.4. Представления памяти17561757Объекты [`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [*протокол буфера*](https://python-all.ru/3.4/c-api/buffer.html#bufferobjects), без копирования.17581759#### `class memoryview(obj)`17601761Создаёт [`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview), ссылающийся на *obj*. *obj* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray).17621763[`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview) имеет понятие *элемента* – атомарной единицы памяти, с которой работает исходный объект *obj*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray), элемент представляет собой один байт, но другие типы, такие как [`array.array`](https://python-all.ru/3.4/library/array.html#array.array), могут иметь элементы большего размера.17641765`len(view)` равно длине [`tolist`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.tolist). Если `view.ndim = 0`, длина равна 1. Если `view.ndim = 1`, длина равна количеству элементов в представлении. Для более высоких размерностей длина равна длине вложенного спискового представления представления. Атрибут [`itemsize`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.itemsize) даёт количество байт в одном элементе.17661767[`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview) поддерживает срезы для доступа к своим данным. Если [`format`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.format) является одним из собственных спецификаторов формата из модуля [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct), то индексирование вернёт один элемент правильного типа. Полный срез вернёт подпредставление:17681769```python1770>>> v = memoryview(b'abcefg')1771>>> v[1]1772981773>>> v[-1]17741031775>>> v[1:4]1776<memory at 0x7f3ddc9f4350>1777>>> bytes(v[1:4])1778b'bce'1779```17801781Другие собственные форматы:17821783```python1784>>> import array1785>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])1786>>> a[0]1787-111111111788>>> a[-1]1789444444441790>>> a[2:3].tolist()1791[-33333333]1792>>> a[::2].tolist()1793[-11111111, -33333333]1794>>> a[::-1].tolist()1795[44444444, -33333333, 22222222, -11111111]1796```17971798Новое в версии 3.3.17991800Если базовый объект допускает запись, memoryview поддерживает присваивание срезу. Изменение размера не разрешено:18011802```python1803>>> data = bytearray(b'abcefg')1804>>> v = memoryview(data)1805>>> v.readonly1806False1807>>> v[0] = ord(b'z')1808>>> data1809bytearray(b'zbcefg')1810>>> v[1:4] = b'123'1811>>> data1812bytearray(b'z123fg')1813>>> v[2:3] = b'spam'1814Traceback (most recent call last):1815  File "<stdin>", line 1, in <module>1816ValueError: memoryview assignment: lvalue and rvalue have different structures1817>>> v[2:6] = b'spam'1818>>> data1819bytearray(b'z1spam')1820```18211822Одномерные представления памяти хешируемых (только для чтения) типов с форматами 'B', 'b' или 'c' также являются хешируемыми. Хеш определяется как `hash(m) == hash(m.tobytes())`:18231824```python1825>>> v = memoryview(b'abcefg')1826>>> hash(v) == hash(b'abcefg')1827True1828>>> hash(v[2:4]) == hash(b'ce')1829True1830>>> hash(v[::-2]) == hash(b'abcefg'[::-2])1831True1832```18331834Изменено в версии 3.3: Одномерные представления памяти с форматами 'B', 'b' или 'c' теперь являются хешируемыми.18351836Изменено в версии 3.4: memoryview теперь автоматически регистрируется как [`collections.abc.Sequence`](https://python-all.ru/3.4/library/collections.abc.html#collections.abc.Sequence)18371838[`memoryview`](https://python-all.ru/3.4/library/stdtypes.html#memoryview) имеет несколько методов:18391840#### `__eq__(exporter)`18411842Объект memoryview и экспортёр [**PEP 3118**](https://python-all.ru/3.4/library/stdtypes.html) равны, если их формы эквивалентны и все соответствующие значения равны, когда коды формата операндов интерпретируются с использованием синтаксиса [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct).18431844Для подмножества строк формата [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct), поддерживаемых в настоящее время [`tolist()`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.tolist), `v` и `w` равны, если `v.tolist() == w.tolist()`:18451846```python1847>>> import array1848>>> a = array.array('I', [1, 2, 3, 4, 5])1849>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])1850>>> c = array.array('b', [5, 3, 1])1851>>> x = memoryview(a)1852>>> y = memoryview(b)1853>>> x == a == y == b1854True1855>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()1856True1857>>> z = y[::-2]1858>>> z == c1859True1860>>> z.tolist() == c.tolist()1861True1862```18631864Если хотя бы одна из строк формата не поддерживается модулем [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct), то объекты всегда будут считаться неравными (даже если строки формата и содержимое буфера идентичны):18651866```python1867>>> from ctypes import BigEndianStructure, c_long1868>>> class BEPoint(BigEndianStructure):1869...     _fields_ = [("x", c_long), ("y", c_long)]1870...1871>>> point = BEPoint(100, 200)1872>>> a = memoryview(point)1873>>> b = memoryview(point)1874>>> a == point1875False1876>>> a == b1877False1878```18791880Обратите внимание, что, как и в случае с числами с плавающей запятой, для объектов memoryview `v is w` *не* подразумевает `v == w`.18811882Изменено в версии 3.3: В предыдущих версиях сравнивалась необработанная память без учёта формата элемента и логической структуры массива.18831884#### `tobytes()`18851886Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.4/library/functions.html#bytes) для данного представления памяти.18871888```python1889>>> m = memoryview(b"abc")1890>>> m.tobytes()1891b'abc'1892>>> bytes(m)1893b'abc'1894```18951896Для несплошных массивов результат равен сплющенному списковому представлению со всеми элементами, преобразованными в байты. [`tobytes()`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.tobytes) поддерживает все строки формата, включая те, которые не входят в синтаксис модуля [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct).18971898#### `tolist()`18991900Возвращает данные в буфере в виде списка элементов.19011902```python1903>>> memoryview(b'abc').tolist()1904[97, 98, 99]1905>>> import array1906>>> a = array.array('d', [1.1, 2.2, 3.3])1907>>> m = memoryview(a)1908>>> m.tolist()1909[1.1, 2.2, 3.3]1910```19111912Изменено в версии 3.3: [`tolist()`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.tolist) теперь поддерживает все односимвольные собственные форматы в синтаксисе модуля [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct), а также многомерные представления.19131914#### `release()`19151916Освобождает базовый буфер, предоставленный объектом memoryview. Многие объекты выполняют специальные действия, пока на них удерживается представление (например, [`bytearray`](https://python-all.ru/3.4/library/functions.html#bytearray) временно запрещает изменение размера); поэтому вызов release() удобен для снятия этих ограничений (и освобождения любых висящих ресурсов) как можно скорее.19171918После вызова этого метода любая дальнейшая операция над представлением вызывает исключение [`ValueError`](https://python-all.ru/3.4/library/exceptions.html#ValueError) (за исключением самого [`release()`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.release), который можно вызывать многократно):19191920```python1921>>> m = memoryview(b'abc')1922>>> m.release()1923>>> m[0]1924Traceback (most recent call last):1925  File "<stdin>", line 1, in <module>1926ValueError: operation forbidden on released memoryview object1927```19281929Протокол управления контекстом можно использовать для аналогичного эффекта, применяя оператор `with`:19301931```python1932>>> with memoryview(b'abc') as m:1933...     m[0]1934...1935971936>>> m[0]1937Traceback (most recent call last):1938  File "<stdin>", line 1, in <module>1939ValueError: operation forbidden on released memoryview object1940```19411942Новое в версии 3.2.19431944#### `cast(format[, shape])`19451946Преобразует memoryview в новый формат или форму. *shape* по умолчанию равен `[byte_length//new_itemsize]`, что означает, что результирующее представление будет одномерным. Возвращаемое значение – новый memoryview, но сам буфер не копируется. Поддерживаемые преобразования: 1D -\> C-непрерывный и C-непрерывный -\> 1D.19471948Оба формата ограничены одноэлементными нативными форматами в синтаксисе модуля [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct). Один из форматов должен быть байтовым форматом ('B', 'b' или 'c'). Длина результата в байтах должна совпадать с исходной длиной.19491950Преобразование 1D/long в 1D/unsigned bytes:19511952```python1953>>> import array1954>>> a = array.array('l', [1,2,3])1955>>> x = memoryview(a)1956>>> x.format1957'l'1958>>> x.itemsize195981960>>> len(x)196131962>>> x.nbytes1963241964>>> y = x.cast('B')1965>>> y.format1966'B'1967>>> y.itemsize196811969>>> len(y)1970241971>>> y.nbytes1972241973```19741975Преобразование 1D/unsigned bytes в 1D/char:19761977```python1978>>> b = bytearray(b'zyz')1979>>> x = memoryview(b)1980>>> x[0] = b'a'1981Traceback (most recent call last):1982  File "<stdin>", line 1, in <module>1983ValueError: memoryview: invalid value for format "B"1984>>> y = x.cast('c')1985>>> y[0] = b'a'1986>>> b1987bytearray(b'ayz')1988```19891990Преобразование 1D/bytes в 3D/ints в 1D/signed char:19911992```python1993>>> import struct1994>>> buf = struct.pack("i"*12, *list(range(12)))1995>>> x = memoryview(buf)1996>>> y = x.cast('i', shape=[2,2,3])1997>>> y.tolist()1998[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]1999>>> y.format2000'i'2001>>> y.itemsize200242003>>> len(y)200422005>>> y.nbytes2006482007>>> z = y.cast('b')2008>>> z.format2009'b'2010>>> z.itemsize201112012>>> len(z)2013482014>>> z.nbytes2015482016```20172018Преобразовать 1D/unsigned char в 2D/unsigned long:20192020```python2021>>> buf = struct.pack("L"*6, *list(range(6)))2022>>> x = memoryview(buf)2023>>> y = x.cast('L', shape=[2,3])2024>>> len(y)202522026>>> y.nbytes2027482028>>> y.tolist()2029[[0, 1, 2], [3, 4, 5]]2030```20312032Новое в версии 3.3.20332034Также доступно несколько атрибутов только для чтения:20352036#### `obj`20372038Базовый объект memoryview:20392040```python2041>>> b  = bytearray(b'xyz')2042>>> m = memoryview(b)2043>>> m.obj is b2044True2045```20462047Новое в версии 3.3.20482049#### `nbytes`20502051`nbytes == product(shape) * itemsize == len(m.tobytes())`. Это объём в байтах, который массив занял бы в непрерывном представлении. Он не обязательно равен len(m):20522053```python2054>>> import array2055>>> a = array.array('i', [1,2,3,4,5])2056>>> m = memoryview(a)2057>>> len(m)205852059>>> m.nbytes2060202061>>> y = m[::2]2062>>> len(y)206332064>>> y.nbytes2065122066>>> len(y.tobytes())2067122068```20692070Многомерные массивы:20712072```python2073>>> import struct2074>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])2075>>> x = memoryview(buf)2076>>> y = x.cast('d', shape=[3,4])2077>>> y.tolist()2078[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]2079>>> len(y)208032081>>> y.nbytes2082962083```20842085Новое в версии 3.3.20862087#### `readonly`20882089Логическое значение bool, указывающее, доступна ли память только для чтения.20902091#### `format`20922093Строка, содержащая формат (в стиле модуля [`struct`](https://python-all.ru/3.4/library/struct.html#module-struct)) для каждого элемента представления. Memoryview можно создать из экспортёров с произвольными строками формата, но некоторые методы (например, [`tolist()`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.tolist)) ограничены нативными одноэлементными форматами.20942095Изменено в версии 3.3: формат `'B'` теперь обрабатывается в соответствии с синтаксисом модуля struct. Это означает, что `memoryview(b'abc')[0] == b'abc'[0] == 97`.20962097#### `itemsize`20982099Размер в байтах каждого элемента memoryview:21002101```python2102>>> import array, struct2103>>> m = memoryview(array.array('H', [32000, 32001, 32002]))2104>>> m.itemsize210522106>>> m[0]2107320002108>>> struct.calcsize('H') == m.itemsize2109True2110```21112112#### `ndim`21132114Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.21152116#### `shape`21172118Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.ndim), задающий форму памяти в виде N-мерного массива.21192120Изменено в версии 3.3: Пустой кортеж вместо None, когда ndim = 0.21212122#### `strides`21232124Кортеж целых чисел длиной [`ndim`](https://python-all.ru/3.4/library/stdtypes.html#memoryview.ndim), задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.21252126Изменено в версии 3.3: Пустой кортеж вместо None, когда ndim = 0.21272128#### `suboffsets`21292130Используется внутри для массивов в стиле PIL. Значение носит только информационный характер.21312132#### `c_contiguous`21332134Логическое значение, указывающее, является ли память C-непрерывной.21352136Новое в версии 3.3.21372138#### `f_contiguous`21392140Логическое значение, указывающее, является ли память непрерывной по Фортрану.21412142Новое в версии 3.3.21432144#### `contiguous`21452146Логическое значение, указывающее, является ли память непрерывной.21472148Новое в версии 3.3.21492150## 4.9. Типы множеств – [`set`](https://python-all.ru/3.4/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset)21512152Объект *set* – это неупорядоченная коллекция различных [*хэшируемых*](https://python-all.ru/3.4/glossary.html#term-hashable) объектов. Обычно используется для проверки принадлежности, удаления дубликатов из последовательности и выполнения математических операций, таких как пересечение, объединение, разность и симметрическая разность. (Другие контейнеры см. во встроенных классах [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.4/library/stdtypes.html#list) и [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple), а также в модуле [`collections`](https://python-all.ru/3.4/library/collections.html#module-collections).)21532154Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множества не сохраняют позицию элемента или порядок вставки. Соответственно, множества не поддерживают индексацию, срезы или другое поведение, подобное последовательностям.21552156В настоящее время существует два встроенных типа множеств: [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset). Тип [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) является изменяемым – его содержимое можно менять с помощью методов [`add()`](https://python-all.ru/3.4/library/stdtypes.html#set.add) и [`remove()`](https://python-all.ru/3.4/library/stdtypes.html#set.remove). Поскольку он изменяем, у него нет хэш-значения, и он не может использоваться ни как ключ словаря, ни как элемент другого множества. Тип [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset) является неизменяемым и [*хэшируемым*](https://python-all.ru/3.4/glossary.html#term-hashable) – его содержимое нельзя изменить после создания; поэтому он может использоваться как ключ словаря или как элемент другого множества.21572158Непустые множества (не frozenset) можно создать, перечислив элементы через запятую в фигурных скобках, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.4/library/stdtypes.html#set).21592160Конструкторы обоих классов работают одинаково:21612162#### `class set([iterable])`21632164#### `class frozenset([iterable])`21652166Return 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.4/glossary.html#term-hashable). To represent sets of sets, the inner sets must be [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset) objects. If *iterable* is not specified, a new empty set is returned.21672168Instances of [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset) provide the following operations:21692170#### `len(s)`21712172Return the cardinality of set *s*.21732174#### `x in s`21752176Проверяет принадлежность *x* множеству *s*.21772178#### `x not in s`21792180Проверяет отсутствие *x* в множестве *s*.21812182#### `isdisjoint(other)`21832184Return `True` if the set has no elements in common with *other*. Sets are disjoint if and only if their intersection is the empty set.21852186#### `issubset(other)`21872188#### `set <= other`21892190Проверяет, принадлежит ли каждый элемент множества множеству *other*.21912192#### `set < other`21932194Test whether the set is a proper subset of *other*, that is, `set <= other and set != other`.21952196#### `issuperset(other)`21972198#### `set >= other`21992200Проверяет, принадлежит ли каждый элемент *other* множеству.22012202#### `set > other`22032204Test whether the set is a proper superset of *other*, that is, `set >= other and set != other`.22052206#### `union(other, ...)`22072208#### `set | other | ...`22092210Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.22112212#### `intersection(other, ...)`22132214#### `set & other & ...`22152216Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.22172218#### `difference(other, ...)`22192220#### `set - other - ...`22212222Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.22232224#### `symmetric_difference(other)`22252226#### `set ^ other`22272228Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в *other*, но не в обоих.22292230#### `copy()`22312232Возвращает новое множество с поверхностной копией *s*.22332234Note, the non-operator versions of [`union()`](https://python-all.ru/3.4/library/stdtypes.html#set.union), [`intersection()`](https://python-all.ru/3.4/library/stdtypes.html#set.intersection), [`difference()`](https://python-all.ru/3.4/library/stdtypes.html#set.difference), and [`symmetric_difference()`](https://python-all.ru/3.4/library/stdtypes.html#set.symmetric_difference), [`issubset()`](https://python-all.ru/3.4/library/stdtypes.html#set.issubset), and [`issuperset()`](https://python-all.ru/3.4/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')`.22352236Both [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.4/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).22372238Instances of [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) are compared to instances of [`frozenset`](https://python-all.ru/3.4/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')])`.22392240The 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`.22412242Поскольку множества определяют только частичный порядок (отношения подмножества), результат работы метода [`list.sort()`](https://python-all.ru/3.4/library/stdtypes.html#list.sort) не определён для списков множеств.22432244Элементы множества, как и ключи словаря, должны быть [*хэшируемыми*](https://python-all.ru/3.4/glossary.html#term-hashable).22452246Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset).22472248В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.4/library/stdtypes.html#set), которые не применяются к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.4/library/stdtypes.html#frozenset):22492250#### `update(other, ...)`22512252#### `set |= other | ...`22532254Обновляет множество, добавляя элементы из всех других.22552256#### `intersection_update(other, ...)`22572258#### `set &= other & ...`22592260Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.22612262#### `difference_update(other, ...)`22632264#### `set -= other | ...`22652266Обновляет множество, удаляя элементы, найденные в других.22672268#### `symmetric_difference_update(other)`22692270#### `set ^= other`22712272Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.22732274#### `add(elem)`22752276Добавляет элемент *elem* в множество.22772278#### `remove(elem)`22792280Удаляет элемент *elem* из множества. Вызывает [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError), если *elem* не содержится во множестве.22812282#### `discard(elem)`22832284Удаляет элемент *elem* из множества, если он присутствует.22852286#### `pop()`22872288Удаляет и возвращает произвольный элемент из множества. Вызывает [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError), если множество пусто.22892290#### `clear()`22912292Удаляет все элементы из множества.22932294Обратите внимание: версии методов [`update()`](https://python-all.ru/3.4/library/stdtypes.html#set.update), [`intersection_update()`](https://python-all.ru/3.4/library/stdtypes.html#set.intersection_update), [`difference_update()`](https://python-all.ru/3.4/library/stdtypes.html#set.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.4/library/stdtypes.html#set.symmetric_difference_update), не использующие операторы, принимают любой итерируемый объект в качестве аргумента.22952296Обратите внимание: аргумент *elem* методов [`__contains__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.4/library/stdtypes.html#set.remove) и [`discard()`](https://python-all.ru/3.4/library/stdtypes.html#set.discard) может быть множеством. Для поддержки поиска эквивалентного неизменяемого множества (frozenset) множество *elem* временно изменяется во время поиска, а затем восстанавливается. Во время поиска не следует читать или изменять множество *elem*, так как оно не имеет осмысленного значения.22972298## 4.10. Типы отображений – [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict)22992300Объект [*отображения*](https://python-all.ru/3.4/glossary.html#term-mapping) сопоставляет [*хешируемые*](https://python-all.ru/3.4/glossary.html#term-hashable) значения с произвольными объектами. Отображения – изменяемые объекты. В настоящее время существует только один стандартный тип отображения – *словарь*. (Другие контейнеры см. во встроенных классах [`list`](https://python-all.ru/3.4/library/stdtypes.html#list), [`set`](https://python-all.ru/3.4/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.4/library/stdtypes.html#tuple), а также в модуле [`collections`](https://python-all.ru/3.4/library/collections.html#module-collections).)23012302Ключи словаря могут быть *почти* любыми значениями. Значения, которые не являются [*хэшируемыми*](https://python-all.ru/3.4/glossary.html#term-hashable), то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, `1` и `1.0`), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)23032304Словари можно создать, поместив разделённый запятыми список пар `ключ: значение` в фигурные скобки, например: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`, или с помощью конструктора [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict).23052306#### `class dict(**kwarg)`23072308#### `class dict(mapping, **kwarg)`23092310#### `class dict(iterable, **kwarg)`23112312Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.23132314Если позиционный аргумент не указан, создаётся пустой словарь. Если позиционный аргумент указан и является объектом отображения (mapping), создаётся словарь с теми же парами ключ-значение, что и у объекта отображения. В противном случае позиционный аргумент должен быть [*итерируемым объектом*](https://python-all.ru/3.4/glossary.html#term-iterable). Каждый элемент итерируемого объекта сам должен быть итерируемым объектом, содержащим ровно два объекта. Первый объект каждого элемента становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.23152316Если переданы именованные аргументы, они и их значения добавляются в словарь, созданный из позиционного аргумента. Если добавляемый ключ уже присутствует, значение из именованного аргумента заменяет значение из позиционного аргумента.23172318В качестве иллюстрации следующие примеры все возвращают словарь, равный `{"one": 1, "two": 2, "three": 3}`:23192320```python2321>>> a = dict(one=1, two=2, three=3)2322>>> b = {'one': 1, 'two': 2, 'three': 3}2323>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))2324>>> d = dict([('two', 2), ('one', 1), ('three', 3)])2325>>> e = dict({'three': 3, 'one': 1, 'two': 2})2326>>> a == b == c == d == e2327True2328```23292330Передача именованных аргументов, как в первом примере, работает только для ключей, являющихся допустимыми идентификаторами Python. В противном случае можно использовать любые допустимые ключи.23312332Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):23332334#### `len(d)`23352336Возвращает количество элементов в словаре *d*.23372338#### `d[key]`23392340Возвращает элемент *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError), если *key* отсутствует в отображении.23412342Если подкласс dict определяет метод [`__missing__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__missing__) и *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает то, что возвращает или возбуждает вызов `__missing__(key)`. Никакие другие операции или методы не вызывают [`__missing__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__missing__). Если [`__missing__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__missing__) не определён, возбуждается [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError). [`__missing__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__missing__) должен быть методом; это не может быть переменная экземпляра:23432344```python2345>>> class Counter(dict):2346...     def __missing__(self, key):2347...         return 02348>>> c = Counter()2349>>> c['red']235002351>>> c['red'] += 12352>>> c['red']235312354```23552356Приведённый выше пример показывает часть реализации [`collections.Counter`](https://python-all.ru/3.4/library/collections.html#collections.Counter). Другой метод `__missing__` используется в [`collections.defaultdict`](https://python-all.ru/3.4/library/collections.html#collections.defaultdict).23572358#### `d[key] = value`23592360Устанавливает `d[key]` в *value*.23612362#### `del d[key]`23632364Remove `d[key]` from *d*. Raises a [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError) if *key* is not in the map.23652366#### `key in d`23672368Возвращает `True`, если *d* содержит ключ *key*, иначе `False`.23692370#### `key not in d`23712372Эквивалентно `not key in d`.23732374#### `iter(d)`23752376Возвращает итератор по ключам словаря. Это более короткая запись для `iter(d.keys())`.23772378#### `clear()`23792380Удаляет все элементы из словаря.23812382#### `copy()`23832384Возвращает поверхностную копию словаря.23852386#### `classmethod fromkeys(seq[, value])`23872388Создаёт новый словарь, ключи которого берутся из *seq*, а значения устанавливаются равными *value*.23892390[`fromkeys()`](https://python-all.ru/3.4/library/stdtypes.html#dict.fromkeys) – это метод класса, который возвращает новый словарь. *value* по умолчанию равен `None`.23912392#### `get(key[, default])`23932394Возвращает значение для *key*, если *key* есть в словаре, иначе *default*. Если *default* не указан, он по умолчанию равен `None`, так что этот метод никогда не вызывает [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError).23952396#### `items()`23972398Возвращает новое представление элементов словаря (пары `(key, value)`). См. [*документацию о представлениях*](https://python-all.ru/3.4/library/stdtypes.html#dict-views).23992400#### `keys()`24012402Возвращает новое представление ключей словаря. См. [*документацию по объектам-представлениям*](https://python-all.ru/3.4/library/stdtypes.html#dict-views).24032404#### `pop(key[, default])`24052406Если *key* есть в словаре, удаляет его и возвращает его значение, иначе возвращает *default*. Если *default* не указан и *key* отсутствует в словаре, вызывается [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError).24072408#### `popitem()`24092410Удаляет и возвращает произвольную пару `(key, value)` из словаря.24112412[`popitem()`](https://python-all.ru/3.4/library/stdtypes.html#dict.popitem) удобна для разрушающего перебора словаря, что часто используется в алгоритмах над множествами. Если словарь пуст, вызов [`popitem()`](https://python-all.ru/3.4/library/stdtypes.html#dict.popitem) вызывает [`KeyError`](https://python-all.ru/3.4/library/exceptions.html#KeyError).24132414#### `setdefault(key[, default])`24152416Если *key* есть в словаре, возвращает его значение. Если нет, вставляет *key* со значением *default* и возвращает *default*. *default* по умолчанию равен `None`.24172418#### `update([other])`24192420Обновляет словарь парами ключ/значение из *other*, перезаписывая существующие ключи. Возвращает `None`.24212422[`update()`](https://python-all.ru/3.4/library/stdtypes.html#dict.update) принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (кортежи или другие итерабельные объекты длиной два). Если указаны именованные аргументы, словарь обновляется этими парами ключ/значение: `d.update(red=1, blue=2)`.24232424#### `values()`24252426Возвращает новое представление (view) значений словаря. См. [*документацию по объектам-представлениям*](https://python-all.ru/3.4/library/stdtypes.html#dict-views).24272428Словари считаются равными тогда и только тогда, когда они содержат одни и те же пары `(key, value)`. Операции сравнения порядка (‘\<’, ‘\<=’, ‘\>=’, ‘\>’) вызывают [`TypeError`](https://python-all.ru/3.4/library/exceptions.html#TypeError).24292430> **См. также**2431>2432> [`types.MappingProxyType`](https://python-all.ru/3.4/library/types.html#types.MappingProxyType) можно использовать для создания представления только для чтения для [`dict`](https://python-all.ru/3.4/library/stdtypes.html#dict).24332434### 4.10.1. Объекты-представления словаря24352436Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.4/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.4/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.4/library/stdtypes.html#dict.items), являются *представлениями*. Они предоставляют динамическое представление содержимого словаря: при изменении словаря представление отражает эти изменения.24372438Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:24392440#### `len(dictview)`24412442Возвращает количество записей в словаре.24432444#### `iter(dictview)`24452446Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) словаря.24472448Ключи и значения итерируются в произвольном порядке, который не является случайным, варьируется в разных реализациях Python и зависит от истории вставок и удалений в словаре. Если представления ключей, значений и элементов итерируются без промежуточных изменений словаря, порядок элементов будет прямо соответствовать друг другу. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.4/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать тот же список: `pairs = [(v, k) for (k, v) in d.items()]`.24492450Итерация по представлениям во время добавления или удаления записей в словаре может вызвать [`RuntimeError`](https://python-all.ru/3.4/library/exceptions.html#RuntimeError) или не выполнить итерацию по всем записям.24512452#### `x in dictview`24532454Возвращает `True`, если *x* находится среди ключей, значений или элементов базового словаря (в последнем случае *x* должен быть кортежем `(key, value)`).24552456Представления ключей ведут себя как множества, поскольку их записи уникальны и хешируемы. Если все значения хешируемы, так что пары `(key, value)` уникальны и хешируемы, то представление элементов также ведёт себя как множество. (Представления значений не считаются множествами, так как их записи обычно не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса [`collections.abc.Set`](https://python-all.ru/3.4/library/collections.abc.html#collections.abc.Set) (например, `==`, `<` или `^`).24572458Пример использования представления словаря:24592460```python2461>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}2462>>> keys = dishes.keys()2463>>> values = dishes.values()24642465>>> # итерация2466>>> n = 02467>>> for val in values:2468...     n += val2469>>> print(n)247050424712472>>> # ключи и значения перебираются в одном и том же порядке2473>>> list(keys)2474['eggs', 'bacon', 'sausage', 'spam']2475>>> list(values)2476[2, 1, 1, 500]24772478>>> # объекты представления динамичны и отражают изменения словаря2479>>> del dishes['eggs']2480>>> del dishes['sausage']2481>>> list(keys)2482['spam', 'bacon']24832484>>> # операции над множествами2485>>> keys & {'eggs', 'bacon', 'salad'}2486{'bacon'}2487>>> keys ^ {'sausage', 'juice'}2488{'juice', 'sausage', 'bacon', 'spam'}2489```24902491## 4.11. Типы контекстных менеджеров24922493Оператор [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with) в Python поддерживает концепцию контекста выполнения, определяемого менеджером контекста. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который вводится перед выполнением тела оператора и завершается при окончании оператора:24942495#### `contextmanager.__enter__()`24962497Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, привязывается к идентификатору в предложении [`as`](https://python-all.ru/3.4/reference/compound_stmts.html#as) оператора [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with), использующего данный менеджер контекста.24982499Примером менеджера контекста, который возвращает самого себя, является [*файловый объект*](https://python-all.ru/3.4/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить [`open()`](https://python-all.ru/3.4/library/functions.html#open) использовать в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with).25002501Примером менеджера контекста, возвращающего связанный объект, является тот, который возвращается [`decimal.localcontext()`](https://python-all.ru/3.4/library/decimal.html#decimal.localcontext). Эти менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста, а затем возвращают копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with), не затрагивая код вне оператора [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with).25022503#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`25042505Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если во время выполнения тела оператора [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with) произошло исключение, аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.25062507Возврат истинного значения из этого метода заставит оператор [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with) подавить исключение и продолжить выполнение с оператора, следующего непосредственно за оператором [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with). В противном случае исключение продолжает распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, произошедшее в теле оператора [`with`](https://python-all.ru/3.4/reference/compound_stmts.html#with).25082509Переданное исключение никогда не должно повторно возбуждаться явно – вместо этого метод должен возвращать ложное значение, чтобы указать, что метод завершился успешно и не хочет подавлять возбуждённое исключение. Это позволяет коду управления контекстом легко определить, действительно ли метод [`__exit__()`](https://python-all.ru/3.4/library/stdtypes.html#contextmanager.__exit__) завершился ошибкой.25102511Python определяет несколько менеджеров контекста для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов и более простого управления активным десятичным контекстом. Конкретные типы не обрабатываются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.4/library/contextlib.html#module-contextlib) для примеров.25122513[*Генераторы*](https://python-all.ru/3.4/glossary.html#term-generator) Python и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.4/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором [`contextlib.contextmanager`](https://python-all.ru/3.4/library/contextlib.html#contextlib.contextmanager), она вернёт менеджер контекста, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.4/reference/datamodel.html#object.__exit__), а не итератор, создаваемый недекорированной функцией-генератором.25142515Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.25162517## 4.12. Другие встроенные типы25182519Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.25202521### 4.12.1. Модули25222523Единственная специальная операция над модулем – это доступ к атрибуту: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.4/reference/simple_stmts.html#import), строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, скорее он требует (внешнего) *определения* для модуля с именем *foo* где-либо.)25242525Специальным атрибутом каждого модуля является [`__dict__`](https://python-all.ru/3.4/library/stdtypes.html#object.__dict__). Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически изменит таблицу символов модуля, но прямое присваивание атрибуту `__dict__` невозможно (можно написать `m.__dict__['a'] = 1`, что определяет `m.a` как `1`, но нельзя написать `m.__dict__ = {}`). Изменять `__dict__` напрямую не рекомендуется.25262527Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.25282529### 4.12.2. Классы и экземпляры классов25302531См. [*Объекты, значения и типы*](https://python-all.ru/3.4/reference/datamodel.html#objects) и [*Определения классов*](https://python-all.ru/3.4/reference/compound_stmts.html#class).25322533### 4.12.3. Функции25342535Объекты функций создаются определениями функций. Единственная операция над объектом функции – это его вызов: `func(argument-list)`.25362537На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.25382539Дополнительную информацию см. в разделе [*Определения функций*](https://python-all.ru/3.4/reference/compound_stmts.html#function).25402541### 4.12.4. Методы25422543Методы – это функции, которые вызываются с использованием точечной нотации. Существует две разновидности: встроенные методы (например, `append()` у списков) и методы экземпляров классов. Встроенные методы описываются вместе с типами, которые их поддерживают.25442545Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, получается специальный объект: объект *связанного метода* (также называемый *методом экземпляра*). При вызове он добавляет аргумент `self` в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: `m.__self__` – это объект, над которым выполняется метод, а `m.__func__` – это функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.25462547Как и объекты функций, объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции (`meth.__func__`), установка атрибутов метода на связанных методах запрещена. Попытка установить атрибут у метода приводит к возбуждению [`AttributeError`](https://python-all.ru/3.4/library/exceptions.html#AttributeError). Чтобы установить атрибут метода, нужно явно установить его в базовом объекте функции:25482549```python2550>>> class C:2551...     def method(self):2552...         pass2553...2554>>> c = C()2555>>> c.method.whoami = 'my name is method'  # нельзя установить на методе2556Traceback (most recent call last):2557  File "<stdin>", line 1, in <module>2558AttributeError: 'method' object has no attribute 'whoami'2559>>> c.method.__func__.whoami = 'my name is method'2560>>> c.method.whoami2561'my name is method'2562```25632564Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.4/reference/datamodel.html#types).25652566### 4.12.5. Объекты кода25672568Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, например, тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.4/library/functions.html#compile) и могут быть извлечены из объектов функций через их атрибут `__code__`. См. также модуль [`code`](https://python-all.ru/3.4/library/code.html#module-code).25692570Объект кода может быть выполнен или вычислен путём передачи его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.4/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.4/library/functions.html#eval).25712572Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.4/reference/datamodel.html#types).25732574### 4.12.6. Объекты типов25752576Объекты типов представляют различные типы объектов. Тип объекта доступен через встроенную функцию [`type()`](https://python-all.ru/3.4/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.4/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.25772578Типы записываются так: `<class 'int'>`.25792580### 4.12.7. Объект None25812582Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один пустой объект с именем `None` (встроенное имя). `type(None)()` создаёт тот же самый синглтон.25832584Он записывается как `None`.25852586### 4.12.8. Объект Ellipsis25872588Этот объект обычно используется при срезах (см. [*Срезы*](https://python-all.ru/3.4/reference/expressions.html#slicings)). Он не поддерживает специальных операций. Существует ровно один объект-многоточие с именем [`Ellipsis`](https://python-all.ru/3.4/library/constants.html#Ellipsis) (встроенное имя). `type(Ellipsis)()` создаёт синглтон [`Ellipsis`](https://python-all.ru/3.4/library/constants.html#Ellipsis).25892590Оно записывается как `Ellipsis` или `...`.25912592### 4.12.9. Объект NotImplemented25932594Этот объект возвращается из операций сравнения и бинарных операций, когда их просят работать с типами, которые они не поддерживают. См. [*Сравнения*](https://python-all.ru/3.4/reference/expressions.html#comparisons) для получения дополнительной информации. Существует ровно один объект `NotImplemented`. `type(NotImplemented)()` создаёт единственный экземпляр.25952596Оно записывается как `NotImplemented`.25972598### 4.12.10. Булевы значения25992600Логические значения – это два константных объекта `False` и `True`. Они используются для представления истинностных значений (хотя другие значения также могут считаться ложными или истинными). В числовом контексте (например, при использовании в качестве аргумента арифметического оператора) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция [`bool()`](https://python-all.ru/3.4/library/functions.html#bool) может использоваться для преобразования любого значения в логическое, если это значение может быть интерпретировано как истинностное (см. раздел [*Проверка истинности*](https://python-all.ru/3.4/library/stdtypes.html#truth) выше).26012602Они записываются как `False` и `True` соответственно.26032604### 4.12.11. Внутренние объекты26052606См. [*Стандартная иерархия типов*](https://python-all.ru/3.4/reference/datamodel.html#types) для получения этой информации. В нем описываются объекты стековых кадров, объекты трассировки и объекты срезов.26072608## 4.13. Специальные атрибуты26092610Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где они уместны. Некоторые из них не возвращаются встроенной функцией [`dir()`](https://python-all.ru/3.4/library/functions.html#dir).26112612#### `object.__dict__`26132614Словарь или другой отображающий объект, используемый для хранения (изменяемых) атрибутов объекта.26152616#### `instance.__class__`26172618Класс, которому принадлежит экземпляр класса.26192620#### `class.__bases__`26212622Кортеж базовых классов объекта класса.26232624#### `class.__name__`26252626Имя класса или типа.26272628#### `class.__qualname__`26292630[*Квалифицированное имя*](https://python-all.ru/3.4/glossary.html#term-qualified-name) класса или типа.26312632Новое в версии 3.3.26332634#### `class.__mro__`26352636Этот атрибут представляет собой кортеж классов, которые учитываются при поиске базовых классов во время разрешения методов.26372638#### `class.mro()`26392640Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в [`__mro__`](https://python-all.ru/3.4/library/stdtypes.html#class.__mro__).26412642#### `class.__subclasses__()`26432644Каждый класс хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех ещё существующих ссылок. Пример:26452646```python2647>>> int.__subclasses__()2648[<class 'bool'>]2649```26502651Сноски26522653| [\[1\]](https://python-all.ru/3.4/library/stdtypes.html#id1) | Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([*Базовая настройка*](https://python-all.ru/3.4/reference/datamodel.html#customization)). |2654| --- | --- |26552656| [\[2\]](https://python-all.ru/3.4/library/stdtypes.html#id2) | Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей. |2657| --- | --- |26582659| [\[3\]](https://python-all.ru/3.4/library/stdtypes.html#id4) | Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов. |2660| --- | --- |26612662| \[4\] | *([1](https://python-all.ru/3.4/library/stdtypes.html#id6), [2](https://python-all.ru/3.4/library/stdtypes.html#id7), [3](https://python-all.ru/3.4/library/stdtypes.html#id8), [4](https://python-all.ru/3.4/library/stdtypes.html#id9))* Символы с регистром – это те, у которых свойство общей категории равно «Lu» (Letter, uppercase), «Ll» (Letter, lowercase) или «Lt» (Letter, titlecase). |2663| --- | --- |26642665| [\[5\]](https://python-all.ru/3.4/library/stdtypes.html#id10) | Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж. |2666| --- | --- |2667