stdtypes.md

1> **Источник:** https://python-all.ru/3.1/library/stdtypes.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 5. Встроенные типы89В следующих разделах описываются стандартные типы, встроенные в интерпретатор.1011Основные встроенные типы: числовые типы, последовательности, отображения, классы, экземпляры и исключения.1213Некоторые операции поддерживаются несколькими типами объектов; в частности, практически все объекты можно сравнивать, проверять на истинность и преобразовывать в строку (с помощью функции [`repr()`](https://python-all.ru/3.1/library/functions.html#repr) или несколько отличной функции [`str()`](https://python-all.ru/3.1/library/functions.html#str)). Последняя функция неявно используется, когда объект выводится функцией [`print()`](https://python-all.ru/3.1/library/functions.html#print).1415## 5.1. Проверка истинности1617Любой объект можно проверить на истинность для использования в условии [`if`](https://python-all.ru/3.1/reference/compound_stmts.html#if) или [`while`](https://python-all.ru/3.1/reference/compound_stmts.html#while) или в качестве операнда логических операций ниже. Следующие значения считаются ложными:1819>2021- `None`22- `False`23- ноль любого числового типа, например, `0`, `0.0`, `0j`.24- любая пустая последовательность, например, `''`, `()`, `[]`.25- любое пустое отображение, например, `{}`.26- экземпляры пользовательских классов, если класс определяет метод [`__bool__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__bool__) или [`__len__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__len__), когда этот метод возвращает целое ноль или логическое значение [`bool`](https://python-all.ru/3.1/library/functions.html#bool) `False`. [\[1\]](https://python-all.ru/3.1/library/stdtypes.html#id7)2728Все остальные значения считаются истинными – поэтому объекты многих типов всегда истинны.2930Операции и встроенные функции, возвращающие логический результат, всегда возвращают `0` или `False` для false и `1` или `True` для true, если не указано иное. (Важное исключение: логические операции `or` и `and` всегда возвращают один из своих операндов.)3132## 5.2. Булевы операции – [`and`](https://python-all.ru/3.1/reference/expressions.html#and), [`or`](https://python-all.ru/3.1/reference/expressions.html#or), [`not`](https://python-all.ru/3.1/reference/expressions.html#not)3334Это булевы операции в порядке возрастания приоритета:3536| Операция | Результат | Примечания |37| --- | --- | --- |38| `x or y` | если *x* ложно, то *y*, иначе *x* | (1) |39| `x and y` | если *x* ложно, то *x*, иначе *y* | (2) |40| `not x` | если *x* ложно, то `True`, иначе `False` | (3) |4142Примечания:43441. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`False`](https://python-all.ru/3.1/library/constants.html#False).452. Это оператор короткого замыкания, поэтому он вычисляет второй аргумент, только если первый равен [`True`](https://python-all.ru/3.1/library/constants.html#True).463. `not` имеет более низкий приоритет, чем нелогические операторы, поэтому `not a == b` интерпретируется как `not (a == b)`, а `a == not b` является синтаксической ошибкой.4748## 5.3. Сравнения4950В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (выше, чем у логических операций). Сравнения можно произвольно соединять в цепочки; например, `x < y <= z` эквивалентно `x < y and y <= z`, за исключением того, что *y* вычисляется только один раз (но в обоих случаях *z* не вычисляется вообще, когда `x < y` оказывается ложным).5152В этой таблице приведены операции сравнения:5354| Операция | Значение |55| --- | --- |56| `<` | строго меньше |57| `<=` | меньше или равно |58| `>` | строго больше |59| `>=` | больше или равно |60| `==` | равно |61| `!=` | не равно |62| `is` | идентичность объектов |63| `is not` | отрицание идентичности объектов |6465Объекты разных типов, за исключением разных числовых типов, никогда не считаются равными. Более того, некоторые типы (например, объекты функций) поддерживают только вырожденное понятие сравнения, при котором любые два объекта этого типа неравны. Операторы `<`, `<=`, `>` и `>=` возбуждают исключение [`TypeError`](https://python-all.ru/3.1/library/exceptions.html#TypeError), когда любой операнд является комплексным числом, объекты имеют разные типы, которые невозможно сравнить, или в других случаях, когда не определено упорядочение.6667Неидентичные экземпляры класса обычно сравниваются как неравные, если класс не определяет метод [`__eq__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__eq__).6869Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или к объектам других типов, если класс не определяет достаточное количество методов [`__lt__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__lt__), [`__le__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__le__), [`__gt__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__gt__) и [`__ge__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__ge__) (в общем случае достаточно [`__lt__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__lt__) и [`__eq__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__eq__), если нужны обычные значения операторов сравнения).7071Поведение операторов [`is`](https://python-all.ru/3.1/reference/expressions.html#is) и [`is not`](https://python-all.ru/3.1/reference/expressions.html#isnot) не может быть настроено; они также могут применяться к любым двум объектам и никогда не вызывают исключение.7273Ещё две операции с тем же синтаксическим приоритетом, `in` и `not in`, поддерживаются только типами последовательностей (см. ниже).7475## 5.4. Числовые типы – [`int`](https://python-all.ru/3.1/library/functions.html#int), [`float`](https://python-all.ru/3.1/library/functions.html#float), [`complex`](https://python-all.ru/3.1/library/functions.html#complex)7677Существует три различных числовых типа: *целые числа*, *числа с плавающей точкой* и *комплексные числа*. Кроме того, логические значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью `double` в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в [`sys.float_info`](https://python-all.ru/3.1/library/sys.html#sys.float_info). Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа *z*, используйте `z.real` и `z.imag`. (Стандартная библиотека включает дополнительные числовые типы: [`fractions`](https://python-all.ru/3.1/library/fractions.html#module-fractions) для рациональных чисел и [`decimal`](https://python-all.ru/3.1/library/decimal.html#module-decimal) для чисел с плавающей точкой с настраиваемой точностью.)7879Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Простые целые литералы (включая шестнадцатеричные, восьмеричные и двоичные числа) дают целые числа. Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление `'j'` или `'J'` к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно прибавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.8081Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до типа другого, где целое уже, чем с плавающей точкой, а то, в свою очередь, уже, чем комплексное. Сравнения чисел смешанного типа используют то же правило. [\[2\]](https://python-all.ru/3.1/library/stdtypes.html#id8) Конструкторы [`int()`](https://python-all.ru/3.1/library/functions.html#int), [`float()`](https://python-all.ru/3.1/library/functions.html#float) и [`complex()`](https://python-all.ru/3.1/library/functions.html#complex) можно использовать для создания чисел определённого типа.8283Все числовые типы (кроме комплексных) поддерживают следующие операции, отсортированные по возрастанию приоритета (операции в одной рамке имеют одинаковый приоритет; все числовые операции имеют более высокий приоритет, чем операции сравнения):8485| Операция | Результат | Примечания | Полная документация |86| --- | --- | --- | --- |87| `x + y` | сумма *x* и *y* |  |  |88| `x - y` | разность *x* и *y* |  |  |89| `x * y` | произведение *x* и *y* |  |  |90| `x / y` | частное *x* и *y* |  |  |91| `x // y` | неполное частное *x* и *y* | (1) |  |92| `x % y` | остаток от `x / y` | (2) |  |93| `-x` | *x* с обратным знаком |  |  |94| `+x` | *x* без изменений |  |  |95| `abs(x)` | абсолютное значение или модуль *x* |  | [`abs()`](https://python-all.ru/3.1/library/functions.html#abs) |96| `int(x)` | *x*, преобразованное в целое число | (3)(6) | [`int()`](https://python-all.ru/3.1/library/functions.html#int) |97| `float(x)` | *x*, преобразованное в число с плавающей запятой | (4)(6) | [`float()`](https://python-all.ru/3.1/library/functions.html#float) |98| `complex(re, im)` | комплексное число с действительной частью *re* и мнимой частью *im*. *im* по умолчанию равно нулю. | (6) | [`complex()`](https://python-all.ru/3.1/library/functions.html#complex) |99| `c.conjugate()` | сопряжённое комплексного числа *c* |  |  |100| `divmod(x, y)` | пара `(x // y, x % y)` | (2) | [`divmod()`](https://python-all.ru/3.1/library/functions.html#divmod) |101| `pow(x, y)` | *x* в степени *y* | (5) | [`pow()`](https://python-all.ru/3.1/library/functions.html#pow) |102| `x ** y` | *x* в степени *y* | (5) |  |103104Примечания:1051061. Также называется целочисленным делением. Результирующее значение является целым числом, хотя тип результата не обязательно int. Результат всегда округляется в сторону минус бесконечности: `1//2` равно `0`, `(-1)//2` равно `-1`, `1//(-2)` равно `-1`, а `(-1)//(-2)` равно `0`.1072. Не для комплексных чисел. Вместо этого преобразуйте в числа с плавающей запятой с помощью [`abs()`](https://python-all.ru/3.1/library/functions.html#abs), если это уместно.1083. Преобразование чисел с плавающей запятой в целые может выполняться округлением или усечением, как в C; обратитесь к функциям `floor()` и `ceil()` в модуле [`math`](https://python-all.ru/3.1/library/math.html#module-math) для получения однозначных преобразований.1094. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.1105. Python определяет `pow(0, 0)` и `0 ** 0` как `1`, что распространено в языках программирования.1116. Принимаемые числовые литералы включают цифры от `0` до `9` или любой эквивалент Unicode (кодовые точки со свойством `Nd`).112113   Полный список кодовых точек со свойством `Nd` приведен по адресу [http://www.unicode.org/Public/6.0.0/ucd/extracted/DerivedNumericType.txt](https://python-all.ru/3.1/library/stdtypes.html).114115Все типы [`numbers.Real`](https://python-all.ru/3.1/library/numbers.html#numbers.Real) ([`int`](https://python-all.ru/3.1/library/functions.html#int) и [`float`](https://python-all.ru/3.1/library/functions.html#float)) также включают следующие операции:116117| Операция | Результат | Примечания |118| --- | --- | --- |119| `math.trunc(x)` | *x*, усечённое до целого |  |120| `round(x[, n])` | *x*, округлённое до n знаков, с округлением половины до чётного. Если n опущено, по умолчанию 0. |  |121| `math.floor(x)` | наибольшее целое число с плавающей запятой, не превышающее *x* |  |122| `math.ceil(x)` | наименьшее целое число с плавающей запятой, не меньшее *x* |  |123124За дополнительными числовыми операциями обращайтесь к [`math`](https://python-all.ru/3.1/library/math.html#module-math) и [`cmath`](https://python-all.ru/3.1/library/cmath.html#module-cmath) модулям.125126### 5.4.1. Битовые операции над целыми числами127128Целые числа поддерживают дополнительные операции, которые имеют смысл только для битовых строк. Отрицательные числа обрабатываются как их дополнительный код (это предполагает достаточно большое количество битов, чтобы при операции не произошло переполнения).129130Приоритеты двоичных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция `~` имеет тот же приоритет, что и другие унарные числовые операции (`+` и `-`).131132В этой таблице перечислены битовые операции, отсортированные по возрастанию приоритета (операции в одной ячейке имеют одинаковый приоритет):133134| Операция | Результат | Примечания |135| --- | --- | --- |136| `x \| y` | побитовое *ИЛИ* для *x* и *y* |  |137| `x ^ y` | побитовое *исключающее ИЛИ* для *x* и *y* |  |138| `x & y` | побитовое *И* для *x* и *y* |  |139| `x << n` | *x*, сдвинутое влево на *n* битов | (1)(2) |140| `x >> n` | *x*, сдвинутое вправо на *n* битов | (1)(3) |141| `~x` | инвертированные биты *x* |  |142143Примечания:1441451. Отрицательные значения сдвига недопустимы и приводят к возникновению исключения [`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError).1462. Сдвиг влево на *n* бит эквивалентен умножению на `pow(2, n)` без проверки переполнения.1473. Сдвиг вправо на *n* бит эквивалентен делению на `pow(2, n)` без проверки переполнения.148149### 5.4.2. Дополнительные методы целочисленных типов150151Тип int реализует [`numbers.Integral`](https://python-all.ru/3.1/library/numbers.html#numbers.Integral) [*абстрактный базовый класс*](https://python-all.ru/3.1/glossary.html#term-abstract-base-class). Кроме того, он предоставляет ещё один метод:152153#### `int.bit_length()`154155Возвращает количество битов, необходимое для представления целого числа в двоичном виде, без учёта знака и ведущих нулей:156157```python158>>> n = -37159>>> bin(n)160'-0b100101'161>>> n.bit_length()1626163```164165Точнее, если `x` не равно нулю, то `x.bit_length()` – это единственное положительное целое число `k` такое, что выполняется `2**(k-1) <= abs(x) < 2**k`. Или, что то же самое, когда `abs(x)` достаточно мал для корректного округления логарифма, то `k = 1 + int(log(abs(x), 2))`. Если `x` равно нулю, то `x.bit_length()` возвращает `0`.166167Эквивалентно следующему:168169```python170def bit_length(self):171    s = bin(self)       # двоичное представление:  bin(-37) --> '-0b100101'172    s = s.lstrip('-0b') # удалить ведущие нули и знак минус173    return len(s)       # len('100101') --> 6174```175176Новое в версии 3.1.177178### 5.4.3. Дополнительные методы типа float179180Тип float реализует [`numbers.Real`](https://python-all.ru/3.1/library/numbers.html#numbers.Real) [*абстрактный базовый класс*](https://python-all.ru/3.1/glossary.html#term-abstract-base-class). Кроме того, float имеет следующие дополнительные методы.181182#### `float.as_integer_ratio()`183184Возвращает пару целых чисел, отношение которых в точности равно исходному числу с плавающей запятой, с положительным знаменателем. Возбуждает185186[`OverflowError`](https://python-all.ru/3.1/library/exceptions.html#OverflowError)187188для бесконечностей и189190[`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError)191192для NaN.193194#### `float.is_integer()`195196Возвращает `True`, если экземпляр float является конечным и имеет целое значение, и `False` в противном случае:197198```python199>>> (-2.0).is_integer()200True201>>> (3.2).is_integer()202False203```204205Два метода поддерживают преобразование в шестнадцатеричные строки и обратно. Поскольку числа с плавающей запятой в Python внутренне хранятся в двоичном виде, преобразование числа с плавающей запятой в строку *decimal* и обратно обычно связано с небольшой ошибкой округления. Напротив, шестнадцатеричные строки позволяют точно представлять и задавать числа с плавающей запятой. Это может быть полезно при отладке и в численных расчётах.206207#### `float.hex()`208209Возвращает представление числа с плавающей запятой в виде шестнадцатеричной строки. Для конечных чисел с плавающей запятой такое представление всегда содержит префикс210211`0x`212213и суффикс214215`p`216217с показателем степени.218219#### `classmethod float.fromhex(s)`220221Метод класса, возвращающий число с плавающей запятой, представленное шестнадцатеричной строкой222223*s*224225. Строка226227*s*228229может содержать начальные и конечные пробелы.230231Обратите внимание, что [`float.hex()`](https://python-all.ru/3.1/library/stdtypes.html#float.hex) – это метод экземпляра, тогда как [`float.fromhex()`](https://python-all.ru/3.1/library/stdtypes.html#float.fromhex) – это метод класса.232233Шестнадцатеричная строка имеет вид:234235```python236[sign] ['0x'] integer ['.' fraction] ['p' exponent]237```238239где необязательный `знак` может быть `+` или `-`, `целая часть` и `дробная часть` – строки шестнадцатеричных цифр, а `порядок` – десятичное целое с необязательным ведущим знаком. Регистр не имеет значения, и должна быть хотя бы одна шестнадцатеричная цифра либо в целой, либо в дробной части. Этот синтаксис похож на синтаксис, указанный в разделе 6.4.4.2 стандарта C99, а также на синтаксис, используемый в Java 1.5 и выше. В частности, результат [`float.hex()`](https://python-all.ru/3.1/library/stdtypes.html#float.hex) может использоваться как шестнадцатеричный литерал с плавающей запятой в коде на C или Java, а шестнадцатеричные строки, создаваемые символом формата `%a` в C или методом `Double.toHexString` в Java, принимаются [`float.fromhex()`](https://python-all.ru/3.1/library/stdtypes.html#float.fromhex).240241Обратите внимание, что порядок записывается в десятичном виде, а не в шестнадцатеричном, и что он показывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка `0x3.a7p10` представляет число с плавающей запятой `(3 + 10./16 + 7./16**2) * 2.0**10`, или `3740.0`:242243```python244>>> float.fromhex('0x3.a7p10')2453740.0246```247248Применение обратного преобразования к `3740.0` даёт другую шестнадцатеричную строку, представляющую то же число:249250```python251>>> float.hex(3740.0)252'0x1.d380000000000p+11'253```254255## 5.5. Типы итераторов256257Python поддерживает концепцию итерации по контейнерам. Это реализовано с помощью двух различных методов; они используются, чтобы позволить пользовательским классам поддерживать итерацию. Последовательности, описанные ниже более подробно, всегда поддерживают методы итерации.258259Для поддержки итерации в объектах-контейнерах необходимо определить один метод:260261#### `container.__iter__()`262263Возвращает объект-итератор. Объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные виды итерации, можно добавить дополнительные методы для явного запроса итераторов для этих типов итерации. (Пример объекта, поддерживающего несколько форм итерации – древовидная структура, которая поддерживает как обход в ширину, так и обход в глубину.) Этот метод соответствует полю264265[`tp_iter`](https://python-all.ru/3.1/c-api/typeobj.html#tp_iter)266267структуры типа для объектов Python в Python/C API.268269Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют *протокол итератора*:270271#### `iterator.__iter__()`272273Возвращает сам объект-итератор. Это требуется, чтобы и контейнеры, и итераторы можно было использовать с операторами274275[`for`](https://python-all.ru/3.1/reference/compound_stmts.html#for)276277и278279[`in`](https://python-all.ru/3.1/reference/expressions.html#in)280281. Этот метод соответствует полю282283[`tp_iter`](https://python-all.ru/3.1/c-api/typeobj.html#tp_iter)284285структуры типа для объектов Python в Python/C API.286287#### `iterator.__next__()`288289Возвращает следующий элемент из контейнера. Если больше нет элементов, возбуждает исключение290291[`StopIteration`](https://python-all.ru/3.1/library/exceptions.html#StopIteration)292293. Этот метод соответствует полю294295[`tp_iternext`](https://python-all.ru/3.1/c-api/typeobj.html#tp_iternext)296297структуры типа для объектов Python в Python/C API.298299Python определяет несколько объектов итераторов для поддержки итерации по общим и специфическим типам последовательностей, словарям и другим более специализированным формам. Конкретные типы не важны, кроме их реализации протокола итератора.300301Как только метод `__next__()` итератора возбуждает исключение [`StopIteration`](https://python-all.ru/3.1/library/exceptions.html#StopIteration), он должен продолжать делать это при последующих вызовах. Реализации, не соблюдающие это свойство, считаются некорректными.302303### 5.5.1. Типы генераторов304305Генераторы [*generator*](https://python-all.ru/3.1/glossary.html#term-generator) в Python предоставляют удобный способ реализации протокола итератора. Если метод [`__iter__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__iter__) объекта-контейнера реализован как генератор, он автоматически возвращает объект-итератор (технически, объект-генератор), предоставляющий методы [`__iter__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__iter__) и `__next__()`. Дополнительную информацию о генераторах можно найти в [*документации по выражению yield*](https://python-all.ru/3.1/reference/expressions.html#yieldexpr).306307## 5.6. Типы последовательностей – [`str`](https://python-all.ru/3.1/library/functions.html#str), [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes), [`bytearray`](https://python-all.ru/3.1/library/functions.html#bytearray), [`list`](https://python-all.ru/3.1/library/functions.html#list), [`tuple`](https://python-all.ru/3.1/library/functions.html#tuple), [`range`](https://python-all.ru/3.1/library/functions.html#range)308309Существует шесть типов последовательностей: строки, последовательности байтов (объекты [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes)), массивы байтов (объекты [`bytearray`](https://python-all.ru/3.1/library/functions.html#bytearray)), списки, кортежи и объекты range. Для других контейнеров обратитесь ко встроенным классам [`dict`](https://python-all.ru/3.1/library/stdtypes.html#dict) и [`set`](https://python-all.ru/3.1/library/stdtypes.html#set), а также к модулю [`collections`](https://python-all.ru/3.1/library/collections.html#module-collections).310311Строки содержат символы Unicode. Их литералы записываются в одинарных или двойных кавычках: `'xyzzy'`, `"frobozz"`. Подробнее о строковых литералах см. [*String and Bytes literals*](https://python-all.ru/3.1/reference/lexical_analysis.html#strings). Помимо описанной здесь функциональности, существуют также строковые методы, описанные в разделе [*String Methods*](https://python-all.ru/3.1/library/stdtypes.html#string-methods).312313Объекты bytes и bytearray содержат отдельные байты – первый является неизменяемым, а второй – изменяемой последовательностью. Объекты bytes можно создать с помощью конструктора [`bytes()`](https://python-all.ru/3.1/library/functions.html#bytes), а также из литералов, используя префикс `b` с обычным синтаксисом строк: `b'xyzzy'`. Для создания массивов байтов используется функция [`bytearray()`](https://python-all.ru/3.1/library/functions.html#bytearray).314315> **Предупреждение**316>317> В то время как строковые объекты являются последовательностями символов (представленных строками длиной 1), объекты bytes и bytearray являются последовательностями *целых чисел* (от 0 до 255), представляющих значение ASCII отдельных байтов. Это означает, что для объекта bytes или bytearray *b*, `b[0]` будет целым числом, а `b[0:1]` будет объектом bytes или bytearray длиной 1. Представление объектов bytes использует формат литерала (`b'...'`), так как это обычно более полезно, чем, например, `bytes([50, 19, 100])`. Вы всегда можете преобразовать объект bytes в список целых чисел с помощью `list(b)`.318>319> Кроме того, хотя в предыдущих версиях Python байтовые строки и строки Unicode можно было довольно свободно заменять друг другом (за исключением проблем кодировки), строки и байты теперь являются полностью отдельными понятиями. Неявного кодирования/декодирования при передаче объекта неправильного типа не происходит. Строка всегда неравна объекту bytes или bytearray при сравнении.320321Списки создаются с помощью квадратных скобок, разделяя элементы запятыми: `[a, b, c]`. Кортежи создаются с помощью оператора запятой (не внутри квадратных скобок), с обрамляющими круглыми скобками или без них, но пустой кортеж должен иметь обрамляющие круглые скобки, например `a, b, c` или `()`. Кортеж из одного элемента должен иметь завершающую запятую, например `(d,)`.322323Объекты типа range создаются с помощью функции [`range()`](https://python-all.ru/3.1/library/functions.html#range). Они не поддерживают срезы, конкатенацию или повторение, и использование `in`, `not in`, [`min()`](https://python-all.ru/3.1/library/functions.html#min) или [`max()`](https://python-all.ru/3.1/library/functions.html#max) с ними неэффективно.324325Большинство типов последовательностей поддерживают следующие операции. Операции `in` и `not in` имеют тот же приоритет, что и операции сравнения. Операции `+` и `*` имеют тот же приоритет, что и соответствующие числовые операции. [\[3\]](https://python-all.ru/3.1/library/stdtypes.html#id9) Дополнительные методы предоставляются для [*Изменяемых типов последовательностей*](https://python-all.ru/3.1/library/stdtypes.html#typesseq-mutable).326327В этой таблице перечислены операции над последовательностями, отсортированные по возрастанию приоритета (операции в одном блоке имеют одинаковый приоритет). В таблице *s* и *t* – последовательности одного типа; *n*, *i* и *j* – целые числа:328329| Операция | Результат | Примечания |330| --- | --- | --- |331| `x в s` | `True`, если элемент *s* равен *x*, иначе `False` | (1) |332| `x не в s` | `False`, если элемент *s* равен *x*, иначе `True` | (1) |333| `s + t` | конкатенация *s* и *t* | (6) |334| `s * n, n * s` | *n* поверхностных копий *s*, объединённых | (2) |335| `s[i]` | *i*-й элемент *s*, индексация с 0 | (3) |336| `s[i:j]` | срез *s* от *i* до *j* | (3)(4) |337| `s[i:j:k]` | срез *s* от *i* до *j* с шагом *k* | (3)(5) |338| `len(s)` | длина *s* |  |339| `min(s)` | наименьший элемент *s* |  |340| `max(s)` | наибольший элемент *s* |  |341| `s.index(i)` | индекс первого вхождения *i* в *s* |  |342| `s.count(i)` | общее количество вхождений *i* в *s* |  |343344Типы последовательностей также поддерживают сравнения. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равным, а две последовательности должны быть одного типа и иметь одинаковую длину. (Полные подробности см. в [*Сравнения*](https://python-all.ru/3.1/reference/expressions.html#comparisons) в справочнике по языку.)345346Примечания:3473481. Если *s* является строковым объектом, операции `in` и `not in` работают как проверка на подстроку.3492. Значения *n* меньше `0` интерпретируются как `0` (что даёт пустую последовательность того же типа, что и *s*). Также обратите внимание, что копии являются поверхностными; вложенные структуры не копируются. Это часто удивляет новичков в Python; рассмотрите:350351   ```python352   >>> lists = [[]] * 3353   >>> lists354   [[], [], []]355   >>> lists[0].append(3)356   >>> lists357   [[3], [3], [3]]358   ```359360   Произошло следующее: `[[]]` – это список из одного элемента, содержащий пустой список, поэтому все три элемента `[[]] * 3` являются (указателями на) этот единственный пустой список. Модификация любого из элементов `списков` изменяет этот единственный список. Создать список из разных списков можно так:361362   ```python363   >>> lists = [[] for i in range(3)]364   >>> lists[0].append(3)365   >>> lists[1].append(5)366   >>> lists[2].append(7)367   >>> lists368   [[3], [5], [7]]369   ```3703. Если *i* или *j* отрицательно, индекс отсчитывается от конца строки: подставляется `len(s) + i` или `len(s) + j`. Но обратите внимание, что `-0` по-прежнему равно `0`.3714. Срез *s* от *i* до *j* определяется как последовательность элементов с индексом *k*, таким что `i <= k < j`. Если *i* или *j* больше `len(s)`, используется `len(s)`. Если *i* опущено или равно `None`, используется `0`. Если *j* опущено или равно `None`, используется `len(s)`. Если *i* больше или равно *j*, срез пуст.3725. Срез *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`.3736. **Особенности реализации CPython:** Если *s* и *t* являются строками, некоторые реализации Python, такие как CPython, обычно могут выполнять оптимизацию на месте для присваиваний вида `s = s + t` или `s += t`. Когда это применимо, такая оптимизация делает квадратичное время выполнения гораздо менее вероятным. Эта оптимизация зависит от версии и реализации. Для кода, чувствительного к производительности, предпочтительнее использовать метод [`str.join()`](https://python-all.ru/3.1/library/stdtypes.html#str.join), который гарантирует стабильную линейную производительность конкатенации во всех версиях и реализациях.374375### 5.6.1. Строковые методы376377Строковые объекты поддерживают перечисленные ниже методы. Обратите внимание, что ни один из этих методов не принимает именованные аргументы.378379Кроме того, строки Python поддерживают методы типов последовательностей, описанные в разделе [*Sequence Types – str, bytes, bytearray, list, tuple, range*](https://python-all.ru/3.1/library/stdtypes.html#typesseq). Для вывода форматированных строк см. раздел [*String Formatting*](https://python-all.ru/3.1/library/string.html#string-formatting). Также см. модуль [`re`](https://python-all.ru/3.1/library/re.html#module-re) для строковых функций, основанных на регулярных выражениях.380381#### `str.capitalize()`382383Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.384385#### `str.center(width[, fillchar])`386387Возвращает строку длины388389*width*390391, в которой исходная строка располагается по центру. Заполнение выполняется с использованием указанного символа392393*fillchar*394395(по умолчанию пробел).396397#### `str.count(sub[, start[, end]])`398399Возвращает количество непересекающихся вхождений подстроки400401*sub*402403в диапазоне \[404405*start*406407,408409*end*410411\]. Необязательные аргументы412413*start*414415и416417*end*418419интерпретируются как в нотации срезов.420421#### `str.encode([encoding[, errors]])`422423Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – текущая строковая кодировка по умолчанию. *errors* может быть указан для задания другой схемы обработки ошибок. Значение по умолчанию для *errors* – `'strict'`, что означает, что ошибки кодирования вызывают [`UnicodeError`](https://python-all.ru/3.1/library/exceptions.html#UnicodeError). Другие возможные значения: `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'` и любое другое имя, зарегистрированное через [`codecs.register_error()`](https://python-all.ru/3.1/library/codecs.html#codecs.register_error); см. раздел [*Codec Base Classes*](https://python-all.ru/3.1/library/codecs.html#codec-base-classes). Список возможных кодировок см. в разделе [*Standard Encodings*](https://python-all.ru/3.1/library/codecs.html#standard-encodings).424425Изменено в версии 3.1: Добавлена поддержка именованных аргументов.426427#### `str.endswith(suffix[, start[, end]])`428429Возвращает430431`True`432433, если строка заканчивается указанным434435*suffix*436437, иначе возвращает438439`False`440441.442443*suffix*444445также может быть кортежем суффиксов, которые нужно искать. С необязательным446447*start*448449проверка начинается с этой позиции. С необязательным450451*end*452453сравнение останавливается на этой позиции.454455#### `str.expandtabs([tabsize])`456457Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами в зависимости от текущей позиции столбца и заданного размера табуляции. Номер столбца сбрасывается в ноль после каждого перевода строки в строке. Если458459*tabsize*460461не указан, предполагается размер табуляции462463`8`464465символа. Этот метод не обрабатывает другие непечатаемые символы или escape-последовательности.466467#### `str.find(sub[, start[, end]])`468469Возвращает наименьший индекс в строке, где найдена подстрока *sub*, такой что *sub* содержится в срезе `s[start:end]`. Необязательные аргументы *start* и *end* интерпретируются как в нотации срезов. Возвращает `-1`, если *sub* не найдена.470471> **Примечание**472>473> Метод [`find()`](https://python-all.ru/3.1/library/stdtypes.html#str.find) следует использовать только если нужно узнать позицию *sub*. Чтобы проверить, является ли *sub* подстрокой, используйте оператор [`in`](https://python-all.ru/3.1/reference/expressions.html#in):474>475> ```python476> >>> 'Py' in 'Python'477> True478> ```479480#### `str.format(*args, **kwargs)`481482Выполняет операцию форматирования строки. Аргумент *format\_string* может содержать литеральный текст или поля замены, ограниченные фигурными скобками `{}`. Каждое поле замены содержит либо числовой индекс позиционного аргумента, либо имя именованного аргумента. Возвращает копию *format\_string*, в которой каждое поле замены заменено строковым значением соответствующего аргумента.483484```python485>>> "The sum of 1 + 2 is {0}".format(1+2)486'The sum of 1 + 2 is 3'487```488489См. [*Синтаксис форматных строк*](https://python-all.ru/3.1/library/string.html#formatstrings) для описания различных параметров форматирования, которые можно указать в форматных строках.490491#### `str.index(sub[, start[, end]])`492493Как494495[`find()`](https://python-all.ru/3.1/library/stdtypes.html#str.find)496497, но вызывает498499[`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError)500501, если подстрока не найдена.502503#### `str.isalnum()`504505Возвращает true, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе false. Символ506507`c`508509является буквенно-цифровым, если один из следующих методов возвращает510511`True`512513:514515`c.isalpha()`516517,518519`c.isdecimal()`520521,522523`c.isdigit()`524525или526527`c.isnumeric()`528529.530531#### `str.isalpha()`532533Возвращает true, если все символы в строке являются буквенными и есть хотя бы один символ, иначе false. Буквенные символы – это символы, определённые в базе данных символов Unicode как «Letter», т.е. те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Unicode.534535#### `str.isdecimal()`536537Возвращает true, если все символы в строке являются десятичными цифрами и есть хотя бы один символ, и false в противном случае. Десятичными считаются символы из общей категории “Nd”. Эта категория включает цифровые символы, а также все символы, которые могут использоваться для записи десятичных чисел, например U+0660, ARABIC-INDIC DIGIT ZERO.538539#### `str.isdigit()`540541Возвращает true, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false. Цифры включают десятичные символы и цифры, требующие специальной обработки, например совместимые надстрочные цифры. Формально цифрой является символ со значением свойства Numeric\_Type=Digit или Numeric\_Type=Decimal.542543#### `str.isidentifier()`544545Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, раздел546547[*Идентификаторы и ключевые слова*](https://python-all.ru/3.1/reference/lexical_analysis.html#identifiers)548549.550551#### `str.islower()`552553Возвращает true, если все символы с учётом регистра в строке являются строчными и есть хотя бы один такой символ, и false в противном случае. Символами с учётом регистра считаются те, у которых свойство общей категории равно “Lu”, “Ll” или “Lt”, а строчными символами считаются те, у которых свойство общей категории “Ll”.554555#### `str.isnumeric()`556557Возвращает true, если все символы в строке являются числовыми символами и есть хотя бы один символ, иначе false. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы – это символы со значением свойства Numeric\_Type=Digit, Numeric\_Type=Decimal или Numeric\_Type=Numeric.558559#### `str.isprintable()`560561Возвращает true, если все символы строки являются печатаемыми или строка пуста, иначе false. Непечатаемые символы – это те, которые определены в базе данных Unicode как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатаемым. (Обратите внимание, что печатаемые символы в данном контексте – это те, которые не должны экранироваться при вызове562563[`repr()`](https://python-all.ru/3.1/library/functions.html#repr)564565для строки. Это не влияет на обработку строк, записываемых в566567[`sys.stdout`](https://python-all.ru/3.1/library/sys.html#sys.stdout)568569или570571[`sys.stderr`](https://python-all.ru/3.1/library/sys.html#sys.stderr)572573.)574575#### `str.isspace()`576577Возвращает true, если в строке есть только пробельные символы и есть хотя бы один символ, иначе false. Пробельные символы – это символы, определённые в базе данных символов Unicode как «Other» или «Separator», а также символы со свойством двунаправленности, являющимся одним из «WS», «B» или «S».578579#### `str.istitle()`580581Возвращает true, если строка является строкой в заглавном регистре (titlecased) и есть хотя бы один символ, например прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. Иначе возвращает false.582583#### `str.isupper()`584585Возвращает true, если все символы с учётом регистра в строке являются прописными и есть хотя бы один такой символ, и false в противном случае. Символами с учётом регистра считаются те, у которых свойство общей категории равно “Lu”, “Ll” или “Lt”, а прописными символами считаются те, у которых свойство общей категории “Lu”.586587#### `str.join(iterable)`588589Возвращает строку, которая является конкатенацией строк из590591[*iterable*](https://python-all.ru/3.1/glossary.html#term-iterable)592593*iterable*594595. Если в596597*seq*598599есть значения, не являющиеся строками, в том числе объекты600601[`bytes`](https://python-all.ru/3.1/library/functions.html#bytes)602603, будет возбуждено604605[`TypeError`](https://python-all.ru/3.1/library/exceptions.html#TypeError)606607. В качестве разделителя между элементами используется строка, предоставляющая этот метод.608609#### `str.ljust(width[, fillchar])`610611Возвращает строку, выровненную по левому краю в строке длины612613*width*614615. Заполнение выполняется с использованием указанного616617*fillchar*618619(по умолчанию – пробел). Исходная строка возвращается, если620621*width*622623меньше624625`len(s)`626627.628629#### `str.lower()`630631Возвращает копию строки, преобразованную в нижний регистр.632633#### `str.lstrip([chars])`634635Возвращает копию строки с удалёнными начальными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом; удаляются все комбинации его значений:636637```python638>>> '   spacious   '.lstrip()639'spacious   '640>>> 'www.example.com'.lstrip('cmowz.')641'example.com'642```643644#### `static str.maketrans(x[, y[, z]])`645646Этот статический метод возвращает таблицу перевода, пригодную для использования в [`str.translate()`](https://python-all.ru/3.1/library/stdtypes.html#str.translate).647648Если передан только один аргумент, это должен быть словарь, отображающий коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или None. Ключи-символы при этом будут преобразованы в коды.649650Если передано два аргумента, они должны быть строками одинаковой длины, и в результирующем словаре каждый символ из x будет сопоставлен символу на той же позиции в y. Если есть третий аргумент, это должна быть строка, символы которой будут сопоставлены None в результате.651652#### `str.partition(sep)`653654Разделяет строку по первому вхождению655656*sep*657658и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий саму строку и две пустые строки.659660#### `str.replace(old, new[, count])`661662Возвращает копию строки, в которой все вхождения подстроки663664*old*665666заменены на667668*new*669670. Если задан необязательный аргумент671672*count*673674, заменяются только первые675676*count*677678вхождений.679680#### `str.rfind(sub[, start[, end]])`681682Возвращает наибольший индекс в строке, на котором найдена подстрока683684*sub*685686, такой, что687688*sub*689690содержится в691692`s[start:end]`693694. Необязательные аргументы695696*start*697698и699700*end*701702интерпретируются как в нотации срезов. Возвращает703704`-1`705706при неудаче.707708#### `str.rindex(sub[, start[, end]])`709710Похож на711712[`rfind()`](https://python-all.ru/3.1/library/stdtypes.html#str.rfind)713714, но возбуждает715716[`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError)717718, когда подстрока719720*sub*721722не найдена.723724#### `str.rjust(width[, fillchar])`725726Возвращает строку, выровненную по правому краю в строке длины727728*width*729730. Заполнение выполняется с использованием указанного731732*fillchar*733734(по умолчанию – пробел). Исходная строка возвращается, если735736*width*737738меньше739740`len(s)`741742.743744#### `str.rpartition(sep)`745746Разделяет строку по последнему вхождению747748*sep*749750и возвращает кортеж из трёх элементов: часть до разделителя, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из трёх элементов, содержащий две пустые строки и саму строку.751752#### `str.rsplit([sep[, maxsplit]])`753754Возвращает список слов в строке, используя755756*sep*757758в качестве строки-разделителя. Если указан759760*maxsplit*761762, выполняется не более763764*maxsplit*765766разбиений, причём767768*справа*769770Если771772*sep*773774не указан или равен775776`None`777778, разделителем считается любая строка из пробельных символов. За исключением разбиения справа,779780[`rsplit()`](https://python-all.ru/3.1/library/stdtypes.html#str.rsplit)781782ведёт себя как783784[`split()`](https://python-all.ru/3.1/library/stdtypes.html#str.split)785786, который подробно описан ниже.787788#### `str.rstrip([chars])`789790Возвращает копию строки с удалёнными конечными символами. Аргумент *chars* – это строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является суффиксом; удаляются все комбинации его значений:791792```python793>>> '   spacious   '.rstrip()794'   spacious'795>>> 'mississippi'.rstrip('ipz')796'mississ'797```798799#### `str.split([sep[, maxsplit]])`800801Возвращает список слов в строке, используя *sep* в качестве строки-разделителя. Если указан *maxsplit*, выполняется не более *maxsplit* разбиений (таким образом, список будет содержать не более `maxsplit+1` элементов). Если *maxsplit* не указан, то количество разбиений не ограничено (выполняются все возможные разбиения).802803Если указан *sep*, то последовательные разделители не объединяются в один, а считаются ограничителями пустых строк (например, `'1,,2'.split(',')` возвращает `['1', '', '2']`). Аргумент *sep* может состоять из нескольких символов (например, `'1<>2<>3'.split('<>')` возвращает `['1', '2', '3']`). Разбиение пустой строки с указанным разделителем возвращает `['']`.804805Если *sep* не указан или равен `None`, применяется другой алгоритм разбиения: последовательности пробельных символов считаются одним разделителем, и в результате не будет пустых строк в начале или конце, если строка начинается или заканчивается пробелами. Соответственно, разбиение пустой строки или строки, состоящей только из пробелов, с разделителем `None` возвращает `[]`.806807Например, `' 1 2 3 '.split()'` возвращает `['1', '2', '3']`, а `' 1 2 3 '.split(None, 1)` возвращает `['1', '2 3 ']`.808809#### `str.splitlines([keepends])`810811Возвращает список строк в строке, разбивая её по границам строк. Символы перевода строки не включаются в результирующий список, если только812813*keepends*814815не задан и не равен true.816817#### `str.startswith(prefix[, start[, end]])`818819Возвращает820821`True`822823, если строка начинается с префикса824825*prefix*826827, иначе возвращает828829`False`830831.832833*prefix*834835также может быть кортежем искомых префиксов. С необязательным836837*start*838839проверка начинается с указанной позиции. С необязательным840841*end*842843сравнение строки завершается на указанной позиции.844845#### `str.strip([chars])`846847Возвращает копию строки с удалёнными ведущими и завершающими символами. Аргумент *chars* – строка, задающая набор удаляемых символов. Если он опущен или равен `None`, аргумент *chars* по умолчанию удаляет пробельные символы. Аргумент *chars* не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:848849```python850>>> '   spacious   '.strip()851'spacious'852>>> 'www.example.com'.strip('cmowz.')853'example'854```855856#### `str.swapcase()`857858Возвращает копию строки, в которой символы верхнего регистра преобразованы в нижний и наоборот.859860#### `str.title()`861862Возвращает строку, где каждое слово начинается с прописной буквы, а остальные символы – строчные.863864Алгоритм использует простое, не зависящее от языка определение слова как группы последовательных букв. Это определение работает во многих контекстах, но означает, что апострофы в сокращениях и притяжательных формах образуют границы слов, что может быть нежелательным результатом:865866```python867>>> "they're bill's friends from the UK".title()868"They'Re Bill'S Friends From The Uk"869```870871Обходной путь для апострофов можно построить с помощью регулярных выражений:872873```python874>>> import re875>>> def titlecase(s):876        return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",877                      lambda mo: mo.group(0)[0].upper() +878                                 mo.group(0)[1:].lower(),879                      s)880881>>> titlecase("they're bill's friends.")882"They're Bill's Friends."883```884885#### `str.translate(map)`886887Возвращает копию *s*, в которой все символы преобразованы с помощью *map*, который должен быть словарём, отображающим коды Unicode (целые числа) в коды Unicode, строки или `None`. Неотображённые символы остаются без изменений. Символы, отображённые на `None`, удаляются.888889Для создания таблицы трансляции из символьных отображений в разных форматах можно использовать [`str.maketrans()`](https://python-all.ru/3.1/library/stdtypes.html#str.maketrans).890891> **Примечание**892>893> Ещё более гибкий подход – создать собственный кодек отображения символов с помощью модуля [`codecs`](https://python-all.ru/3.1/library/codecs.html#module-codecs) (см. `encodings.cp1251` в качестве примера).894895#### `str.upper()`896897Возвращает копию строки, преобразованную в верхний регистр.898899#### `str.zfill(width)`900901Возвращает числовую строку, дополненную слева нулями до длины902903*width*904905. Знаковый префикс обрабатывается корректно. Исходная строка возвращается, если906907*width*908909меньше910911`len(s)`912913.914915### 5.6.2. Устаревшие операции форматирования строк916917> **Примечание**918>919> Описанные здесь операции форматирования устарели и могут быть удалены в будущих версиях Python. В новом коде используйте [*новое форматирование строк*](https://python-all.ru/3.1/library/string.html#string-formatting).920921Строковые объекты имеют одну уникальную встроенную операцию: оператор `%` (modulo). Он также известен как оператор *форматирования* или *интерполяции* строк. При использовании `format % values` (где *format* – это строка), спецификации преобразования `%` в строке *format* заменяются на ноль или более элементов из *values*. Результат аналогичен использованию `sprintf()` в языке C.922923Если *format* требует один аргумент, то *values* может быть одним объектом, не являющимся кортежем. [\[4\]](https://python-all.ru/3.1/library/stdtypes.html#id10) В противном случае *values* должен быть кортежем с количеством элементов, точно указанным в строке формата, или одним объектом отображения (например, словарём).924925Спецификатор преобразования содержит два или более символа и состоит из следующих компонентов, которые должны располагаться в указанном порядке:9269271. Символ `'%'`, обозначающий начало спецификатора.9282. Ключ отображения (необязательно), состоящий из последовательности символов в скобках (например, `(somename)`).9293. Флаги преобразования (необязательно), влияющие на результат для некоторых типов преобразования.9304. Минимальная ширина поля (необязательно). Если указана как `'*'` (звёздочка), то фактическая ширина берётся из следующего элемента кортежа в *values*, а преобразуемый объект следует после минимальной ширины поля и необязательной точности.9315. Точность (необязательно) задаётся через `'.'` (точку) и следующее за ней значение точности. Если указана как `'*'` (звёздочка), то фактическая ширина считывается из следующего элемента кортежа *values*, а преобразуемое значение следует после точности.9326. Модификатор длины (необязательно).9337. Тип преобразования.934935Когда правый аргумент является словарём (или другим типом отображения), форматы в строке *должны* включать ключ отображения в скобках, указывающий на этот словарь, вставленный сразу после символа `'%'`. Ключ отображения выбирает значение для форматирования из отображения. Например:936937```python938>>> print('%(language)s has %(number)03d quote types.' %939...       {'language': "Python", "number": 2})940Python has 002 quote types.941```942943В этом случае в формате не должно быть спецификаторов `*` (поскольку они требуют последовательного списка параметров).944945Символы флагов преобразования:946947| Флаг | Значение |948| --- | --- |949| `'#'` | Преобразование значения будет использовать «альтернативную форму» (определённую ниже). |950| `'0'` | Для числовых значений преобразование будет дополняться нулями. |951| `'-'` | Преобразованное значение выравнивается по левому краю (переопределяет преобразование `'0'`, если указаны оба). |952| `' '` | (пробел) Перед положительным числом (или пустой строкой), полученным в результате знакового преобразования, следует оставлять пробел. |953| `'+'` | Знак (`'+'` или `'-'`) будет предшествовать преобразованию (переопределяет флаг «пробел»). |954955Модификатор длины (`h`, `l` или `L`) может присутствовать, но игнорируется, так как не нужен для Python – например, `%ld` идентично `%d`.956957Типы преобразования:958959| Преобразование | Значение | Примечания |960| --- | --- | --- |961| `'d'` | Десятичное целое со знаком. |  |962| `'i'` | Десятичное целое со знаком. |  |963| `'o'` | Восьмеричное значение со знаком. | (1) |964| `'u'` | Устаревший тип – он идентичен `'d'`. | (7) |965| `'x'` | Шестнадцатеричное со знаком (строчные буквы). | (2) |966| `'X'` | Шестнадцатеричное со знаком (заглавные буквы). | (2) |967| `'e'` | Экспоненциальный формат чисел с плавающей точкой (строчные буквы). | (3) |968| `'E'` | Экспоненциальный формат чисел с плавающей точкой (заглавные буквы). | (3) |969| `'f'` | Десятичный формат чисел с плавающей точкой. | (3) |970| `'F'` | Десятичный формат чисел с плавающей точкой. | (3) |971| `'g'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат со строчными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |972| `'G'` | Формат чисел с плавающей точкой. Использует экспоненциальный формат с заглавными буквами, если показатель степени меньше −4 или не меньше точности, в противном случае – десятичный формат. | (4) |973| `'c'` | Один символ (принимает целое число или строку из одного символа). |  |974| `'r'` | Строка (преобразует любой объект Python с помощью [`repr()`](https://python-all.ru/3.1/library/functions.html#repr)). | (5) |975| `'s'` | Строка (преобразует любой объект Python с помощью [`str()`](https://python-all.ru/3.1/library/functions.html#str)). |  |976| `'%'` | Ни один аргумент не преобразуется, результатом является символ `'%'` в итоговом выводе. |  |977978Примечания:9799801. Альтернативная форма приводит к вставке ведущего нуля (`'0'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.9812. Альтернативная форма приводит к вставке ведущего `'0x'` или `'0X'` (в зависимости от того, использовался ли формат `'x'` или `'X'`) между левым заполнением и форматированным числом, если первый символ результата ещё не является нулём.9823. Альтернативная форма всегда включает десятичную точку в результат, даже если после неё нет цифр.983984   Точность определяет количество цифр после десятичной точки; по умолчанию – 6.9854. Альтернативная форма всегда включает десятичную точку в результат, а конечные нули не удаляются, как это было бы в противном случае.986987   Точность определяет количество значащих цифр до и после десятичной точки; по умолчанию – 6.9885. Точность определяет максимальное количество используемых символов.9899907. См. [**PEP 237**](https://python-all.ru/3.1/library/stdtypes.html).991992Поскольку строки Python имеют явную длину, преобразования `%s` не предполагают, что `'\0'` является концом строки.993994Изменено в версии 3.1: преобразования `%f` для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями `%g`.995996Дополнительные строковые операции определены в стандартных модулях [`string`](https://python-all.ru/3.1/library/string.html#module-string) и [`re`](https://python-all.ru/3.1/library/re.html#module-re).997998### 5.6.3. Тип range9991000Тип [`range`](https://python-all.ru/3.1/library/functions.html#range) – это неизменяемая последовательность, обычно используемая для циклических операций. Преимущество типа [`range`](https://python-all.ru/3.1/library/functions.html#range) заключается в том, что объект [`range`](https://python-all.ru/3.1/library/functions.html#range) всегда занимает одинаковый объём памяти, независимо от размера диапазона, который он представляет. Каких-либо постоянных преимуществ в производительности нет.10011002Объекты range имеют очень мало поведения: они поддерживают только индексацию, итерацию и функцию [`len()`](https://python-all.ru/3.1/library/functions.html#len).10031004### 5.6.4. Изменяемые типы последовательностей10051006Объекты list и bytearray поддерживают дополнительные операции, позволяющие изменять объект на месте. Другие изменяемые типы последовательностей (если они будут добавлены в язык) также должны поддерживать эти операции. Строки и кортежи являются неизменяемыми типами последовательностей: такие объекты нельзя изменить после создания. Для изменяемых типов последовательностей определены следующие операции (где *x* – произвольный объект).10071008Обратите внимание: хотя списки допускают элементы любого типа, «элементы» объекта bytearray – это целые числа в диапазоне 0 \<= x \< 256.10091010| Операция | Результат | Примечания |1011| --- | --- | --- |1012| `s[i] = x` | элемент *i* из *s* заменяется на *x* |  |1013| `s[i:j] = t` | срез *s* от *i* до *j* заменяется содержимым итерируемого объекта *t* |  |1014| `del s[i:j]` | то же, что `s[i:j] = []` |  |1015| `s[i:j:k] = t` | элементы `s[i:j:k]` заменяются элементами *t* | (1) |1016| `del s[i:j:k]` | удаляет элементы `s[i:j:k]` из списка |  |1017| `s.append(x)` | то же, что и `s[len(s):len(s)] = [x]` |  |1018| `s.extend(x)` | то же, что и `s[len(s):len(s)] = x` | (2) |1019| `s.count(x)` | возвращает количество *i*, для которых `s[i] == x` |  |1020| `s.index(x[, i[, j]])` | возвращает наименьшее *k*, такое что `s[k] == x` и `i <= k < j` | (3) |1021| `s.insert(i, x)` | то же, что и `s[i:i] = [x]` | (4) |1022| `s.pop([i])` | то же, что и `x = s[i]; del s[i]; return x` | (5) |1023| `s.remove(x)` | то же, что и `del s[s.index(x)]` | (3) |1024| `s.reverse()` | переворачивает элементы *s* на месте | (6) |1025| `s.sort([key[, reverse]])` | сортирует элементы *s* на месте | (6), (7), (8) |10261027Примечания:102810291. *t* должен иметь ту же длину, что и заменяемый срез.10302. *x* может быть любым итерируемым объектом.10313. Возбуждает [`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError), если *x* не найден в *s*. Когда отрицательный индекс передаётся вторым или третьим параметром метода `index()`, к нему добавляется длина последовательности, как для срезов. Если он всё ещё отрицательный, он усекается до нуля, как для срезов.10324. Когда отрицательный индекс передаётся первым параметром методу `insert()`, к нему добавляется длина последовательности, как для срезов. Если он всё ещё отрицательный, он усекается до нуля, как для срезов.10335. Необязательный аргумент *i* по умолчанию равен `-1`, поэтому по умолчанию удаляется и возвращается последний элемент.10346. The `sort()` and `reverse()` methods modify the sequence in place for economy of space when sorting or reversing a large sequence. To remind you that they operate by side effect, they don’t return the sorted or reversed sequence.10357. Метод `sort()` принимает необязательные аргументы для управления сравнениями. Каждый должен быть указан как именованный аргумент.10361037   *key* задаёт функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка: `key=str.lower`. Значение по умолчанию – `None`.10381039   *reverse* – логическое значение. Если установлено в `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.10401041   Метод `sort()` гарантированно является устойчивым. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые считаются равными – это полезно при сортировке в несколько проходов (например, сначала по отделу, затем по уровню зарплаты).10421043   **Особенность реализации CPython:** Во время сортировки списка результат попытки изменить или даже просмотреть список не определён. C-реализация Python делает список пустым на время сортировки и вызывает [`ValueError`](https://python-all.ru/3.1/library/exceptions.html#ValueError), если может обнаружить, что список был изменён во время сортировки.10448. Метод `sort()` не поддерживается объектами [`bytearray`](https://python-all.ru/3.1/library/functions.html#bytearray).10451046### 5.6.5. Методы bytes и bytearray10471048Объекты bytes и bytearray, будучи «строками байтов», имеют все методы, доступные для строк, за исключением `encode()`, [`format()`](https://python-all.ru/3.1/library/functions.html#format) и `isidentifier()`, которые не имеют смысла для этих типов. Для преобразования объектов в строки у них есть метод `decode()`.10491050Если какому-либо из этих методов требуется интерпретировать байты как символы (например, методы `is...()`), предполагается набор символов ASCII.10511052> **Примечание**1053>1054> Методы объектов bytes и bytearray не принимают строки в качестве аргументов, так же как методы строк не принимают байты. Например, нужно писать1055>1056> ```python1057> a = "abc"1058> b = a.replace("a", "f")1059> ```1060>1061> и1062>1063> ```python1064> a = b"abc"1065> b = a.replace(b"a", b"f")1066> ```10671068#### `bytes.decode([encoding[, errors]])`10691070#### `bytearray.decode([encoding[, errors]])`10711072Возвращает строку, декодированную из заданных байтов. Кодировка по умолчанию – текущая стандартная строковая кодировка.10731074*errors*10751076может быть задан для использования другой схемы обработки ошибок. Значение по умолчанию для10771078*errors*10791080–10811082`'strict'`10831084, то есть ошибки кодирования вызывают10851086[`UnicodeError`](https://python-all.ru/3.1/library/exceptions.html#UnicodeError)10871088. Другие возможные значения:10891090`'ignore'`10911092,10931094`'replace'`10951096и любое другое имя, зарегистрированное через10971098[`codecs.register_error()`](https://python-all.ru/3.1/library/codecs.html#codecs.register_error)10991100; см. раздел11011102[*Codec Base Classes*](https://python-all.ru/3.1/library/codecs.html#codec-base-classes)11031104. Список возможных кодировок приведён в разделе11051106[*Standard Encodings*](https://python-all.ru/3.1/library/codecs.html#standard-encodings)11071108.11091110Типы bytes и bytearray имеют дополнительный метод класса:11111112#### `classmethod bytes.fromhex(string)`11131114#### `classmethod bytearray.fromhex(string)`11151116Этот метод класса [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes) возвращает объект bytes или bytearray, декодируя заданный строковый объект. Строка должна содержать две шестнадцатеричные цифры на байт, пробелы игнорируются.11171118```python1119>>> bytes.fromhex('f0 f1f2  ')1120b'\xf0\xf1\xf2'1121```11221123Методы maketrans и translate отличаются семантикой от версий, доступных для строк:11241125#### `bytes.translate(table[, delete])`11261127#### `bytearray.translate(table[, delete])`11281129Возвращает копию объекта bytes или bytearray, из которой удалены все байты, входящие в необязательный аргумент *delete*, а оставшиеся байты преобразованы через заданную таблицу перевода, которая должна быть объектом bytes длиной 256.11301131Для создания таблицы перевода можно использовать метод [`bytes.maketrans()`](https://python-all.ru/3.1/library/stdtypes.html#bytes.maketrans).11321133Установите аргумент *table* равным `None` для преобразований, которые только удаляют символы:11341135```python1136>>> b'read this short text'.translate(None, b'aeiou')1137b'rd ths shrt txt'1138```11391140#### `static bytes.maketrans(from, to)`11411142#### `static bytearray.maketrans(from, to)`11431144Этот статический метод возвращает таблицу перевода, пригодную для использования в [`bytes.translate()`](https://python-all.ru/3.1/library/stdtypes.html#bytes.translate), которая сопоставляет каждый символ из *from* с символом на той же позиции в *to*; *from* и *to* должны быть объектами bytes и иметь одинаковую длину.11451146Новое в версии 3.1.11471148## 5.7. Типы множеств – [`set`](https://python-all.ru/3.1/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset)11491150Объект *set* – это неупорядоченная коллекция уникальных [*хэшируемых*](https://python-all.ru/3.1/glossary.html#term-hashable) объектов. Обычное применение включает проверку принадлежности, удаление дубликатов из последовательности и вычисление математических операций, таких как пересечение, объединение, разность и симметрическая разность. (О других контейнерах см. встроенные классы [`dict`](https://python-all.ru/3.1/library/stdtypes.html#dict), [`list`](https://python-all.ru/3.1/library/functions.html#list) и [`tuple`](https://python-all.ru/3.1/library/functions.html#tuple), а также модуль [`collections`](https://python-all.ru/3.1/library/collections.html#module-collections).)11511152Как и другие коллекции, множества поддерживают `x in set`, `len(set)` и `for x in set`. Будучи неупорядоченной коллекцией, множества не сохраняют позицию элемента или порядок вставки. Соответственно, множества не поддерживают индексацию, срезы или другое поведение, подобное последовательностям.11531154В настоящее время существует два встроенных типа множеств: [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset). Тип [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) является изменяемым – содержимое можно изменять с помощью методов, таких как `add()` и `remove()`. Поскольку он изменяем, у него нет хэш-значения, и он не может использоваться ни в качестве ключа словаря, ни в качестве элемента другого множества. Тип [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset) является неизменяемым и [*хэшируемым*](https://python-all.ru/3.1/glossary.html#term-hashable) – его содержимое не может быть изменено после создания; поэтому его можно использовать как ключ словаря или как элемент другого множества.11551156Непустые множества (не frozenset) можно создать, перечислив элементы через запятую в фигурных скобках, например: `{'jack', 'sjoerd'}`, а также с помощью конструктора [`set`](https://python-all.ru/3.1/library/stdtypes.html#set).11571158Конструкторы обоих классов работают одинаково:11591160#### `class set([iterable])`11611162#### `class frozenset([iterable])`11631164Возвращает новый объект set или frozenset, элементы которого берутся из *iterable*. Элементы множества должны быть хэшируемыми. Для представления множеств множеств внутренние множества должны быть объектами [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset). Если *iterable* не указан, возвращается новое пустое множество.11651166Instances of [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset) provide the following operations:11671168#### `len(s)`11691170Return the cardinality of set11711172*s*11731174.11751176#### `x in s`11771178Проверяет принадлежность11791180*x*11811182множеству11831184*s*11851186.11871188#### `x not in s`11891190Проверяет отсутствие11911192*x*11931194в множестве11951196*s*11971198.11991200#### `isdisjoint(other)`12011202Возвращает True, если множество не имеет общих элементов с12031204*other*12051206. Множества являются непересекающимися тогда и только тогда, когда их пересечение является пустым множеством.12071208#### `issubset(other)`12091210#### `set <= other`12111212Проверяет, принадлежит ли каждый элемент множества множеству12131214*other*12151216.12171218#### `set < other`12191220Проверяет, является ли множество истинным подмножеством12211222*other*12231224, то есть12251226`set <= other и set != other`12271228.12291230#### `issuperset(other)`12311232#### `set >= other`12331234Проверяет, принадлежит ли каждый элемент12351236*other*12371238множеству.12391240#### `set > other`12411242Проверяет, является ли множество истинным надмножеством12431244*other*12451246, то есть12471248`set >= other и set != other`12491250.12511252#### `union(other, ...)`12531254#### `set | other | ...`12551256Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.12571258#### `intersection(other, ...)`12591260#### `set & other & ...`12611262Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.12631264#### `difference(other, ...)`12651266#### `set - other - ...`12671268Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.12691270#### `symmetric_difference(other)`12711272#### `set ^ other`12731274Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в12751276*other*12771278, но не в обоих.12791280#### `copy()`12811282Возвращает новое множество с поверхностной копией12831284*s*12851286.12871288Note, the non-operator versions of [`union()`](https://python-all.ru/3.1/library/stdtypes.html#set.union), [`intersection()`](https://python-all.ru/3.1/library/stdtypes.html#set.intersection), [`difference()`](https://python-all.ru/3.1/library/stdtypes.html#set.difference), and [`symmetric_difference()`](https://python-all.ru/3.1/library/stdtypes.html#set.symmetric_difference), [`issubset()`](https://python-all.ru/3.1/library/stdtypes.html#set.issubset), and [`issuperset()`](https://python-all.ru/3.1/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')`.12891290Both [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) and [`frozenset`](https://python-all.ru/3.1/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).12911292Instances of [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) are compared to instances of [`frozenset`](https://python-all.ru/3.1/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')])`.12931294Сравнения на подмножество и равенство не обобщаются до функции полного упорядочивания. Например, любые два непересекающихся множества не равны и не являются подмножествами друг друга, поэтому *all* из следующих возвращают `False`: `a<b`, `a==b` или `a>b`.12951296Поскольку множества определяют только частичный порядок (отношения подмножеств), результат метода `list.sort()` для списков множеств не определён.12971298Элементы множества, как и ключи словаря, должны быть [*хэшируемыми*](https://python-all.ru/3.1/glossary.html#term-hashable).12991300Бинарные операции, в которых смешиваются экземпляры [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset), возвращают тип первого операнда. Например: `frozenset('ab') | set('bc')` возвращает экземпляр [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset).13011302В следующей таблице перечислены операции, доступные для [`set`](https://python-all.ru/3.1/library/stdtypes.html#set), которые не применяются к неизменяемым экземплярам [`frozenset`](https://python-all.ru/3.1/library/stdtypes.html#frozenset):13031304#### `update(other, ...)`13051306#### `set |= other | ...`13071308Обновляет множество, добавляя элементы из всех других.13091310#### `intersection_update(other, ...)`13111312#### `set &= other & ...`13131314Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.13151316#### `difference_update(other, ...)`13171318#### `set -= other | ...`13191320Обновляет множество, удаляя элементы, найденные в других.13211322#### `symmetric_difference_update(other)`13231324#### `set ^= other`13251326Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.13271328#### `add(elem)`13291330Добавляет элемент13311332*elem*13331334в множество.13351336#### `remove(elem)`13371338Удаляет элемент13391340*elem*13411342из множества. Вызывает13431344[`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError)13451346, если13471348*elem*13491350не содержится во множестве.13511352#### `discard(elem)`13531354Удаляет элемент13551356*elem*13571358из множества, если он присутствует.13591360#### `pop()`13611362Удаляет и возвращает произвольный элемент из множества. Вызывает13631364[`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError)13651366, если множество пусто.13671368#### `clear()`13691370Удаляет все элементы из множества.13711372Обратите внимание: версии методов [`update()`](https://python-all.ru/3.1/library/stdtypes.html#set.update), [`intersection_update()`](https://python-all.ru/3.1/library/stdtypes.html#set.intersection_update), [`difference_update()`](https://python-all.ru/3.1/library/stdtypes.html#set.difference_update) и [`symmetric_difference_update()`](https://python-all.ru/3.1/library/stdtypes.html#set.symmetric_difference_update), не использующие операторы, принимают любой итерируемый объект в качестве аргумента.13731374Обратите внимание: аргумент *elem* методов [`__contains__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__contains__), [`remove()`](https://python-all.ru/3.1/library/stdtypes.html#set.remove) и [`discard()`](https://python-all.ru/3.1/library/stdtypes.html#set.discard) может быть множеством. Для поддержки поиска эквивалентного неизменяемого множества (frozenset) множество *elem* временно изменяется во время поиска, а затем восстанавливается. Во время поиска не следует читать или изменять множество *elem*, так как оно не имеет осмысленного значения.13751376## 5.8. Типы отображений – [`dict`](https://python-all.ru/3.1/library/stdtypes.html#dict)13771378Объект *отображения* сопоставляет [*хешируемые*](https://python-all.ru/3.1/glossary.html#term-hashable) значения произвольным объектам. Отображения являются изменяемыми объектами. В настоящее время существует только один стандартный тип отображения – *словарь*. (Другие контейнеры см. во встроенных классах [`list`](https://python-all.ru/3.1/library/functions.html#list), [`set`](https://python-all.ru/3.1/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.1/library/functions.html#tuple), а также в модуле [`collections`](https://python-all.ru/3.1/library/collections.html#module-collections).)13791380Ключи словаря могут быть *почти* любыми значениями. Значения, которые не являются [*хэшируемыми*](https://python-all.ru/3.1/glossary.html#term-hashable), то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, `1` и `1.0`), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)13811382Словари можно создать, поместив разделённый запятыми список пар `ключ: значение` в фигурные скобки, например: `{'jack': 4098, 'sjoerd': 4127}` или `{4098: 'jack', 4127: 'sjoerd'}`, или с помощью конструктора [`dict`](https://python-all.ru/3.1/library/stdtypes.html#dict).13831384#### `class dict([arg])`13851386Возвращает новый словарь, инициализированный из необязательного позиционного аргумента или набора именованных аргументов. Если аргументы не переданы, возвращается новый пустой словарь. Если позиционный аргумент *arg* является объектом отображения, возвращается словарь, сопоставляющий те же ключи тем же значениям, что и объект отображения. В противном случае позиционный аргумент должен быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Каждый элемент аргумента также должен быть одного из этих типов и, в свою очередь, содержать ровно два объекта. Первый используется как ключ в новом словаре, а второй – как значение ключа. Если один и тот же ключ встречается более одного раза, в новом словаре сохраняется последнее связанное с ним значение.13871388Если переданы именованные аргументы, сами ключевые слова с соответствующими значениями добавляются в словарь. Если ключ указан как в позиционном аргументе, так и в именованном, то в словаре сохраняется значение из именованного аргумента. Например, все следующие варианты возвращают словарь, равный `{"one": 1, "two": 2}`:13891390- `dict(one=1, two=2)`1391- `dict({'one': 1, 'two': 2})`1392- `dict(zip(('one', 'two'), (1, 2)))`1393- `dict([['two', 2], ['one', 1]])`13941395Первый пример работает только для ключей, являющихся допустимыми идентификаторами Python; остальные работают с любыми допустимыми ключами.13961397Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):13981399#### `len(d)`14001401Возвращает количество элементов в словаре14021403*d*14041405.14061407#### `d[key]`14081409Возвращает элемент *d* с ключом *key*. Вызывает [`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError), если *key* отсутствует в отображении.14101411Если подкласс dict определяет метод `__missing__()`, и ключ *key* отсутствует, операция `d[key]` вызывает этот метод с ключом *key* в качестве аргумента. Затем операция `d[key]` возвращает или возбуждает то, что возвращает или возбуждает вызов `__missing__(key)`, если ключ отсутствует. Никакие другие операции или методы не вызывают `__missing__()`. Если `__missing__()` не определен, возбуждается [`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError). `__missing__()` должен быть методом, а не переменной экземпляра. Пример см. в [`collections.defaultdict`](https://python-all.ru/3.1/library/collections.html#collections.defaultdict).14121413#### `d[key] = value`14141415Устанавливает14161417`d[key]`14181419в14201421*value*14221423.14241425#### `del d[key]`14261427Remove14281429`d[key]`14301431from14321433*d*14341435. Raises a14361437[`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError)14381439if14401441*key*14421443is not in the map.14441445#### `key in d`14461447Возвращает14481449`True`14501451, если14521453*d*14541455содержит ключ14561457*key*14581459, иначе14601461`False`14621463.14641465#### `key not in d`14661467Эквивалентно14681469`not key in d`14701471.14721473#### `iter(d)`14741475Возвращает итератор по ключам словаря. Это более короткая запись для14761477`iter(d.keys())`14781479.14801481#### `clear()`14821483Удаляет все элементы из словаря.14841485#### `copy()`14861487Возвращает поверхностную копию словаря.14881489#### `classmethod fromkeys(seq[, value])`14901491Создаёт новый словарь, ключи которого берутся из *seq*, а значения устанавливаются равными *value*.14921493[`fromkeys()`](https://python-all.ru/3.1/library/stdtypes.html#dict.fromkeys) – это метод класса, который возвращает новый словарь. *value* по умолчанию равен `None`.14941495#### `get(key[, default])`14961497Возвращает значение для14981499*key*15001501, если15021503*key*15041505есть в словаре, иначе15061507*default*15081509. Если15101511*default*15121513не указан, он по умолчанию равен15141515`None`15161517, так что этот метод никогда не вызывает15181519[`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError)15201521.15221523#### `items()`15241525Возвращает новое представление элементов словаря (пары15261527`(key, value)`15281529). См. ниже документацию объектов представления.15301531#### `keys()`15321533Возвращает новое представление ключей словаря. См. ниже документацию объектов представления.15341535#### `pop(key[, default])`15361537Если15381539*key*15401541есть в словаре, удаляет его и возвращает его значение, иначе возвращает15421543*default*15441545. Если15461547*default*15481549не указан и15501551*key*15521553отсутствует в словаре, вызывается15541555[`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError)15561557.15581559#### `popitem()`15601561Удаляет и возвращает произвольную пару `(key, value)` из словаря.15621563[`popitem()`](https://python-all.ru/3.1/library/stdtypes.html#dict.popitem) удобна для разрушающего перебора словаря, что часто используется в алгоритмах над множествами. Если словарь пуст, вызов [`popitem()`](https://python-all.ru/3.1/library/stdtypes.html#dict.popitem) вызывает [`KeyError`](https://python-all.ru/3.1/library/exceptions.html#KeyError).15641565#### `setdefault(key[, default])`15661567Если15681569*key*15701571есть в словаре, возвращает его значение. Если нет, вставляет15721573*key*15741575со значением15761577*default*15781579и возвращает15801581*default*15821583.15841585*default*15861587по умолчанию равен15881589`None`15901591.15921593#### `update([other])`15941595Обновляет словарь парами ключ/значение из *other*, перезаписывая существующие ключи. Возвращает `None`.15961597[`update()`](https://python-all.ru/3.1/library/stdtypes.html#dict.update) принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (кортежи или другие итерабельные объекты длиной два). Если указаны именованные аргументы, словарь обновляется этими парами ключ/значение: `d.update(red=1, blue=2)`.15981599#### `values()`16001601Возвращает новое представление значений словаря. См. ниже документацию объектов представления.16021603### 5.8.1. Объекты представления словаря16041605Объекты, возвращаемые [`dict.keys()`](https://python-all.ru/3.1/library/stdtypes.html#dict.keys), [`dict.values()`](https://python-all.ru/3.1/library/stdtypes.html#dict.values) и [`dict.items()`](https://python-all.ru/3.1/library/stdtypes.html#dict.items), являются *представлениями*. Они предоставляют динамическое представление содержимого словаря: при изменении словаря представление отражает эти изменения.16061607Представления словаря можно обходить для получения соответствующих данных, а также они поддерживают проверку принадлежности:16081609#### `len(dictview)`16101611Возвращает количество записей в словаре.16121613#### `iter(dictview)`16141615Возвращает итератор по ключам, значениям или элементам (представленным в виде кортежей `(key, value)`) словаря.16161617Ключи и значения итерируются в произвольном порядке, который не является случайным, варьируется в разных реализациях Python и зависит от истории вставок и удалений в словаре. Если представления ключей, значений и элементов итерируются без промежуточных изменений словаря, порядок элементов будет прямо соответствовать друг другу. Это позволяет создавать пары `(value, key)` с помощью [`zip()`](https://python-all.ru/3.1/library/functions.html#zip): `pairs = zip(d.values(), d.keys())`. Другой способ создать тот же список: `pairs = [(v, k) for (k, v) in d.items()]`.16181619Итерация по представлениям во время добавления или удаления записей в словаре может вызвать [`RuntimeError`](https://python-all.ru/3.1/library/exceptions.html#RuntimeError) или не выполнить итерацию по всем записям.16201621#### `x in dictview`16221623Возвращает16241625`True`16261627, если16281629*x*16301631находится среди ключей, значений или элементов базового словаря (в последнем случае16321633*x*16341635должен быть кортежем16361637`(key, value)`16381639).16401641Представления ключей подобны множествам, поскольку их элементы уникальны и хешируемы. Если все значения хешируемы, так что пары `(key, value)` уникальны и хешируемы, то представление элементов также подобно множеству. (Представления значений не рассматриваются как подобные множествам, поскольку их элементы, как правило, не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса [`collections.Set`](https://python-all.ru/3.1/library/collections.html#collections.Set) (например, `==`, `<` или `^`).16421643Пример использования представления словаря:16441645```python1646>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}1647>>> keys = dishes.keys()1648>>> values = dishes.values()16491650>>> # итерация1651>>> n = 01652>>> for val in values:1653...     n += val1654>>> print(n)165550416561657>>> # ключи и значения перебираются в одном и том же порядке1658>>> list(keys)1659['eggs', 'bacon', 'sausage', 'spam']1660>>> list(values)1661[2, 1, 1, 500]16621663>>> # объекты представления динамичны и отражают изменения словаря1664>>> del dishes['eggs']1665>>> del dishes['sausage']1666>>> list(keys)1667['spam', 'bacon']16681669>>> # операции над множествами1670>>> keys & {'eggs', 'bacon', 'salad'}1671{'bacon'}1672>>> keys ^ {'sausage', 'juice'}1673{'juice', 'eggs', 'bacon', 'spam'}1674```16751676## 5.9. Типы memoryview16771678Объекты [`memoryview`](https://python-all.ru/3.1/library/stdtypes.html#memoryview) позволяют коду Python получать доступ к внутренним данным объекта, поддерживающего [*протокол буфера*](https://python-all.ru/3.1/c-api/buffer.html#bufferobjects), без копирования. Память обычно интерпретируется как простые байты.16791680#### `class memoryview(obj)`16811682Создаёт [`memoryview`](https://python-all.ru/3.1/library/stdtypes.html#memoryview), ссылающийся на *obj*. *obj* должен поддерживать протокол буфера. Встроенные объекты, поддерживающие протокол буфера, включают [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.1/library/functions.html#bytearray).16831684[`memoryview`](https://python-all.ru/3.1/library/stdtypes.html#memoryview) имеет понятие *элемента* – атомарной единицы памяти, с которой работает исходный объект *obj*. Для многих простых типов, таких как [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes) и [`bytearray`](https://python-all.ru/3.1/library/functions.html#bytearray), элемент представляет собой один байт, но другие типы, такие как [`array.array`](https://python-all.ru/3.1/library/array.html#array.array), могут иметь элементы большего размера.16851686`len(view)` возвращает общее количество элементов в memoryview, *view*. Атрибут [`itemsize`](https://python-all.ru/3.1/library/stdtypes.html#memoryview.itemsize) выдаёт количество байтов в одном элементе.16871688[`memoryview`](https://python-all.ru/3.1/library/stdtypes.html#memoryview) поддерживает срезы для раскрытия своих данных. Обращение по одному индексу возвращает один элемент в виде объекта [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes). Полный срез даёт подпредставление:16891690```python1691>>> v = memoryview(b'abcefg')1692>>> v[1]1693b'b'1694>>> v[-1]1695b'g'1696>>> v[1:4]1697<memory at 0x77ab28>1698>>> bytes(v[1:4])1699b'bce'1700```17011702Если объект, над которым создано memoryview, допускает изменение своих данных, memoryview поддерживает присваивание срезу:17031704```python1705>>> data = bytearray(b'abcefg')1706>>> v = memoryview(data)1707>>> v.readonly1708False1709>>> v[0] = b'z'1710>>> data1711bytearray(b'zbcefg')1712>>> v[1:4] = b'123'1713>>> data1714bytearray(b'a123fg')1715>>> v[2] = b'spam'1716Traceback (most recent call last):1717File "<stdin>", line 1, in <module>1718ValueError: cannot modify size of memoryview object1719```17201721Обратите внимание, что размер объекта memoryview изменить нельзя.17221723[`memoryview`](https://python-all.ru/3.1/library/stdtypes.html#memoryview) имеет два метода:17241725#### `tobytes()`17261727Возвращает данные в буфере в виде байтовой строки. Это эквивалентно вызову конструктора [`bytes`](https://python-all.ru/3.1/library/functions.html#bytes) для данного представления памяти.17281729```python1730>>> m = memoryview(b"abc")1731>>> m.tobytes()1732b'abc'1733>>> bytes(m)1734b'abc'1735```17361737#### `tolist()`17381739Возвращает данные из буфера в виде списка целых чисел.17401741```python1742>>> memoryview(b'abc').tolist()1743[97, 98, 99]1744```17451746Также доступно несколько атрибутов только для чтения:17471748#### `format`17491750Строка, содержащая формат (в стиле модуля17511752[`struct`](https://python-all.ru/3.1/library/struct.html#module-struct)17531754) для каждого элемента в представлении. По умолчанию это17551756`'B'`17571758, простая байтовая строка.17591760#### `itemsize`17611762Размер в байтах каждого элемента memoryview:17631764```python1765>>> m = memoryview(array.array('H', [1,2,3]))1766>>> m.itemsize176721768>>> m[0]1769b'\x01\x00'1770>>> len(m[0]) == m.itemsize1771True1772```17731774#### `shape`17751776Кортеж целых чисел длиной17771778[`ndim`](https://python-all.ru/3.1/c-api/buffer.html#ndim)17791780, задающий форму памяти как N-мерный массив.17811782#### `ndim`17831784Целое число, указывающее количество измерений многомерного массива, которое представляет данный блок памяти.17851786#### `strides`17871788Кортеж целых чисел длиной17891790[`ndim`](https://python-all.ru/3.1/c-api/buffer.html#ndim)17911792, задающий размер в байтах для доступа к каждому элементу по каждому измерению массива.17931794#### `readonly`17951796Логическое значение bool, указывающее, доступна ли память только для чтения.17971798## 5.10. Типы менеджеров контекста17991800Оператор [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with) в Python поддерживает концепцию контекста выполнения, определяемого менеджером контекста. Это реализовано с помощью пары методов, которые позволяют пользовательским классам определять контекст выполнения, который вводится перед выполнением тела оператора и завершается при окончании оператора:18011802#### `contextmanager.__enter__()`18031804Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, привязывается к идентификатору в предложении [`as`](https://python-all.ru/3.1/reference/compound_stmts.html#as) оператора [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with), использующего данный менеджер контекста.18051806Примером менеджера контекста, который возвращает самого себя, является [*файловый объект*](https://python-all.ru/3.1/glossary.html#term-file-object). Файловые объекты возвращают себя из \_\_enter\_\_(), чтобы позволить [`open()`](https://python-all.ru/3.1/library/functions.html#open) использовать в качестве контекстного выражения в операторе [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with).18071808Примером менеджера контекста, возвращающего связанный объект, является тот, который возвращается [`decimal.localcontext()`](https://python-all.ru/3.1/library/decimal.html#decimal.localcontext). Эти менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста, а затем возвращают копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with), не затрагивая код вне оператора [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with).18091810#### `contextmanager.__exit__(exc_type, exc_val, exc_tb)`18111812Выходит из контекста выполнения и возвращает логический флаг, указывающий, следует ли подавить возникшее исключение. Если во время выполнения тела оператора [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with) произошло исключение, аргументы содержат тип исключения, значение и информацию о трассировке. В противном случае все три аргумента равны `None`.18131814Возврат истинного значения из этого метода заставит оператор [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with) подавить исключение и продолжить выполнение с оператора, следующего непосредственно за оператором [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with). В противном случае исключение продолжает распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, произошедшее в теле оператора [`with`](https://python-all.ru/3.1/reference/compound_stmts.html#with).18151816Переданное исключение никогда не следует явно возбуждать повторно – вместо этого метод должен возвращать ложное значение, показывая, что метод выполнен успешно и не подавляет возникшее исключение. Это позволяет коду управления контекстом (например, `contextlib.nested`) легко определить, завершился ли метод [`__exit__()`](https://python-all.ru/3.1/library/stdtypes.html#contextmanager.__exit__) неудачей.18171818Python определяет несколько менеджеров контекста для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов и более простого управления активным десятичным контекстом. Конкретные типы не обрабатываются особым образом, помимо реализации протокола управления контекстом. См. модуль [`contextlib`](https://python-all.ru/3.1/library/contextlib.html#module-contextlib) для примеров.18191820[*Генераторы*](https://python-all.ru/3.1/glossary.html#term-generator) Python и декоратор [`contextlib.contextmanager`](https://python-all.ru/3.1/library/contextlib.html#contextlib.contextmanager) предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором [`contextlib.contextmanager`](https://python-all.ru/3.1/library/contextlib.html#contextlib.contextmanager), она вернёт менеджер контекста, реализующий необходимые методы [`__enter__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.1/reference/datamodel.html#object.__exit__), а не итератор, создаваемый недекорированной функцией-генератором.18211822Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.18231824## 5.11. Другие встроенные типы18251826Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.18271828### 5.11.1. Модули18291830Единственная специальная операция над модулем – это доступ к атрибуту: `m.name`, где *m* – это модуль, а *name* обращается к имени, определённому в таблице символов *m*. Атрибутам модуля можно присваивать значения. (Обратите внимание, что оператор [`import`](https://python-all.ru/3.1/reference/simple_stmts.html#import), строго говоря, не является операцией над объектом модуля; `import foo` не требует существования объекта модуля с именем *foo*, скорее он требует (внешнего) *определения* для модуля с именем *foo* где-либо.)18311832Особым членом каждого модуля является `__dict__`. Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически изменит таблицу символов модуля, но прямая запись в атрибут `__dict__` невозможна (можно написать `m.__dict__['a'] = 1`, что определяет `m.a` как `1`, но нельзя написать `m.__dict__ = {}`). Изменять `__dict__` напрямую не рекомендуется.18331834Модули, встроенные в интерпретатор, записываются так: `<module 'sys' (built-in)>`. Если загружены из файла, они записываются как `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`.18351836### 5.11.2. Классы и экземпляры классов18371838См. [*Объекты, значения и типы*](https://python-all.ru/3.1/reference/datamodel.html#objects) и [*Определения классов*](https://python-all.ru/3.1/reference/compound_stmts.html#class).18391840### 5.11.3. Функции18411842Объекты функций создаются определениями функций. Единственная операция над объектом функции – это его вызов: `func(argument-list)`.18431844На самом деле существует два вида объектов-функций: встроенные функции и определяемые пользователем функции. Оба поддерживают одну и ту же операцию (вызов функции), но реализация различается, отсюда разные типы объектов.18451846Дополнительную информацию см. в разделе [*Определения функций*](https://python-all.ru/3.1/reference/compound_stmts.html#function).18471848### 5.11.4. Методы18491850Методы – это функции, которые вызываются с использованием точечной нотации. Существует две разновидности: встроенные методы (например, `append()` у списков) и методы экземпляров классов. Встроенные методы описываются вместе с типами, которые их поддерживают.18511852Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, получается специальный объект: объект *связанного метода* (также называемый *методом экземпляра*). При вызове он добавляет аргумент `self` в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: `m.__self__` – это объект, над которым выполняется метод, а `m.__func__` – это функция, реализующая метод. Вызов `m(arg-1, arg-2, ..., arg-n)` полностью эквивалентен вызову `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`.18531854Как и объекты функций, объекты связанных методов поддерживают получение произвольных атрибутов. Однако, поскольку атрибуты метода на самом деле хранятся в базовом объекте функции (`meth.__func__`), установка атрибутов метода для связанных методов запрещена. Попытка установить атрибут метода приводит к возбуждению [`TypeError`](https://python-all.ru/3.1/library/exceptions.html#TypeError). Чтобы установить атрибут метода, необходимо явно задать его на базовом объекте функции:18551856```python1857class C:1858    def method(self):1859        pass18601861c = C()1862c.method.__func__.whoami = 'my name is c'1863```18641865Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.1/reference/datamodel.html#types).18661867### 5.11.5. Объекты кода18681869Объекты кода используются реализацией для представления «псевдокомпилированного» исполняемого кода Python, например, тела функции. Они отличаются от объектов функций тем, что не содержат ссылки на глобальное окружение выполнения. Объекты кода возвращаются встроенной функцией [`compile()`](https://python-all.ru/3.1/library/functions.html#compile) и могут быть извлечены из объектов функций через их атрибут `__code__`. См. также модуль [`code`](https://python-all.ru/3.1/library/code.html#module-code).18701871Объект кода может быть выполнен или вычислен путём передачи его (вместо строки исходного кода) встроенным функциям [`exec()`](https://python-all.ru/3.1/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.1/library/functions.html#eval).18721873Дополнительную информацию см. в разделе [*Стандартная иерархия типов*](https://python-all.ru/3.1/reference/datamodel.html#types).18741875### 5.11.6. Объекты типа18761877Объекты типов представляют различные типы объектов. Тип объекта доступен через встроенную функцию [`type()`](https://python-all.ru/3.1/library/functions.html#type). Над типами не определено специальных операций. Стандартный модуль [`types`](https://python-all.ru/3.1/library/types.html#module-types) определяет имена для всех стандартных встроенных типов.18781879Типы записываются так: `<class 'int'>`.18801881### 5.11.7. Объект None18821883Этот объект возвращается функциями, которые не возвращают значение явно. Он не поддерживает никаких специальных операций. Существует ровно один нулевой объект с именем `None` (встроенное имя).18841885Он записывается как `None`.18861887### 5.11.8. Объект Ellipsis18881889Этот объект обычно используется при срезах (см. [*Slicings*](https://python-all.ru/3.1/reference/expressions.html#slicings)). Он не поддерживает никаких специальных операций. Существует ровно один объект Ellipsis с именем [`Ellipsis`](https://python-all.ru/3.1/library/constants.html#Ellipsis) (встроенное имя).18901891Оно записывается как `Ellipsis` или `...`.18921893### 5.11.9. Булевы значения18941895Булевы значения – это два константных объекта `False` и `True`. Они используются для представления истинностных значений (хотя другие значения также могут считаться ложными или истинными). В числовом контексте (например, при использовании в качестве аргумента арифметической операции) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция [`bool()`](https://python-all.ru/3.1/library/functions.html#bool) может использоваться для преобразования любого значения в булево, если это значение может быть интерпретировано как истинностное (см. раздел Проверка истинности выше).18961897Они записываются как `False` и `True` соответственно.18981899### 5.11.10. Внутренние объекты19001901См. [*Стандартная иерархия типов*](https://python-all.ru/3.1/reference/datamodel.html#types) для получения этой информации. В нем описываются объекты стековых кадров, объекты трассировки и объекты срезов.19021903## 5.12. Специальные атрибуты19041905Реализация добавляет несколько специальных атрибутов только для чтения к некоторым типам объектов, где они уместны. Некоторые из них не возвращаются встроенной функцией [`dir()`](https://python-all.ru/3.1/library/functions.html#dir).19061907#### `object.__dict__`19081909Словарь или другой отображающий объект, используемый для хранения (изменяемых) атрибутов объекта.19101911#### `instance.__class__`19121913Класс, которому принадлежит экземпляр класса.19141915#### `class.__bases__`19161917Кортеж базовых классов объекта класса.19181919#### `class.__name__`19201921Имя класса или типа.19221923Следующие атрибуты поддерживаются только классами [*нового стиля*](https://python-all.ru/3.1/glossary.html#term-new-style-class).19241925#### `class.__mro__`19261927Этот атрибут представляет собой кортеж классов, которые учитываются при поиске базовых классов во время разрешения методов.19281929#### `class.mro()`19301931Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в19321933[`__mro__`](https://python-all.ru/3.1/library/stdtypes.html#class.__mro__)19341935.19361937#### `class.__subclasses__()`19381939Каждый класс нового стиля хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех тех ссылок, которые ещё живы. Пример:19401941```python1942>>> int.__subclasses__()1943[<type 'bool'>]1944```19451946Сноски19471948| [\[1\]](https://python-all.ru/3.1/library/stdtypes.html#id1) | Дополнительную информацию об этих специальных методах можно найти в Справочном руководстве Python ([*Базовая настройка*](https://python-all.ru/3.1/reference/datamodel.html#customization)). |1949| --- | --- |19501951| [\[2\]](https://python-all.ru/3.1/library/stdtypes.html#id2) | Как следствие, список `[1, 2]` считается равным `[1.0, 2.0]`, и аналогично для кортежей. |1952| --- | --- |19531954| [\[3\]](https://python-all.ru/3.1/library/stdtypes.html#id4) | Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов. |1955| --- | --- |19561957| [\[4\]](https://python-all.ru/3.1/library/stdtypes.html#id6) | Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж. |1958| --- | --- |1959