> **Источник:** https://python-all.ru/3.5/library/functions.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 2. Встроенные функции

Интерпретатор Python включает ряд встроенных функций и типов, которые доступны всегда. Они перечислены здесь в алфавитном порядке.

|  |  | Встроенные функции |  |  |
| --- | --- | --- | --- | --- |
| [`abs()`](https://python-all.ru/3.5/library/functions.html#abs) | [`dict()`](https://python-all.ru/3.5/library/functions.html#func-dict) | [`help()`](https://python-all.ru/3.5/library/functions.html#help) | [`min()`](https://python-all.ru/3.5/library/functions.html#min) | [`setattr()`](https://python-all.ru/3.5/library/functions.html#setattr) |
| [`all()`](https://python-all.ru/3.5/library/functions.html#all) | [`dir()`](https://python-all.ru/3.5/library/functions.html#dir) | [`hex()`](https://python-all.ru/3.5/library/functions.html#hex) | [`next()`](https://python-all.ru/3.5/library/functions.html#next) | [`slice()`](https://python-all.ru/3.5/library/functions.html#slice) |
| [`any()`](https://python-all.ru/3.5/library/functions.html#any) | [`divmod()`](https://python-all.ru/3.5/library/functions.html#divmod) | [`id()`](https://python-all.ru/3.5/library/functions.html#id) | [`object()`](https://python-all.ru/3.5/library/functions.html#object) | [`sorted()`](https://python-all.ru/3.5/library/functions.html#sorted) |
| [`ascii()`](https://python-all.ru/3.5/library/functions.html#ascii) | [`enumerate()`](https://python-all.ru/3.5/library/functions.html#enumerate) | [`input()`](https://python-all.ru/3.5/library/functions.html#input) | [`oct()`](https://python-all.ru/3.5/library/functions.html#oct) | [`staticmethod()`](https://python-all.ru/3.5/library/functions.html#staticmethod) |
| [`bin()`](https://python-all.ru/3.5/library/functions.html#bin) | [`eval()`](https://python-all.ru/3.5/library/functions.html#eval) | [`int()`](https://python-all.ru/3.5/library/functions.html#int) | [`open()`](https://python-all.ru/3.5/library/functions.html#open) | [`str()`](https://python-all.ru/3.5/library/functions.html#func-str) |
| [`bool()`](https://python-all.ru/3.5/library/functions.html#bool) | [`exec()`](https://python-all.ru/3.5/library/functions.html#exec) | [`isinstance()`](https://python-all.ru/3.5/library/functions.html#isinstance) | [`ord()`](https://python-all.ru/3.5/library/functions.html#ord) | [`sum()`](https://python-all.ru/3.5/library/functions.html#sum) |
| [`bytearray()`](https://python-all.ru/3.5/library/functions.html#bytearray) | [`filter()`](https://python-all.ru/3.5/library/functions.html#filter) | [`issubclass()`](https://python-all.ru/3.5/library/functions.html#issubclass) | [`pow()`](https://python-all.ru/3.5/library/functions.html#pow) | [`super()`](https://python-all.ru/3.5/library/functions.html#super) |
| [`bytes()`](https://python-all.ru/3.5/library/functions.html#bytes) | [`float()`](https://python-all.ru/3.5/library/functions.html#float) | [`iter()`](https://python-all.ru/3.5/library/functions.html#iter) | [`print()`](https://python-all.ru/3.5/library/functions.html#print) | [`tuple()`](https://python-all.ru/3.5/library/functions.html#func-tuple) |
| [`callable()`](https://python-all.ru/3.5/library/functions.html#callable) | [`format()`](https://python-all.ru/3.5/library/functions.html#format) | [`len()`](https://python-all.ru/3.5/library/functions.html#len) | [`property()`](https://python-all.ru/3.5/library/functions.html#property) | [`type()`](https://python-all.ru/3.5/library/functions.html#type) |
| [`chr()`](https://python-all.ru/3.5/library/functions.html#chr) | [`frozenset()`](https://python-all.ru/3.5/library/functions.html#func-frozenset) | [`list()`](https://python-all.ru/3.5/library/functions.html#func-list) | [`range()`](https://python-all.ru/3.5/library/functions.html#func-range) | [`vars()`](https://python-all.ru/3.5/library/functions.html#vars) |
| [`classmethod()`](https://python-all.ru/3.5/library/functions.html#classmethod) | [`getattr()`](https://python-all.ru/3.5/library/functions.html#getattr) | [`locals()`](https://python-all.ru/3.5/library/functions.html#locals) | [`repr()`](https://python-all.ru/3.5/library/functions.html#repr) | [`zip()`](https://python-all.ru/3.5/library/functions.html#zip) |
| [`compile()`](https://python-all.ru/3.5/library/functions.html#compile) | [`globals()`](https://python-all.ru/3.5/library/functions.html#globals) | [`map()`](https://python-all.ru/3.5/library/functions.html#map) | [`reversed()`](https://python-all.ru/3.5/library/functions.html#reversed) | [`__import__()`](https://python-all.ru/3.5/library/functions.html#__import__) |
| [`complex()`](https://python-all.ru/3.5/library/functions.html#complex) | [`hasattr()`](https://python-all.ru/3.5/library/functions.html#hasattr) | [`max()`](https://python-all.ru/3.5/library/functions.html#max) | [`round()`](https://python-all.ru/3.5/library/functions.html#round) |  |
| [`delattr()`](https://python-all.ru/3.5/library/functions.html#delattr) | [`hash()`](https://python-all.ru/3.5/library/functions.html#hash) | [`memoryview()`](https://python-all.ru/3.5/library/functions.html#func-memoryview) | [`set()`](https://python-all.ru/3.5/library/functions.html#func-set) |  |

#### `abs(x)`

Возвращает абсолютное значение числа. Аргументом может быть целое число или число с плавающей запятой. Если аргументом является комплексное число, возвращается его модуль.

#### `all(iterable)`

Возвращает `True`, если все элементы *iterable* истинны (или если iterable пуст). Эквивалентно:

```python
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
```

#### `any(iterable)`

Возвращает `True`, если хотя бы один элемент *iterable* истинен. Если iterable пуст, возвращает `False`. Эквивалентно:

```python
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
```

#### `ascii(object)`

Как и [`repr()`](https://python-all.ru/3.5/library/functions.html#repr), возвращает строку, содержащую печатное представление объекта, но экранирует не-ASCII символы в строке, возвращаемой [`repr()`](https://python-all.ru/3.5/library/functions.html#repr), с помощью управляющих последовательностей `\x`, `\u` или `\U`. Это генерирует строку, похожую на возвращаемую [`repr()`](https://python-all.ru/3.5/library/functions.html#repr) в Python 2.

#### `bin(x)`

Преобразует целое число в двоичную строку. Результат – корректное выражение Python. Если *x* не является объектом [`int`](https://python-all.ru/3.5/library/functions.html#int) Python, он должен определять метод [`__index__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__index__), возвращающий целое число.

#### `class bool([x])`

Возвращает логическое значение, то есть одно из `True` или `False`. *x* преобразуется с использованием стандартной [процедуры проверки истинности](https://python-all.ru/3.5/library/stdtypes.html#truth). Если *x* равно false или опущено, возвращается `False`; в противном случае возвращается `True`. Класс [`bool`](https://python-all.ru/3.5/library/functions.html#bool) является подклассом [`int`](https://python-all.ru/3.5/library/functions.html#int) (см. [Числовые типы – int, float, complex](https://python-all.ru/3.5/library/stdtypes.html#typesnumeric)). Он не может быть унаследован далее. Его единственными экземплярами являются `False` и `True` (см. [Логические значения](https://python-all.ru/3.5/library/stdtypes.html#bltin-boolean-values)).

#### `class bytearray([source[, encoding[, errors]]])`

Возвращает новый массив байтов. Класс [`bytearray`](https://python-all.ru/3.5/library/functions.html#bytearray) представляет собой изменяемую последовательность целых чисел в диапазоне 0 \<= x \< 256. Он поддерживает большинство обычных методов изменяемых последовательностей, описанных в разделе [Изменяемые типы последовательностей](https://python-all.ru/3.5/library/stdtypes.html#typesseq-mutable), а также большинство методов, которые есть у типа [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes) (см. [Операции с байтами и bytearray](https://python-all.ru/3.5/library/stdtypes.html#bytes-methods)).

Необязательный параметр *source* можно использовать для инициализации массива несколькими разными способами:

- Если это *строка*, необходимо также указать параметры *кодировка* (и, опционально, *ошибки*); затем [`bytearray()`](https://python-all.ru/3.5/library/functions.html#bytearray) преобразует строку в байты с помощью [`str.encode()`](https://python-all.ru/3.5/library/stdtypes.html#str.encode).
- Если это *целое число*, массив будет иметь указанный размер и будет инициализирован нулевыми байтами.
- Если это объект, соответствующий интерфейсу *buffer*, то для инициализации массива bytes будет использоваться буфер этого объекта только для чтения.
- Если это *итерируемый объект*, он должен быть итерируемым объектом, содержащим целые числа в диапазоне `0 <= x < 256`, которые используются в качестве начального содержимого массива.

Без аргументов создаётся массив размера 0.

См. также [Типы бинарных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.5/library/stdtypes.html#binaryseq) и [Объекты bytearray](https://python-all.ru/3.5/library/stdtypes.html#typebytearray).

#### `class bytes([source[, encoding[, errors]]])`

Возвращает новый объект «bytes», который является неизменяемой последовательностью целых чисел в диапазоне `0 <= x < 256`. [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes) – это неизменяемая версия [`bytearray`](https://python-all.ru/3.5/library/functions.html#bytearray) – он имеет те же неизменяющие методы и то же поведение при индексации и срезах.

Соответственно, аргументы конструктора интерпретируются так же, как для [`bytearray()`](https://python-all.ru/3.5/library/functions.html#bytearray).

Объекты bytes также можно создавать с помощью литералов, см. [Литералы строк и bytes](https://python-all.ru/3.5/reference/lexical_analysis.html#strings).

См. также [Типы двоичных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.5/library/stdtypes.html#binaryseq), [Bytes](https://python-all.ru/3.5/library/stdtypes.html#typebytes) и [Операции над bytes и bytearray](https://python-all.ru/3.5/library/stdtypes.html#bytes-methods).

#### `callable(object)`

Возвращает [`True`](https://python-all.ru/3.5/library/constants.html#True), если аргумент *object* является вызываемым, [`False`](https://python-all.ru/3.5/library/constants.html#False) – в противном случае. Если возвращается истина, вызов всё равно может завершиться неудачей, но если возвращается ложь, вызов *object* никогда не завершится успешно. Обратите внимание: классы вызываемы (вызов класса возвращает новый экземпляр); экземпляры вызываемы, если у их класса есть метод [`__call__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__call__).

Новое в версии 3.2: Эта функция была сначала удалена в Python 3.0, а затем снова добавлена в Python 3.2.

#### `chr(i)`

Возвращает строку, представляющую символ, кодовая точка Unicode которого равна целому числу *i*. Например, `chr(97)` возвращает строку `'a'`, а `chr(8364)` возвращает `'€'`. Это обратная операция к [`ord()`](https://python-all.ru/3.5/library/functions.html#ord).

Допустимый диапазон аргумента – от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError) будет возбуждено, если *i* выходит за этот диапазон.

#### `classmethod(function)`

Возвращает метод класса для *функции*.

Метод класса получает класс в качестве неявного первого аргумента, точно так же, как метод экземпляра получает экземпляр. Чтобы объявить метод класса, используйте эту идиому:

```python
class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...
```

Форма `@classmethod` является функцией-[декоратором](https://python-all.ru/3.5/glossary.html#term-decorator) – см. описание определений функций в [Определения функций](https://python-all.ru/3.5/reference/compound_stmts.html#function) для получения дополнительной информации.

Его можно вызывать либо для класса (например, `C.f()`), либо для экземпляра (например, `C().f()`). Экземпляр игнорируется – в расчёт берётся только его класс. Если метод класса вызывается для производного класса, объект производного класса передаётся в качестве неявного первого аргумента.

Методы класса отличаются от статических методов C++ или Java. Если нужны такие, см. [`staticmethod()`](https://python-all.ru/3.5/library/functions.html#staticmethod) в этом разделе.

Дополнительную информацию о методах класса см. в документации по стандартной иерархии типов в [Стандартная иерархия типов](https://python-all.ru/3.5/reference/datamodel.html#types).

#### `compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`

Компилирует *source* в объект кода или AST. Объекты кода могут выполняться с помощью [`exec()`](https://python-all.ru/3.5/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.5/library/functions.html#eval). *source* может быть обычной строкой, строкой байтов или объектом AST. Обратитесь к документации модуля [`ast`](https://python-all.ru/3.5/library/ast.html#module-ast) за информацией о работе с объектами AST.

Аргумент *filename* должен указывать файл, из которого был прочитан код; если код был прочитан не из файла, следует передать какое-либо узнаваемое значение (обычно используется `'<string>'`).

Аргумент *mode* определяет, какой код следует компилировать; он может быть равен `'exec'`, если *source* состоит из последовательности инструкций, `'eval'`, если из одного выражения, или `'single'`, если из одной интерактивной инструкции (в последнем случае будут выведены выражения, которые вычисляются в значение, отличное от `None`).

Необязательные аргументы *flags* и *dont\_inherit* управляют тем, какие операторы future (см. [**PEP 236**](https://python-all.ru/3.5/library/functions.html)) влияют на компиляцию *source*. Если ни один из них не указан (или оба равны нулю), код компилируется с теми операторами future, которые действуют в коде, вызывающем [`compile()`](https://python-all.ru/3.5/library/functions.html#compile). Если аргумент *flags* задан, а *dont\_inherit* – нет (или равен нулю), то операторы future, указанные аргументом *flags*, добавляются к тем, которые использовались бы в любом случае. Если *dont\_inherit* – ненулевое целое число, то используется только аргумент *flags* – операторы future, действующие вокруг вызова compile, игнорируются.

Операторы future задаются битами, которые можно объединять побитовым ИЛИ для указания нескольких операторов. Битовое поле, необходимое для указания конкретной возможности, можно найти как атрибут `compiler_flag` в экземпляре `_Feature` в модуле [`__future__`](https://python-all.ru/3.5/library/__future__.html#module-__future__).

Аргумент *optimize* задаёт уровень оптимизации компилятора; значение по умолчанию `-1` выбирает уровень оптимизации интерпретатора, заданный опциями [`-O`](https://python-all.ru/3.5/using/cmdline.html#cmdoption-o). Явные уровни: `0` (без оптимизации; `__debug__` истинно), `1` (утверждения удалены, `__debug__` ложно) или `2` (строки документации также удалены).

Эта функция возбуждает [`SyntaxError`](https://python-all.ru/3.5/library/exceptions.html#SyntaxError), если скомпилированный исходный код некорректен, и [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError), если исходный код содержит нулевые байты.

Если требуется разобрать код Python в его AST-представление, см. [`ast.parse()`](https://python-all.ru/3.5/library/ast.html#ast.parse).

> **Примечание**
>
> При компиляции строки с многострочным кодом в режиме `'single'` или `'eval'` входные данные должны завершаться как минимум одним символом новой строки. Это необходимо для облегчения определения незавершённых и завершённых инструкций в модуле [`code`](https://python-all.ru/3.5/library/code.html#module-code).

Изменено в версии 3.2: Разрешено использование символов новой строки Windows и Mac. Также ввод в режиме `'exec'` больше не должен заканчиваться символом новой строки. Добавлен параметр *optimize*.

Изменено в версии 3.5: Ранее возбуждалось исключение [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError), когда в *source* встречались нулевые байты.

#### `class complex([real[, imag]])`

Возвращает комплексное число со значением *real* + *imag*\*1j или преобразует строку или число в комплексное число. Если первый параметр – строка, она интерпретируется как комплексное число, и функция должна вызываться без второго параметра. Второй параметр не может быть строкой. Каждый аргумент может иметь любой числовой тип (включая комплексный). Если *imag* опущен, по умолчанию он равен нулю, и конструктор работает как числовое преобразование, аналогично [`int`](https://python-all.ru/3.5/library/functions.html#int) и [`float`](https://python-all.ru/3.5/library/functions.html#float). Если оба аргумента опущены, возвращается `0j`.

> **Примечание**
>
> При преобразовании из строки вокруг центрального оператора `+` или `-` не должно быть пробелов. Например, `complex('1+2j')` корректно, а `complex('1 + 2j')` вызывает [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError).

Тип complex описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.5/library/stdtypes.html#typesnumeric).

#### `delattr(object, name)`

Это родственная функция для [`setattr()`](https://python-all.ru/3.5/library/functions.html#setattr). Аргументами являются объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет указанный атрибут, если объект это позволяет. Например, `delattr(x, 'foobar')` эквивалентно `del x.foobar`.

#### `class dict(**kwarg)`

#### `class dict(mapping, **kwarg)`

#### `class dict(iterable, **kwarg)`

Создаёт новый словарь. Объект [`dict`](https://python-all.ru/3.5/library/stdtypes.html#dict) – это класс словаря. Документацию по этому классу см. в [`dict`](https://python-all.ru/3.5/library/stdtypes.html#dict) и [Типы отображений – dict](https://python-all.ru/3.5/library/stdtypes.html#typesmapping).

О других контейнерах см. встроенные классы [`list`](https://python-all.ru/3.5/library/stdtypes.html#list), [`set`](https://python-all.ru/3.5/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.5/library/stdtypes.html#tuple), а также модуль [`collections`](https://python-all.ru/3.5/library/collections.html#module-collections).

#### `dir([object])`

Без аргументов возвращает список имён в текущей локальной области видимости. Если передан аргумент, пытается вернуть список допустимых атрибутов этого объекта.

Если у объекта есть метод с именем [`__dir__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__dir__), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, реализующим собственную функцию [`__getattr__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getattr__) или [`__getattribute__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getattribute__), настраивать способ, которым [`dir()`](https://python-all.ru/3.5/library/functions.html#dir) сообщает их атрибуты.

Если объект не предоставляет [`__dir__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__dir__), функция старается собрать информацию из атрибута [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__) объекта, если он определён, и из объекта его типа. Полученный список не обязательно полный и может быть неточным, если объект имеет пользовательский [`__getattr__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getattr__).

Механизм [`dir()`](https://python-all.ru/3.5/library/functions.html#dir) по умолчанию ведёт себя по-разному для разных типов объектов, поскольку он пытается выдать наиболее релевантную, а не полную информацию:

- Если объект является модулем, список содержит имена атрибутов этого модуля.
- Если объект является типом или классом, список содержит имена его атрибутов, а также (рекурсивно) атрибутов его базовых классов.
- В остальных случаях список содержит имена атрибутов объекта, имена атрибутов его класса и (рекурсивно) атрибутов базовых классов его класса.

Полученный список сортируется по алфавиту. Например:

```python
>>> import struct
>>> dir()   # показать имена в пространстве имён модуля
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct # doctest: +SKIP
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']
```

> **Примечание**
>
> Поскольку [`dir()`](https://python-all.ru/3.5/library/functions.html#dir) предоставляется в первую очередь для удобства использования в интерактивной оболочке, он старается выдать интересный набор имён скорее, чем строго или последовательно определённый, и его детальное поведение может меняться от версии к версии. Например, атрибуты метакласса не входят в результирующий список, когда аргументом является класс.

#### `divmod(a, b)`

Принимает два (не комплексных) числа в качестве аргументов и возвращает пару чисел, состоящую из их частного и остатка при целочисленном делении. Для смешанных типов операндов применяются правила бинарных арифметических операторов. Для целых чисел результат такой же, как `(a // b, a % b)`. Для чисел с плавающей запятой результат равен `(q, a % b)`, где *q* обычно равно `math.floor(a / b)`, но может быть на 1 меньше. В любом случае `q * b + a % b` очень близко к *a*; если `a % b` не равно нулю, оно имеет тот же знак, что и *b*, и `0 <= abs(a % b) < abs(b)`.

#### `enumerate(iterable, start=0)`

Возвращает объект enumerate. *iterable* должен быть последовательностью, [итератором](https://python-all.ru/3.5/glossary.html#term-iterator) или другим объектом, поддерживающим итерацию. Метод [`__next__()`](https://python-all.ru/3.5/library/stdtypes.html#iterator.__next__) итератора, возвращаемого[`enumerate()`](https://python-all.ru/3.5/library/functions.html#enumerate), возвращает кортеж, содержащий счётчик (начиная с *start*, который по умолчанию равен 0) и значения, полученные при итерации по *iterable*.

```python
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
```

Эквивалентно следующему:

```python
def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1
```

#### `eval(expression, globals=None, locals=None)`

Аргументами являются строка и необязательные globals и locals. Если они указаны, *globals* должен быть словарём. Если указаны, *locals* может быть любым отображением (mapping).

Аргумент *expression* разбирается и вычисляется как выражение Python (технически говоря, список условий) с использованием словарей *globals* и *locals* в качестве глобального и локального пространств имён. Если словарь *globals* присутствует, но в нём нет '\_\_builtins\_\_', текущие глобальные переменные копируются в *globals* перед разбором *expression*. Это означает, что *expression* обычно имеет полный доступ к стандартному модулю [`builtins`](https://python-all.ru/3.5/library/builtins.html#module-builtins), и ограниченные окружения распространяются. Если словарь *locals* опущен, по умолчанию используется словарь *globals*. Если опущены оба словаря, выражение выполняется в окружении, где вызывается [`eval()`](https://python-all.ru/3.5/library/functions.html#eval). Возвращаемое значение – результат вычисленного выражения. Синтаксические ошибки сообщаются как исключения. Пример:

```python
>>> x = 1
>>> eval('x+1')
2
```

Эту функцию также можно использовать для выполнения произвольных объектов кода (например, созданных с помощью [`compile()`](https://python-all.ru/3.5/library/functions.html#compile)). В этом случае вместо строки передаётся объект кода. Если объект кода был скомпилирован с `'exec'` в качестве аргумента *mode*, то возвращаемое значение [`eval()`](https://python-all.ru/3.5/library/functions.html#eval) будет `None`.

Подсказки: динамическое выполнение инструкций поддерживается функцией [`exec()`](https://python-all.ru/3.5/library/functions.html#exec). Функции [`globals()`](https://python-all.ru/3.5/library/functions.html#globals) и [`locals()`](https://python-all.ru/3.5/library/functions.html#locals) возвращают текущий глобальный и локальный словари соответственно, что может быть полезно для передачи в [`eval()`](https://python-all.ru/3.5/library/functions.html#eval) или [`exec()`](https://python-all.ru/3.5/library/functions.html#exec).

См. [`ast.literal_eval()`](https://python-all.ru/3.5/library/ast.html#ast.literal_eval): функция, которая может безопасно вычислять строки с выражениями, содержащими только литералы.

#### `exec(object[, globals[, locals]])`

Эта функция поддерживает динамическое выполнение кода Python. *object* должен быть строкой или объектом кода. Если это строка, она разбирается как набор инструкций Python, которые затем выполняются (если не возникает синтаксическая ошибка). [\[1\]](https://python-all.ru/3.5/library/functions.html#id2) Если это объект кода, он просто выполняется. В любом случае ожидается, что выполняемый код будет допустимым в качестве файлового ввода (см. раздел «Файловый ввод» в справочном руководстве). Помните, что инструкции [`return`](https://python-all.ru/3.5/reference/simple_stmts.html#return) и [`yield`](https://python-all.ru/3.5/reference/simple_stmts.html#yield) не могут использоваться вне определений функций, даже в контексте кода, переданного функции [`exec()`](https://python-all.ru/3.5/library/functions.html#exec). Возвращаемое значение – `None`.

Во всех случаях, если необязательные части опущены, код выполняется в текущей области видимости. Если указан только *globals*, он должен быть словарём, который будет использоваться как для глобальных, так и для локальных переменных. Если указаны *globals* и *locals*, они используются для глобальных и локальных переменных соответственно. Если указан, *locals* может быть любым отображающим объектом. Помните, что на уровне модуля globals и locals – один и тот же словарь. Если exec получает два отдельных объекта в качестве *globals* и *locals*, код будет выполняться так, как если бы он был встроен в определение класса.

Если словарь *globals* не содержит значение для ключа `__builtins__`, под этот ключ вставляется ссылка на словарь встроенного модуля [`builtins`](https://python-all.ru/3.5/library/builtins.html#module-builtins). Таким образом можно контролировать, какие встроенные объекты доступны выполняемому коду, вставив собственный словарь `__builtins__` в *globals* перед передачей его в [`exec()`](https://python-all.ru/3.5/library/functions.html#exec).

> **Примечание**
>
> Встроенные функции [`globals()`](https://python-all.ru/3.5/library/functions.html#globals) и [`locals()`](https://python-all.ru/3.5/library/functions.html#locals) возвращают текущий глобальный и локальный словарь соответственно, что может быть полезно для передачи в качестве второго и третьего аргумента в [`exec()`](https://python-all.ru/3.5/library/functions.html#exec).

> **Примечание**
>
> Словарь *locals* по умолчанию действует так, как описано для функции [`locals()`](https://python-all.ru/3.5/library/functions.html#locals) ниже: не следует пытаться изменять словарь *locals* по умолчанию. Передайте явный словарь *locals*, если нужно увидеть влияние кода на *locals* после возврата из функции [`exec()`](https://python-all.ru/3.5/library/functions.html#exec).

#### `filter(function, iterable)`

Создает итератор из тех элементов *итерируемого объекта*, для которых *функция* возвращает истину. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *функция* равна `None`, подразумевается тождественная функция, то есть удаляются все элементы *итерируемого объекта*, которые являются ложными.

Обратите внимание: `filter(function, iterable)` эквивалентно генераторному выражению `(item for item in iterable if function(item))`, если function не равна `None`, и `(item for item in iterable if item)`, если function равна `None`.

См. [`itertools.filterfalse()`](https://python-all.ru/3.5/library/itertools.html#itertools.filterfalse) для дополнительной функции, которая возвращает элементы *итерируемого объекта*, для которых *функция* возвращает ложь.

#### `class float([x])`

Возвращает число с плавающей запятой, построенное из числа или строки *x*.

Если аргумент является строкой, она должна содержать десятичное число, которое может предваряться знаком и может быть окружено пробелами. Необязательный знак может быть `'+'` или `'-'`; знак `'+'` не влияет на результирующее значение. Аргумент также может быть строкой, представляющей NaN (не число), или положительную или отрицательную бесконечность. Более точно, входная строка должна соответствовать следующей грамматике после удаления начальных и конечных пробельных символов:

```

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value
```

Здесь `floatnumber` – это форма литерала с плавающей точкой Python, описанная в [Литералы с плавающей точкой](https://python-all.ru/3.5/reference/lexical_analysis.html#floating). Регистр не имеет значения, так что, например, «inf», «Inf», «INFINITY» и «iNfINity» – все допустимые варианты написания положительной бесконечности.

В противном случае, если аргумент – целое число или число с плавающей запятой, возвращается число с плавающей запятой с тем же значением (в пределах точности чисел с плавающей запятой Python). Если аргумент выходит за диапазон числа float в Python, будет возбуждено исключение [`OverflowError`](https://python-all.ru/3.5/library/exceptions.html#OverflowError).

Для произвольного объекта Python `x` функция `float(x)` делегирует выполнение `x.__float__()`.

Если аргумент не указан, возвращается `0.0`.

Примеры:

```python
>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf
```

Тип float описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.5/library/stdtypes.html#typesnumeric).

#### `format(value[, format_spec])`

Преобразует *значение* в «форматированное» представление, управляемое *спецификацией формата*. Интерпретация *спецификации формата* зависит от типа аргумента *значение*, однако существует стандартный синтаксис форматирования, используемый большинством встроенных типов: [Мини-язык спецификации формата](https://python-all.ru/3.5/library/string.html#formatspec).

Значение *format\_spec* по умолчанию – пустая строка, что обычно даёт тот же эффект, что и вызов [`str(value)`](https://python-all.ru/3.5/library/stdtypes.html#str).

Вызов `format(value, format_spec)` преобразуется в `type(value).__format__(value, format_spec)`, который обходит словарь экземпляра при поиске метода [`__format__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__format__) значения. Исключение [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError) возникает, если поиск метода доходит до [`object`](https://python-all.ru/3.5/library/functions.html#object) и *format\_spec* не пуста, или если *format\_spec* или возвращаемое значение не являются строками.

Изменено в версии 3.4: `object().__format__(format_spec)` вызывает [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError), если *format\_spec* не является пустой строкой.

#### `class frozenset([iterable])`

Возвращает новый объект [`frozenset`](https://python-all.ru/3.5/library/stdtypes.html#frozenset), опционально с элементами, взятыми из *итерируемого объекта*. `frozenset` – это встроенный класс. См. [`frozenset`](https://python-all.ru/3.5/library/stdtypes.html#frozenset) и [Типы множеств – set, frozenset](https://python-all.ru/3.5/library/stdtypes.html#types-set) для документации об этом классе.

Для других контейнеров см. встроенные классы [`set`](https://python-all.ru/3.5/library/stdtypes.html#set), [`list`](https://python-all.ru/3.5/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.5/library/stdtypes.html#tuple) и [`dict`](https://python-all.ru/3.5/library/stdtypes.html#dict), а также модуль [`collections`](https://python-all.ru/3.5/library/collections.html#module-collections).

#### `getattr(object, name[, default])`

Возвращает значение именованного атрибута объекта *object*. *name* должен быть строкой. Если эта строка является именем одного из атрибутов объекта, результатом будет значение этого атрибута. Например, `getattr(x, 'foobar')` эквивалентно `x.foobar`. Если именованный атрибут не существует, возвращается *значение по умолчанию*, если оно предоставлено, в противном случае возбуждается [`AttributeError`](https://python-all.ru/3.5/library/exceptions.html#AttributeError).

#### `globals()`

Возвращает словарь, представляющий текущую таблицу глобальных символов. Это всегда словарь текущего модуля (внутри функции или метода это модуль, где она определена, а не модуль, из которого она вызывается).

#### `hasattr(object, name)`

Аргументами являются объект и строка. Результат равен `True`, если строка является именем одного из атрибутов объекта, и `False` в противном случае. (Реализовано вызовом `getattr(object, name)` и проверкой, вызывает ли он исключение [`AttributeError`](https://python-all.ru/3.5/library/exceptions.html#AttributeError) или нет.)

#### `hash(object)`

> Возвращает хеш-значение объекта (если оно есть). Хеш-значения – целые числа. Они используются для быстрого сравнения ключей словаря при поиске. Числовые значения, равные при сравнении, имеют одинаковое хеш-значение (даже если они разных типов, как в случае 1 и 1.0).

> **Примечание**
>
> Для объектов с пользовательскими методами [`__hash__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__hash__), обратите внимание, что [`hash()`](https://python-all.ru/3.5/library/functions.html#hash) усекает возвращаемое значение на основе разрядности хост-машины. См. [`__hash__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__hash__) для подробностей.

#### `help([object])`

Запускает встроенную справочную систему. (Эта функция предназначена для интерактивного использования.) Если аргумент не указан, интерактивная справочная система запускается на консоли интерпретатора. Если аргумент – строка, то она ищется как имя модуля, функции, класса, метода, ключевого слова или темы документации, и на консоль выводится страница справки. Если аргумент – объект любого другого типа, генерируется страница справки по этому объекту.

Эта функция добавляется во встроенное пространство имен модулем [`site`](https://python-all.ru/3.5/library/site.html#module-site).

Изменено в версии 3.4: Изменения в [`pydoc`](https://python-all.ru/3.5/library/pydoc.html#module-pydoc) и [`inspect`](https://python-all.ru/3.5/library/inspect.html#module-inspect) привели к тому, что сообщаемые сигнатуры для вызываемых объектов стали более полными и согласованными.

#### `hex(x)`

Преобразует целое число в шестнадцатеричную строку в нижнем регистре с префиксом «0x», например:

```python
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
```

Если x не является объектом [`int`](https://python-all.ru/3.5/library/functions.html#int) Python, он должен определять метод \_\_index\_\_(), возвращающий целое число.

См. также [`int()`](https://python-all.ru/3.5/library/functions.html#int) для преобразования шестнадцатеричной строки в целое число с основанием 16.

> **Примечание**
>
> Чтобы получить шестнадцатеричное строковое представление числа с плавающей точкой, используйте метод [`float.hex()`](https://python-all.ru/3.5/library/stdtypes.html#float.hex).

#### `id(object)`

Возвращает «идентификатор» объекта. Это целое число, которое гарантированно будет уникальным и постоянным для данного объекта на протяжении его времени жизни. Два объекта с непересекающимся временем жизни могут иметь одинаковое значение [`id()`](https://python-all.ru/3.5/library/functions.html#id).

**Особенность реализации CPython:** Это адрес объекта в памяти.

#### `input([prompt])`

Если аргумент *prompt* присутствует, он выводится в стандартный вывод без символа новой строки. Затем функция читает строку из ввода, преобразует её в строку (удаляя конечный символ новой строки) и возвращает её. Когда достигнут конец файла, возбуждается [`EOFError`](https://python-all.ru/3.5/library/exceptions.html#EOFError). Пример:

```python
>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"
```

Если модуль [`readline`](https://python-all.ru/3.5/library/readline.html#module-readline) был загружен, то [`input()`](https://python-all.ru/3.5/library/functions.html#input) будет использовать его для предоставления расширенных возможностей редактирования строки и истории команд.

#### `class int(x=0)`

#### `class int(x, base=10)`

Возвращает целое число, построенное из числа или строки *x*, или возвращает `0`, если аргументы не переданы. Если *x* является числом, возвращается [`x.__int__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__int__). Для чисел с плавающей запятой производится усечение в сторону нуля.

Если *x* не является числом или если задан *base*, то *x* должен быть строкой, [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes) или экземпляром [`bytearray`](https://python-all.ru/3.5/library/functions.html#bytearray), представляющим [целочисленный литерал](https://python-all.ru/3.5/reference/lexical_analysis.html#integers) в системе счисления *base*. При необходимости литерал может предваряться `+` или `-` (без пробела) и быть окружен пробелами. Литерал в системе счисления n состоит из цифр от 0 до n-1, где `a` до `z` (или `A` до `Z`) имеют значения от 10 до 35. Значение по умолчанию *base* равно 10. Допустимые значения: 0 и 2–36. Литералы с основанием 2, 8 и 16 могут опционально начинаться с `0b`/`0B`, `0o`/`0O` или `0x`/`0X`, как и целочисленные литералы в коде. Основание 0 означает точную интерпретацию как литерала в коде, так что фактическое основание может быть 2, 8, 10 или 16, и поэтому `int('010', 0)` недопустимо, тогда как `int('010')` допустимо, равно как и `int('010', 8)`.

Целочисленный тип описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.5/library/stdtypes.html#typesnumeric).

Изменено в версии 3.4: Если *base* не является экземпляром [`int`](https://python-all.ru/3.5/library/functions.html#int) и объект *base* имеет метод [`base.__index__`](https://python-all.ru/3.5/reference/datamodel.html#object.__index__), то вызывается этот метод для получения целого числа для основания. В предыдущих версиях использовался [`base.__int__`](https://python-all.ru/3.5/reference/datamodel.html#object.__int__) вместо [`base.__index__`](https://python-all.ru/3.5/reference/datamodel.html#object.__index__).

#### `isinstance(object, classinfo)`

Возвращает истину, если аргумент *object* является экземпляром аргумента *classinfo*, или его (прямого, косвенного или [виртуального](https://python-all.ru/3.5/glossary.html#term-abstract-base-class)) подкласса. Если *object* не является объектом указанного типа, функция всегда возвращает ложь. Если *classinfo* является кортежем объектов типа (или рекурсивно других таких кортежей), возвращает истину, если *object* является экземпляром любого из типов. Если *classinfo* не является типом, кортежем типов или таких кортежей, возбуждается исключение [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError).

#### `issubclass(class, classinfo)`

Возвращает истину, если *class* является подклассом (прямым, косвенным или [виртуальным](https://python-all.ru/3.5/glossary.html#term-abstract-base-class)) *classinfo*. Класс считается подклассом самого себя. *classinfo* может быть кортежем объектов классов, и в этом случае проверяется каждый элемент *classinfo*. В любом другом случае возбуждается исключение [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError).

#### `iter(object[, sentinel])`

Возвращает объект [итератор](https://python-all.ru/3.5/glossary.html#term-iterator). Первый аргумент интерпретируется совершенно по-разному в зависимости от наличия второго аргумента. Без второго аргумента *object* должен быть объектом коллекции, поддерживающим протокол итерации (метод [`__iter__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__iter__)) или протокол последовательности (метод [`__getitem__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getitem__) с целочисленными аргументами, начиная с `0`). Если он не поддерживает ни один из этих протоколов, возбуждается [`TypeError`](https://python-all.ru/3.5/library/exceptions.html#TypeError). Если задан второй аргумент, *страж*, то *object* должен быть вызываемым объектом. Созданный в этом случае итератор будет вызывать *object* без аргументов при каждом вызове своего метода [`__next__()`](https://python-all.ru/3.5/library/stdtypes.html#iterator.__next__); если возвращённое значение равно *страж*, возбуждается [`StopIteration`](https://python-all.ru/3.5/library/exceptions.html#StopIteration), в противном случае значение возвращается.

См. также [Типы итераторов](https://python-all.ru/3.5/library/stdtypes.html#typeiter).

Одно из полезных применений второй формы [`iter()`](https://python-all.ru/3.5/library/functions.html#iter) – чтение строк файла до тех пор, пока не будет достигнута определённая строка. В следующем примере файл читается до тех пор, пока метод [`readline()`](https://python-all.ru/3.5/library/io.html#io.TextIOBase.readline) не вернёт пустую строку:

```python
with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)
```

#### `len(s)`

Возвращает длину (количество элементов) объекта. Аргументом может быть последовательность (например, строка, байты, кортеж, список или диапазон) или коллекция (например, словарь, множество или замороженное множество).

#### `class list([iterable])`

Вместо того чтобы быть функцией, [`list`](https://python-all.ru/3.5/library/stdtypes.html#list) на самом деле является изменяемым типом последовательности, как описано в [Списки](https://python-all.ru/3.5/library/stdtypes.html#typesseq-list) и [Типы последовательностей – list, tuple, range](https://python-all.ru/3.5/library/stdtypes.html#typesseq).

#### `locals()`

Обновляет и возвращает словарь, представляющий текущую таблицу локальных символов. Свободные переменные возвращаются [`locals()`](https://python-all.ru/3.5/library/functions.html#locals) при вызове в блоках функций, но не в блоках классов.

> **Примечание**
>
> Содержимое этого словаря не следует изменять; изменения могут не повлиять на значения локальных и свободных переменных, используемых интерпретатором.

#### `map(function, iterable, ...)`

Возвращает итератор, который применяет *function* к каждому элементу *iterable* и возвращает результаты. Если переданы дополнительные аргументы *iterable*, *function* должна принимать столько же аргументов и применяется к элементам из всех итерируемых параллельно. При нескольких итерируемых итератор останавливается, когда завершается самый короткий. Для случаев, когда входные данные функции уже упакованы в кортежи аргументов, см. [`itertools.starmap()`](https://python-all.ru/3.5/library/itertools.html#itertools.starmap).

#### `max(iterable, *[, key, default])`

#### `max(arg1, arg2, *args[, key])`

Возвращает наибольший элемент итерируемого объекта или наибольший из двух или более аргументов.

Если указан один позиционный аргумент, он должен быть [итерируемым объектом](https://python-all.ru/3.5/glossary.html#term-iterable). Возвращается наибольший элемент итерируемого объекта. Если указано два или более позиционных аргумента, возвращается наибольший из них.

Есть два необязательных аргумента, передаваемых только по ключу. Аргумент *key* задаёт функцию упорядочения с одним аргументом, подобно тому, как это делается для [`list.sort()`](https://python-all.ru/3.5/library/stdtypes.html#list.sort). Аргумент *default* задаёт объект, возвращаемый, если переданный итерируемый объект пуст. Если итерация пуста и *default* не указан, возбуждается [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError).

Если несколько элементов являются максимальными, функция возвращает первый встреченный. Это согласуется с другими инструментами, сохраняющими стабильность сортировки, такими как `sorted(iterable, key=keyfunc, reverse=True)[0]` и `heapq.nlargest(1, iterable, key=keyfunc)`.

Новое в версии 3.4: Аргумент *default*, указываемый только по ключевому слову.

#### `memoryview(obj)`

Возвращает объект «представление памяти» (memory view), созданный из переданного аргумента. Дополнительную информацию см. в [Memory Views](https://python-all.ru/3.5/library/stdtypes.html#typememoryview).

#### `min(iterable, *[, key, default])`

#### `min(arg1, arg2, *args[, key])`

Возвращает наименьший элемент итерируемого объекта или наименьший из двух или более аргументов.

Если указан один позиционный аргумент, он должен быть [итерируемым объектом](https://python-all.ru/3.5/glossary.html#term-iterable). Возвращается наименьший элемент итерируемого объекта. Если указано два или более позиционных аргумента, возвращается наименьший из них.

Есть два необязательных аргумента, передаваемых только по ключу. Аргумент *key* задаёт функцию упорядочения с одним аргументом, подобно тому, как это делается для [`list.sort()`](https://python-all.ru/3.5/library/stdtypes.html#list.sort). Аргумент *default* задаёт объект, возвращаемый, если переданный итерируемый объект пуст. Если итерация пуста и *default* не указан, возбуждается [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError).

Если несколько элементов являются минимальными, функция возвращает первый из них. Это согласуется с другими инструментами, сохраняющими устойчивость сортировки, такими как `sorted(iterable, key=keyfunc)[0]` и `heapq.nsmallest(1, iterable, key=keyfunc)`.

Новое в версии 3.4: Аргумент *default*, указываемый только по ключевому слову.

#### `next(iterator[, default])`

Извлекает следующий элемент из *итератора*, вызывая его метод [`__next__()`](https://python-all.ru/3.5/library/stdtypes.html#iterator.__next__). Если указан *default*, он возвращается, когда итератор исчерпан, в противном случае возбуждается [`StopIteration`](https://python-all.ru/3.5/library/exceptions.html#StopIteration).

#### `class object`

Возвращает новый пустой объект. [`object`](https://python-all.ru/3.5/library/functions.html#object) – базовый класс для всех классов. Он содержит методы, общие для всех экземпляров классов Python. Эта функция не принимает аргументов.

> **Примечание**
>
> [`object`](https://python-all.ru/3.5/library/functions.html#object) *не* имеет [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__), поэтому нельзя присваивать произвольные атрибуты экземпляру класса [`object`](https://python-all.ru/3.5/library/functions.html#object).

#### `oct(x)`

Преобразует целое число в восьмеричную строку. Результат – корректное выражение Python. Если *x* не является объектом [`int`](https://python-all.ru/3.5/library/functions.html#int) Python, он должен определять метод [`__index__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__index__), возвращающий целое число.

#### `open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`

Открывает *file* и возвращает соответствующий [файловый объект](https://python-all.ru/3.5/glossary.html#term-file-object). Если файл не может быть открыт, возбуждается [`OSError`](https://python-all.ru/3.5/library/exceptions.html#OSError).

*file* – это либо строка, либо объект bytes, задающий путь к файлу (абсолютный или относительный относительно текущего рабочего каталога), либо целочисленный файловый дескриптор файла, который нужно обернуть. (Если передан файловый дескриптор, он закрывается при закрытии возвращаемого объекта ввода-вывода, если только *closefd* не установлен в `False`.)

*mode* – необязательная строка, задающая режим открытия файла. По умолчанию используется `'r'`, что означает открытие для чтения в текстовом режиме. Другие распространённые значения: `'w'` для записи (с усечением файла, если он уже существует), `'x'` для исключительного создания и `'a'` для дозаписи (что в *некоторых* Unix-системах означает, что *все* операции записи добавляются в конец файла независимо от текущей позиции указателя). В текстовом режиме, если *encoding* не указан, используется кодировка, зависящая от платформы: `locale.getpreferredencoding(False)` вызывается для получения текущей кодировки локали. (Для чтения и записи сырых байтов используйте двоичный режим и оставьте *encoding* неопределённым.) Доступные режимы:

| Символ | Значение |
| --- | --- |
| `'r'` | открытие для чтения (по умолчанию) |
| `'w'` | открытие для записи, с предварительным усечением файла |
| `'x'` | открытие для эксклюзивного создания, завершается ошибкой, если файл уже существует |
| `'a'` | открытие для записи, дозапись в конец файла, если он существует |
| `'b'` | двоичный режим |
| `'t'` | текстовый режим (по умолчанию) |
| `'+'` | открывает дисковый файл для обновления (чтения и записи) |
| `'U'` | [универсальные новые строки](https://python-all.ru/3.5/glossary.html#term-universal-newlines) режим (устарело) |

Режим по умолчанию – `'r'` (открытие для чтения текста, синоним `'rt'`). Для двоичного доступа на чтение и запись режим `'w+b'` открывает и усекает файл до 0 байт. `'r+b'` открывает файл без усечения.

Как упоминалось в [Обзоре](https://python-all.ru/3.5/library/io.html#io-overview), Python различает двоичный и текстовый ввод-вывод. Файлы, открытые в двоичном режиме (включая `'b'` в аргументе *mode*), возвращают содержимое в виде объектов [`bytes`](https://python-all.ru/3.5/library/functions.html#bytes) без какого-либо декодирования. В текстовом режиме (по умолчанию или когда `'t'` включён в аргумент *mode*) содержимое файла возвращается как [`str`](https://python-all.ru/3.5/library/stdtypes.html#str), при этом байты предварительно декодируются с использованием кодировки, зависящей от платформы, или указанной *encoding*, если она задана.

> **Примечание**
>
> Python не зависит от представления текстовых файлов в базовой операционной системе; вся обработка выполняется самим Python и, следовательно, не зависит от платформы.

*buffering* – необязательное целое число, используемое для задания политики буферизации. Передайте 0, чтобы отключить буферизацию (допустимо только в двоичном режиме), 1 – для построчной буферизации (работает только в текстовом режиме), и целое число больше 1 – для указания размера буфера фиксированными блоками в байтах. Если аргумент *buffering* не задан, политика буферизации по умолчанию работает следующим образом:

- Двоичные файлы буферизируются блоками фиксированного размера; размер буфера выбирается эвристически, пытаясь определить «размер блока» нижележащего устройства, и при неудаче используется [`io.DEFAULT_BUFFER_SIZE`](https://python-all.ru/3.5/library/io.html#io.DEFAULT_BUFFER_SIZE). Во многих системах размер буфера обычно составляет 4096 или 8192 байта.
- «Интерактивные» текстовые файлы (файлы, для которых [`isatty()`](https://python-all.ru/3.5/library/io.html#io.IOBase.isatty) возвращает `True`) используют построчную буферизацию. Остальные текстовые файлы используют политику, описанную выше для двоичных файлов.

*encoding* – имя кодировки, используемой для декодирования или кодирования файла. Это следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы (то, что возвращает [`locale.getpreferredencoding()`](https://python-all.ru/3.5/library/locale.html#locale.getpreferredencoding)), но может использоваться любая [текстовая кодировка](https://python-all.ru/3.5/glossary.html#term-text-encoding), поддерживаемая Python. См. модуль [`codecs`](https://python-all.ru/3.5/library/codecs.html#module-codecs) для списка поддерживаемых кодировок.

*errors* – необязательная строка, определяющая, как обрабатывать ошибки кодирования и декодирования; этот параметр нельзя использовать в двоичном режиме. Доступны различные стандартные обработчики ошибок (перечислены в разделе [Обработчики ошибок](https://python-all.ru/3.5/library/codecs.html#error-handlers)), однако также подходит любое имя обработчика, зарегистрированное с помощью [`codecs.register_error()`](https://python-all.ru/3.5/library/codecs.html#codecs.register_error). Стандартные имена включают:

- `'strict'` – возбуждать исключение [`ValueError`](https://python-all.ru/3.5/library/exceptions.html#ValueError) при ошибке кодирования. Значение по умолчанию `None` имеет тот же эффект.
- `'ignore'` – игнорировать ошибки. Учтите, что игнорирование ошибок кодирования может привести к потере данных.
- `'replace'` – вставляет заменяющий символ (например, `'?'`) в местах повреждённых данных.
- `'surrogateescape'` будет представлять любые некорректные байты как кодовые точки в Unicode Private Use Area в диапазоне от U+DC80 до U+DCFF. Затем эти частные кодовые точки будут преобразованы обратно в те же байты при использовании обработчика ошибок `surrogateescape` при записи данных. Это полезно для обработки файлов с неизвестной кодировкой.
- `'xmlcharrefreplace'` поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей XML-ссылкой на символ `&#nnn;`.
- `'backslashreplace'` заменяет повреждённые данные escape-последовательностями Python с обратной косой чертой.
- `'namereplace'` (также поддерживается только при записи) заменяет неподдерживаемые символы escape-последовательностями `\N{...}`.

*newline* управляет работой режима [универсальные новые строки](https://python-all.ru/3.5/glossary.html#term-universal-newlines) (он применяется только к текстовому режиму). Может принимать значения `None`, `''`, `'\n'`, `'\r'` и `'\r\n'`. Работает следующим образом:

- При чтении из потока, если *newline* равен `None`, включается универсальный режим новых строк. Строки во входных данных могут заканчиваться на `'\n'`, `'\r'` или `'\r\n'`; перед возвратом вызывающему коду они преобразуются в `'\n'`. Если равен `''`, универсальный режим новых строк включён, но концы строк возвращаются как есть, без преобразования. Если задано любое другое допустимое значение, строки на входе завершаются только заданной строкой, и конец строки возвращается вызывающему коду без изменений.
- При записи в поток, если *newline* равен `None`, все символы `'\n'` преобразуются в системный разделитель строк по умолчанию [`os.linesep`](https://python-all.ru/3.5/library/os.html#os.linesep). Если *newline* равен `''` или `'\n'`, преобразование не выполняется. Если *newline* равен любому другому допустимому значению, все символы `'\n'` преобразуются в заданную строку.

Если *closefd* равен `False` и был передан файловый дескриптор, а не имя файла, базовый файловый дескриптор останется открытым при закрытии файла. Если передано имя файла, *closefd* должно быть `True` (значение по умолчанию), иначе будет возбуждена ошибка.

Можно задать собственный «открыватель», передав вызываемый объект как *opener*. Базовый файловый дескриптор для файлового объекта получается вызовом *opener* с аргументами (*file*, *flags*). *opener* должен вернуть открытый файловый дескриптор (передача [`os.open`](https://python-all.ru/3.5/library/os.html#os.open) в качестве *opener* даёт результат, аналогичный передаче `None`).

Созданный файл является [ненаследуемым](https://python-all.ru/3.5/library/os.html#fd-inheritance).

В следующем примере используется параметр [dir\_fd](https://python-all.ru/3.5/library/os.html#dir-fd) функции [`os.open()`](https://python-all.ru/3.5/library/os.html#os.open) для открытия файла относительно заданного каталога:

```python
>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # не допустить утечки файлового дескриптора
```

Тип [файлового объекта](https://python-all.ru/3.5/glossary.html#term-file-object), возвращаемого функцией [`open()`](https://python-all.ru/3.5/library/functions.html#open), зависит от режима. При использовании [`open()`](https://python-all.ru/3.5/library/functions.html#open) для открытия файла в текстовом режиме (`'w'`, `'r'`, `'wt'`, `'rt'` и т.д.) возвращается подкласс [`io.TextIOBase`](https://python-all.ru/3.5/library/io.html#io.TextIOBase) (а именно [`io.TextIOWrapper`](https://python-all.ru/3.5/library/io.html#io.TextIOWrapper)). При открытии файла в двоичном режиме с буферизацией возвращаемый класс является подклассом [`io.BufferedIOBase`](https://python-all.ru/3.5/library/io.html#io.BufferedIOBase). Конкретный класс различается: в режиме чтения в двоичном виде возвращается [`io.BufferedReader`](https://python-all.ru/3.5/library/io.html#io.BufferedReader); в режимах записи и добавления в двоичном виде – [`io.BufferedWriter`](https://python-all.ru/3.5/library/io.html#io.BufferedWriter), а в режиме чтения/записи – [`io.BufferedRandom`](https://python-all.ru/3.5/library/io.html#io.BufferedRandom). Если буферизация отключена, возвращается необработанный поток – подкласс [`io.RawIOBase`](https://python-all.ru/3.5/library/io.html#io.RawIOBase), [`io.FileIO`](https://python-all.ru/3.5/library/io.html#io.FileIO).

См. также модули для работы с файлами: [`fileinput`](https://python-all.ru/3.5/library/fileinput.html#module-fileinput), [`io`](https://python-all.ru/3.5/library/io.html#module-io) (где объявлен [`open()`](https://python-all.ru/3.5/library/functions.html#open)), [`os`](https://python-all.ru/3.5/library/os.html#module-os), [`os.path`](https://python-all.ru/3.5/library/os.path.html#module-os.path), [`tempfile`](https://python-all.ru/3.5/library/tempfile.html#module-tempfile) и [`shutil`](https://python-all.ru/3.5/library/shutil.html#module-shutil).

Изменено в версии 3.3: Добавлен параметр *opener*. Добавлен режим `'x'`. [`IOError`](https://python-all.ru/3.5/library/exceptions.html#IOError) ранее вызывалось, теперь это псевдоним [`OSError`](https://python-all.ru/3.5/library/exceptions.html#OSError). [`FileExistsError`](https://python-all.ru/3.5/library/exceptions.html#FileExistsError) теперь вызывается, если файл, открытый в эксклюзивном режиме создания (`'x'`), уже существует.

Изменено в версии 3.4: Файл теперь не наследуется.

Устарело с версии 3.4, будет удалено в версии 4.0: Режим `'U'`.

Изменено в версии 3.5: Если системный вызов был прерван и обработчик сигнала не возбуждает исключение, функция теперь повторяет системный вызов вместо возбуждения исключения [`InterruptedError`](https://python-all.ru/3.5/library/exceptions.html#InterruptedError) (см. [**PEP 475**](https://python-all.ru/3.5/library/functions.html) для обоснования).

Изменено в версии 3.5: Добавлен обработчик ошибок `'namereplace'`.

#### `ord(c)`

Принимает строку, представляющую один символ Unicode, и возвращает целое число – кодовую точку Unicode этого символа. Например, `ord('a')` возвращает целое число `97`, а `ord('€')` (знак евро) возвращает `8364`. Это функция, обратная [`chr()`](https://python-all.ru/3.5/library/functions.html#chr).

#### `pow(x, y[, z])`

Возвращает *x* в степени *y*; если указан *z*, возвращает *x* в степени *y* по модулю *z* (вычисляется эффективнее, чем `pow(x, y) % z`). Двухаргументная форма `pow(x, y)` эквивалентна использованию оператора возведения в степень: `x**y`.

Аргументы должны быть числовых типов. При смешанных типах операндов применяются правила приведения для бинарных арифметических операторов. Для операндов [`int`](https://python-all.ru/3.5/library/functions.html#int) результат имеет тот же тип, что и операнды (после приведения), если только второй аргумент не отрицателен; в этом случае все аргументы преобразуются в float и возвращается результат типа float. Например, `10**2` возвращает `100`, а `10**-2` возвращает `0.01`. Если второй аргумент отрицателен, третий аргумент должен быть опущен. Если указан *z*, *x* и *y* должны быть целыми типами, а *y* должен быть неотрицательным.

#### `print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)`

Выводит *objects* в текстовый поток *file*, разделяя их *sep* и завершая *end*. *sep*, *end*, *file* и *flush*, если присутствуют, должны передаваться как именованные аргументы.

Все неименованные аргументы преобразуются в строки, как [`str()`](https://python-all.ru/3.5/library/stdtypes.html#str), и записываются в поток, разделённые *sep* и завершаемые *end*. Оба *sep* и *end* должны быть строками; они также могут быть `None`, что означает использование значений по умолчанию. Если *objects* не указаны, [`print()`](https://python-all.ru/3.5/library/functions.html#print) просто запишет *end*.

Аргумент *file* должен быть объектом с методом `write(string)`; если он не указан или равен `None`, будет использоваться [`sys.stdout`](https://python-all.ru/3.5/library/sys.html#sys.stdout). Так как выводимые аргументы преобразуются в текстовые строки, [`print()`](https://python-all.ru/3.5/library/functions.html#print) нельзя использовать с файловыми объектами в бинарном режиме. Для них используйте `file.write(...)`.

Обычно буферизация вывода определяется параметром *file*, но если именованный аргумент *flush* равен True, поток принудительно сбрасывается.

Изменено в версии 3.3: Добавлен именованный аргумент *flush*.

#### `class property(fget=None, fset=None, fdel=None, doc=None)`

Возвращает атрибут property.

*fget* – функция для получения значения атрибута. *fset* – функция для установки значения атрибута. *fdel* – функция для удаления значения атрибута. А *doc* создаёт строку документации для атрибута.

Типичное использование – определить управляемый атрибут `x`:

```python
class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")
```

Если *c* – экземпляр *C*, то `c.x` вызовет геттер, `c.x = value` вызовет сеттер, а `del c.x` – делитер.

Если указан, *doc* будет строкой документации атрибута property. В противном случае property скопирует строку документации *fget* (если она существует). Это позволяет легко создавать свойства только для чтения, используя [`property()`](https://python-all.ru/3.5/library/functions.html#property) в качестве [декоратора](https://python-all.ru/3.5/glossary.html#term-decorator):

```python
class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Получить текущее напряжение."""
        return self._voltage
```

Декоратор `@property` превращает метод `voltage()` в «геттер» для атрибута только для чтения с тем же именем и устанавливает строку документации для *voltage* в «Get the current voltage.»

Объект property имеет методы `getter`, `setter` и `deleter`, которые можно использовать как декораторы; они создают копию свойства с соответствующей функцией доступа, установленной в декорированную функцию. Лучше всего это объяснить на примере:

```python
class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """Я – свойство 'x'."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x
```

Этот код полностью эквивалентен первому примеру. Убедитесь, что дополнительные функции имеют то же имя, что и исходное свойство (`x` в данном случае.)

Возвращаемый объект property также имеет атрибуты `fget`, `fset` и `fdel`, соответствующие аргументам конструктора.

Изменено в версии 3.5: Строки документации объектов property теперь доступны для записи.

#### `range(stop)`

#### `range(start, stop[, step])`

[`range`](https://python-all.ru/3.5/library/stdtypes.html#range) – не функция, а неизменяемый тип последовательности, как описано в [Ranges](https://python-all.ru/3.5/library/stdtypes.html#typesseq-range) и [Sequence Types – list, tuple, range](https://python-all.ru/3.5/library/stdtypes.html#typesseq).

#### `repr(object)`

Возвращает строку, содержащую печатное представление объекта. Для многих типов эта функция пытается вернуть строку, при передаче которой в [`eval()`](https://python-all.ru/3.5/library/functions.html#eval) будет получен объект с тем же значением, в противном случае представление представляет собой строку в угловых скобках, содержащую имя типа объекта и дополнительную информацию, часто включающую имя и адрес объекта. Класс может управлять тем, что возвращает эта функция для своих экземпляров, определив метод [`__repr__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__repr__).

#### `reversed(seq)`

Возвращает обратный [итератор](https://python-all.ru/3.5/glossary.html#term-iterator). *seq* должен быть объектом с методом [`__reversed__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__reversed__) или поддерживающим протокол последовательности (методы [`__len__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__len__) и [`__getitem__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getitem__) с целочисленными аргументами, начиная с `0`).

#### `round(number[, ndigits])`

Возвращает *number*, округлённое до *ndigits* знаков после запятой. Если *ndigits* опущено или равно `None`, возвращается ближайшее целое к входному значению.

Для встроенных типов, поддерживающих [`round()`](https://python-all.ru/3.5/library/functions.html#round), значения округляются до ближайшего кратного 10 в степени минус *ndigits*; если два кратных одинаково близки, округление производится к чётному (так, например, оба `round(0.5)` и `round(-0.5)` равны `0`, а `round(1.5)` равно `2`). Любое целое значение допустимо для *ndigits* (положительное, ноль или отрицательное). Возвращаемое значение – целое число, если функция вызвана с одним аргументом, иначе того же типа, что и *number*.

Для произвольного объекта Python `number` функция `round(number, ndigits)` делегирует выполнение `number.__round__(ndigits)`.

> **Примечание**
>
> Поведение [`round()`](https://python-all.ru/3.5/library/functions.html#round) для чисел с плавающей точкой может быть неожиданным: например, `round(2.675, 2)` даёт `2.67` вместо ожидаемого `2.68`. Это не ошибка: это результат того, что большинство десятичных дробей невозможно точно представить в виде числа с плавающей точкой. Подробнее см. [Арифметика с плавающей точкой: проблемы и ограничения](https://python-all.ru/3.5/tutorial/floatingpoint.html#tut-fp-issues).

#### `class set([iterable])`

Возвращает новый объект [`set`](https://python-all.ru/3.5/library/stdtypes.html#set), опционально с элементами, взятыми из *итерируемого объекта*. `set` – это встроенный класс. См. [`set`](https://python-all.ru/3.5/library/stdtypes.html#set) и [Типы множеств – set, frozenset](https://python-all.ru/3.5/library/stdtypes.html#types-set) для документации об этом классе.

Для других контейнеров см. встроенные классы [`frozenset`](https://python-all.ru/3.5/library/stdtypes.html#frozenset), [`list`](https://python-all.ru/3.5/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.5/library/stdtypes.html#tuple) и [`dict`](https://python-all.ru/3.5/library/stdtypes.html#dict), а также модуль [`collections`](https://python-all.ru/3.5/library/collections.html#module-collections).

#### `setattr(object, name, value)`

Это аналог [`getattr()`](https://python-all.ru/3.5/library/functions.html#getattr). Аргументами являются объект, строка и произвольное значение. Строка может задавать существующий или новый атрибут. Функция присваивает значение атрибуту, если объект это позволяет. Например, `setattr(x, 'foobar', 123)` эквивалентно `x.foobar = 123`.

#### `class slice(stop)`

#### `class slice(start, stop[, step])`

Возвращает объект [slice](https://python-all.ru/3.5/glossary.html#term-slice), представляющий набор индексов, заданных `range(start, stop, step)`. Аргументы *start* и *step* по умолчанию равны `None`. Объекты slice имеют атрибуты только для чтения `start`, `stop` и `step`, которые просто возвращают значения аргументов (или значения по умолчанию). Они не имеют другой явной функциональности; однако они используются Numerical Python и другими сторонними расширениями. Объекты slice также создаются при использовании расширенного синтаксиса индексации. Например: `a[start:stop:step]` или `a[start:stop, i]`. См. [`itertools.islice()`](https://python-all.ru/3.5/library/itertools.html#itertools.islice) для альтернативной версии, возвращающей итератор.

#### `sorted(iterable[, key][, reverse])`

Возвращает новый отсортированный список из элементов *итерируемого объекта*.

Имеет два необязательных аргумента, которые должны быть указаны как именованные.

*key* задает функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка: `key=str.lower`. Значение по умолчанию – `None` (сравнивать элементы напрямую).

*reverse* – логическое значение. Если указано `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.

Используйте [`functools.cmp_to_key()`](https://python-all.ru/3.5/library/functools.html#functools.cmp_to_key) для преобразования устаревшей функции *cmp* в функцию *key*.

Встроенная функция [`sorted()`](https://python-all.ru/3.5/library/functions.html#sorted) гарантированно устойчива. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые сравниваются как равные. Это удобно при многоуровневой сортировке (например, сначала по отделу, затем по зарплатной категории).

Примеры сортировки и краткое руководство см. в [Sorting HOW TO](https://python-all.ru/3.5/howto/sorting.html#sortinghowto).

#### `staticmethod(function)`

Возвращает статический метод для *функции*.

Статический метод не получает неявный первый аргумент. Чтобы объявить статический метод, используйте такую идиому:

```python
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
```

Форма `@staticmethod` является функцией-[декоратором](https://python-all.ru/3.5/glossary.html#term-decorator) – см. описание определений функций в [Определения функций](https://python-all.ru/3.5/reference/compound_stmts.html#function) для получения дополнительной информации.

Её можно вызывать либо для класса (например, `C.f()`), либо для экземпляра (например, `C().f()`). Экземпляр игнорируется – в расчёт берётся только его класс.

Статические методы в Python похожи на аналоги из Java или C++. Также смотрите [`classmethod()`](https://python-all.ru/3.5/library/functions.html#classmethod) – вариант, полезный для создания альтернативных конструкторов класса.

Для получения дополнительной информации о статических методах обратитесь к документации по стандартной иерархии типов в [Стандартная иерархия типов](https://python-all.ru/3.5/reference/datamodel.html#types).

#### `class str(object='')`

#### `class str(object=b'', encoding='utf-8', errors='strict')`

Возвращает [`str`](https://python-all.ru/3.5/library/stdtypes.html#str)-версию *объекта*. Подробнее см. [`str()`](https://python-all.ru/3.5/library/stdtypes.html#str).

`str` – это встроенный строковый [класс](https://python-all.ru/3.5/glossary.html#term-class). Общую информацию о строках см. в [Text Sequence Type – str](https://python-all.ru/3.5/library/stdtypes.html#textseq).

#### `sum(iterable[, start])`

Суммирует *начальное значение* и элементы *итерируемого объекта* слева направо и возвращает итог. *Начальное значение* по умолчанию равно `0`. Элементы *итерируемого объекта* обычно являются числами, а начальное значение не может быть строкой.

Для некоторых случаев существуют хорошие альтернативы [`sum()`](https://python-all.ru/3.5/library/functions.html#sum). Предпочтительный и быстрый способ конкатенации последовательности строк – вызов `''.join(sequence)`. Для сложения чисел с плавающей точкой с повышенной точностью см. [`math.fsum()`](https://python-all.ru/3.5/library/math.html#math.fsum). Для конкатенации последовательности итерируемых объектов рассмотрите [`itertools.chain()`](https://python-all.ru/3.5/library/itertools.html#itertools.chain).

#### `super([type[, object-or-type]])`

Возвращает прокси-объект, который делегирует вызовы методов родительскому или родственному классу *типа*. Это полезно для доступа к унаследованным методам, которые были переопределены в классе. Порядок поиска тот же, что используется [`getattr()`](https://python-all.ru/3.5/library/functions.html#getattr), за исключением того, что сам *тип* пропускается.

Атрибут [`__mro__`](https://python-all.ru/3.5/library/stdtypes.html#class.__mro__) *типа* перечисляет порядок разрешения методов (MRO), используемый как [`getattr()`](https://python-all.ru/3.5/library/functions.html#getattr), так и [`super()`](https://python-all.ru/3.5/library/functions.html#super). Этот атрибут является динамическим и может изменяться при обновлении иерархии наследования.

Если второй аргумент опущен, возвращается несвязанный объект super. Если второй аргумент является объектом, `isinstance(obj, type)` должно быть истинно. Если второй аргумент является типом, `issubclass(type2, type)` должно быть истинно (это полезно для методов класса).

Существует два типичных варианта использования *super*. В иерархии классов с одиночным наследованием *super* можно использовать для ссылки на родительские классы без явного указания их имен, что делает код более поддерживаемым. Это использование тесно параллельно использованию *super* в других языках программирования.

Второй вариант использования – поддержка кооперативного множественного наследования в динамической среде выполнения. Этот вариант уникален для Python и не встречается в статически компилируемых языках или языках, поддерживающих только одиночное наследование. Это позволяет реализовать «ромбовидные диаграммы», в которых несколько базовых классов реализуют один и тот же метод. Хороший дизайн требует, чтобы этот метод имел одинаковую сигнатуру вызова во всех случаях (поскольку порядок вызовов определяется во время выполнения, поскольку этот порядок адаптируется к изменениям в иерархии классов и поскольку этот порядок может включать родственные классы, неизвестные до выполнения).

Для обоих вариантов использования типичный вызов родительского класса выглядит так:

```python
class C(B):
    def method(self, arg):
        super().method(arg)    # Делает то же самое, что и:
                               # super(C, self).method(arg)
```

Обратите внимание, что [`super()`](https://python-all.ru/3.5/library/functions.html#super) реализован как часть процесса связывания для явных точечных обращений к атрибутам, таких как `super().__getitem__(name)`. Это делается путём реализации собственного метода [`__getattribute__()`](https://python-all.ru/3.5/reference/datamodel.html#object.__getattribute__) для поиска классов в предсказуемом порядке, поддерживающем кооперативное множественное наследование. Соответственно, [`super()`](https://python-all.ru/3.5/library/functions.html#super) не определён для неявных обращений с использованием инструкций или операторов, таких как `super()[name]`.

Также обратите внимание, что, за исключением формы без аргументов, [`super()`](https://python-all.ru/3.5/library/functions.html#super) не ограничен использованием внутри методов. Форма с двумя аргументами точно задает аргументы и создает соответствующие ссылки. Форма без аргументов работает только внутри определения класса, так как компилятор заполняет необходимые детали для правильного извлечения определяемого класса, а также для доступа к текущему экземпляру в обычных методах.

Практические рекомендации по проектированию кооперативных классов с использованием [`super()`](https://python-all.ru/3.5/library/functions.html#super) см. в [руководстве по использованию super()](https://python-all.ru/3.5/library/functions.html).

#### `tuple([iterable])`

[`tuple`](https://python-all.ru/3.5/library/stdtypes.html#tuple) на самом деле не функция, а неизменяемый тип последовательности, как описано в [Кортежи](https://python-all.ru/3.5/library/stdtypes.html#typesseq-tuple) и [Типы последовательностей – list, tuple, range](https://python-all.ru/3.5/library/stdtypes.html#typesseq).

#### `class type(object)`

#### `class type(name, bases, dict)`

С одним аргументом возвращает тип объекта *object*. Возвращаемое значение – объект типа, как правило, тот же объект, что и возвращаемый [`object.__class__`](https://python-all.ru/3.5/library/stdtypes.html#instance.__class__).

Встроенная функция [`isinstance()`](https://python-all.ru/3.5/library/functions.html#isinstance) рекомендуется для проверки типа объекта, поскольку она учитывает подклассы.

С тремя аргументами возвращает новый объект типа. Это, по сути, динамическая форма инструкции [`class`](https://python-all.ru/3.5/reference/compound_stmts.html#class). Строка *имя* – это имя класса, которое становится атрибутом [`__name__`](https://python-all.ru/3.5/library/stdtypes.html#definition.__name__); кортеж *базовые классы* перечисляет базовые классы и становится атрибутом [`__bases__`](https://python-all.ru/3.5/library/stdtypes.html#class.__bases__); словарь *словарь* – это пространство имён, содержащее определения для тела класса, и он копируется в стандартный словарь, чтобы стать атрибутом [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__). Например, следующие два оператора создают идентичные объекты [`type`](https://python-all.ru/3.5/library/functions.html#type):

```python
>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))
```

См. также [Type Objects](https://python-all.ru/3.5/library/stdtypes.html#bltin-type-objects).

#### `vars([object])`

Возвращает атрибут [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__) для модуля, класса, экземпляра или любого другого объекта с атрибутом [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__).

Такие объекты, как модули и экземпляры, имеют обновляемый атрибут [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__); однако другие объекты могут иметь ограничения на запись своих атрибутов [`__dict__`](https://python-all.ru/3.5/library/stdtypes.html#object.__dict__) (например, классы используют [`types.MappingProxyType`](https://python-all.ru/3.5/library/types.html#types.MappingProxyType) для предотвращения прямых изменений словаря).

Без аргумента [`vars()`](https://python-all.ru/3.5/library/functions.html#vars) ведёт себя как [`locals()`](https://python-all.ru/3.5/library/functions.html#locals). Примечание: словарь locals полезен только для чтения, так как обновления словаря locals игнорируются.

#### `zip(*iterables)`

Создаёт итератор, который объединяет элементы из каждой из переданных итерируемых последовательностей.

Возвращает итератор кортежей, где *i*-й кортеж содержит *i*-й элемент из каждой последовательности аргументов или итерируемого объекта. Итератор останавливается, когда исчерпывается самая короткая входная последовательность. С одним аргументом-итератором возвращает итератор кортежей из одного элемента. Без аргументов возвращает пустой итератор. Эквивалентно:

```python
def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)
```

Гарантируется порядок вычисления слева направо. Это позволяет реализовать идиому для группировки данных в группы длины n с помощью `zip(*[iter(s)]*n)`. При этом *тот же самый* итератор повторяется `n` раз, так что каждый выходной кортеж содержит результат `n` вызовов итератора. Это приводит к разбиению входных данных на блоки длины n.

[`zip()`](https://python-all.ru/3.5/library/functions.html#zip) следует использовать только с последовательностями разной длины, если не важны несовпавшие хвостовые значения из более длинных последовательностей. Если эти значения важны, используйте [`itertools.zip_longest()`](https://python-all.ru/3.5/library/itertools.html#itertools.zip_longest).

[`zip()`](https://python-all.ru/3.5/library/functions.html#zip) в сочетании с оператором `*` можно использовать для распаковки списка:

```python
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True
```

#### `__import__(name, globals=None, locals=None, fromlist=(), level=0)`

> **Примечание**
>
> Это продвинутая функция, которая не требуется в повседневном программировании на Python, в отличие от [`importlib.import_module()`](https://python-all.ru/3.5/library/importlib.html#importlib.import_module).

Эта функция вызывается оператором [`import`](https://python-all.ru/3.5/reference/simple_stmts.html#import). Её можно заменить (импортировав модуль [`builtins`](https://python-all.ru/3.5/library/builtins.html#module-builtins) и присвоив `builtins.__import__`), чтобы изменить семантику оператора [`import`](https://python-all.ru/3.5/reference/simple_stmts.html#import), но делать это **настоятельно** не рекомендуется, так как обычно проще использовать перехватчики импорта (см. [**PEP 302**](https://python-all.ru/3.5/library/functions.html)) для достижения тех же целей, и это не вызывает проблем с кодом, предполагающим использование реализации импорта по умолчанию. Прямое использование [`__import__()`](https://python-all.ru/3.5/library/functions.html#__import__) также не рекомендуется, вместо него следует использовать [`importlib.import_module()`](https://python-all.ru/3.5/library/importlib.html#importlib.import_module).

Функция импортирует модуль *name*, потенциально используя переданные *globals* и *locals* для определения того, как интерпретировать имя в контексте пакета. *fromlist* задаёт имена объектов или подмодулей, которые должны быть импортированы из модуля, указанного в *name*. Стандартная реализация вообще не использует свой аргумент *locals*, а *globals* использует только для определения контекста пакета для оператора [`import`](https://python-all.ru/3.5/reference/simple_stmts.html#import).

*level* указывает, использовать ли абсолютный или относительный импорт. `0` (по умолчанию) означает только абсолютный импорт. Положительные значения *level* указывают количество родительских каталогов для поиска относительно каталога модуля, вызывающего [`__import__()`](https://python-all.ru/3.5/library/functions.html#__import__) (подробнее см. [**PEP 328**](https://python-all.ru/3.5/library/functions.html)).

Когда переменная *name* имеет вид `package.module`, обычно возвращается пакет верхнего уровня (имя до первой точки), а *не* модуль, названный *name*. Однако, если передан непустой аргумент *fromlist*, возвращается модуль, названный *name*.

Например, оператор `import spam` приводит к байт-коду, напоминающему следующий код:

```python
spam = __import__('spam', globals(), locals(), [], 0)
```

Оператор `import spam.ham` приводит к следующему вызову:

```python
spam = __import__('spam.ham', globals(), locals(), [], 0)
```

Обратите внимание, как [`__import__()`](https://python-all.ru/3.5/library/functions.html#__import__) возвращает модуль верхнего уровня, потому что это объект, который привязывается к имени оператором [`import`](https://python-all.ru/3.5/reference/simple_stmts.html#import).

С другой стороны, оператор `from spam.ham import eggs, sausage as saus` приводит к

```python
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
```

Здесь модуль `spam.ham` возвращается из [`__import__()`](https://python-all.ru/3.5/library/functions.html#__import__). Из этого объекта извлекаются имена для импорта и присваиваются соответствующим именам.

Если требуется просто импортировать модуль (возможно, внутри пакета) по имени, используйте [`importlib.import_module()`](https://python-all.ru/3.5/library/importlib.html#importlib.import_module).

Изменено в версии 3.3: Отрицательные значения *level* больше не поддерживаются (это также меняет значение по умолчанию на 0).

Сноски

| [\[1\]](https://python-all.ru/3.5/library/functions.html#id1) | Обратите внимание, что анализатор принимает только соглашение о концах строк в стиле Unix. Если вы читаете код из файла, убедитесь, что используете режим преобразования символов новой строки для преобразования концов строк в стиле Windows или Mac. |
| --- | --- |