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

---

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

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

#### `[abs]abs(x)`

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

#### `[all]all(iterable)`

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

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

#### `[any]any(iterable)`

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

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

#### `[ascii]ascii(object)`

Как и

[`repr()`](https://python-all.ru/3.0/library/functions.html#repr)

, возвращает строку, содержащую печатное представление объекта, но экранирует не-ASCII символы в строке, возвращаемой

[`repr()`](https://python-all.ru/3.0/library/functions.html#repr)

, используя escape-последовательности

`\x`

,

`\u`

или

`\U`

. Это создаёт строку, похожую на возвращаемую

[`repr()`](https://python-all.ru/3.0/library/functions.html#repr)

в Python 2.

#### `[bin]bin(x)`

Преобразует целое число в двоичную строку. Результат – корректное выражение Python. Если

*x*

не является объектом

[`int`](https://python-all.ru/3.0/library/functions.html#int)

, он должен определять метод

[`__index__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__index__)

, который возвращает целое число.

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

Преобразует значение в логический тип, используя стандартную процедуру проверки истинности. Если

*x*

равно false или опущено, возвращается

[`False`](https://python-all.ru/3.0/library/constants.html#False)

; в противном случае возвращается

[`True`](https://python-all.ru/3.0/library/constants.html#True)

.

[`bool`](https://python-all.ru/3.0/library/functions.html#bool)

– это также класс, являющийся подклассом

[`int`](https://python-all.ru/3.0/library/functions.html#int)

. Класс

[`bool`](https://python-all.ru/3.0/library/functions.html#bool)

не может быть далее подклассифицирован. Его единственные экземпляры – это

[`False`](https://python-all.ru/3.0/library/constants.html#False)

и

[`True`](https://python-all.ru/3.0/library/constants.html#True)

.

#### `[bytearray]bytearray([arg[, encoding[, errors]]])`

Возвращает новый массив байтов. Тип [`bytearray`](https://python-all.ru/3.0/library/functions.html#bytearray) является изменяемой последовательностью целых чисел в диапазоне 0 \<= x \< 256. Он поддерживает большинство обычных методов изменяемых последовательностей, описанных в [*Mutable Sequence Types*](https://python-all.ru/3.0/library/stdtypes.html#typesseq-mutable), а также большинство методов, которые есть у типа [`str`](https://python-all.ru/3.0/library/functions.html#str); см. [*Bytes and Byte Array Methods*](https://python-all.ru/3.0/library/stdtypes.html#bytes-methods).

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

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

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

#### `[bytes]bytes([arg[, encoding[, errors]]])`

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

Соответственно, аргументы конструктора интерпретируются так же, как для `buffer()`.

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

#### `[chr]chr(i)`

Возвращает строку из одного символа, кодовая точка Unicode которого равна целому числу

*i*

. Например,

`chr(97)`

возвращает строку

`'a'`

. Это обратная функция для

[`ord()`](https://python-all.ru/3.0/library/functions.html#ord)

. Допустимый диапазон аргумента зависит от того, как был сконфигурирован Python – это может быть UCS2 \[0..0xFFFF\] или UCS4 \[0..0x10FFFF\].

[`ValueError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.ValueError)

будет возбуждено, если

*i*

выходит за этот диапазон.

#### `[classmethod]classmethod(function)`

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

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

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

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

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

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

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

#### `[compile]compile(source, filename, mode[, flags[, dont_inherit]])`

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

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

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

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

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

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

> **Примечание**
>
> При компиляции строки с многострочными операторами концы строк должны быть представлены одним символом новой строки (`'\n'`), и входные данные должны завершаться по крайней мере одним символом новой строки. Если концы строк представлены как `'\r\n'`, используйте [`str.replace()`](https://python-all.ru/3.0/library/stdtypes.html#str.replace), чтобы заменить их на `'\n'`.

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

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

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

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

Это аналог

[`setattr()`](https://python-all.ru/3.0/library/functions.html#setattr)

. Аргументы – объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет именованный атрибут, если объект это позволяет. Например,

`delattr(x, 'foobar')`

эквивалентно

`del x.foobar`

.

#### `dict([arg])`

Создаёт новый словарь данных, опционально с элементами, взятыми из *arg*. Тип словаря описан в [*Mapping Types – dict*](https://python-all.ru/3.0/library/stdtypes.html#typesmapping).

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

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

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

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

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

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

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

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

```python
>>> import struct
>>> dir()   # doctest: +SKIP
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # doctest: +NORMALIZE_WHITESPACE
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Foo(object):
...     def __dir__(self):
...         return ["kan", "ga", "roo"]
...
>>> f = Foo()
>>> dir(f)
['ga', 'kan', 'roo']
```

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

#### `[divmod]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]enumerate(iterable[, start=0])`

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

```python
>>> for i, season in enumerate(['Spring', 'Summer', 'Fall', 'Winter']):
...     print(i, season)
0 Spring
1 Summer
2 Fall
3 Winter
```

#### `[eval]eval(expression[, globals[, locals]])`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует строку или число в число с плавающей запятой. Если аргумент – строка, она должна содержать десятичное число или число с плавающей запятой, возможно, со знаком и окружённое пробелами. Аргументом также может быть `'[+|-]nan'` или `'[+|-]inf'`. В противном случае аргумент может быть целым числом или числом с плавающей запятой; возвращается число с плавающей запятой с тем же значением (в пределах точности чисел с плавающей запятой Python). Если аргумент не указан, возвращается `0.0`.

> **Примечание**
>
> When passing in a string, values for NaN and Infinity may be returned, depending on the underlying C library. Float accepts the strings `'nan'`, `'inf'` and `'-inf'` for NaN and positive or negative infinity. The case and a leading + are ignored as well as a leading - is ignored for NaN. Float always represents NaN and infinity as `nan`, `inf` or `-inf`.

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

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

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

> **Примечание**
>
> `format(value, format_spec)` просто вызывает `value.__format__(format_spec)`.

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

Return a frozenset object, optionally with elements taken from *iterable*. The frozenset type is described in [*Set Types – set, frozenset*](https://python-all.ru/3.0/library/stdtypes.html#types-set).

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

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

Возвращает значение именованного атрибута объекта

*object*

.

*name*

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

`getattr(x, 'foobar')`

эквивалентно

`x.foobar`

. Если именованный атрибут не существует, возвращается

*default*

, если он указан, в противном случае возбуждается

[`AttributeError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.AttributeError)

.

#### `[globals]globals()`

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

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

Аргументами являются объект и строка. Результат –

`True`

, если строка является именем одного из атрибутов объекта, и

`False`

в противном случае. (Реализовано вызовом

`getattr(object, name)`

и проверкой, вызывает ли он исключение.)

#### `[hash]hash(object)`

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

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

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

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

#### `[hex]hex(x)`

Преобразует целое число в шестнадцатеричную строку. Результат является корректным Python выражением. Если

*x*

не является объектом

[`int`](https://python-all.ru/3.0/library/functions.html#int)

, он должен определять метод

[`__index__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__index__)

, который возвращает целое число.

#### `[id]id(object)`

Возвращает «идентификатор» объекта. Это целое число, которое гарантированно является уникальным и постоянным для данного объекта на протяжении его жизни. Два объекта с неперекрывающимися временами жизни могут иметь одно и то же значение

[`id()`](https://python-all.ru/3.0/library/functions.html#id)

. (Примечание по реализации: это адрес объекта.)

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

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

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

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

#### `[int]int([number | string[, radix]])`

Преобразует число или строку в целое число. Если аргументы не переданы, возвращает `0`. Если передано число, возвращает `number.__int__()`. При преобразовании чисел с плавающей запятой в целые происходит отбрасывание дробной части в сторону нуля. Строка должна быть целочисленным литералом в указанной системе счисления, необязательно с префиксом '+' или '-' (без пробела между ними) и необязательно окруженным пробелами. Литерал по основанию n состоит из цифр от 0 до n-1, причем 'a' – 'z' (или 'A' – 'Z') имеют значения от 10 до 35. Система счисления по умолчанию – 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.0/library/stdtypes.html#typesnumeric).

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

Return true if the

*object*

argument is an instance of the

*classinfo*

argument, or of a (direct or indirect) subclass thereof. If

*object*

is not an object of the given type, the function always returns false. If

*classinfo*

is not a class (type object), it may be a tuple of type objects, or may recursively contain other such tuples (other sequence types are not accepted). If

*classinfo*

is not a type or tuple of types and such tuples, a

[`TypeError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.TypeError)

exception is raised.

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

Return true if

*class*

is a subclass (direct or indirect) of

*classinfo*

. A class is considered a subclass of itself.

*classinfo*

may be a tuple of class objects, in which case every entry in

*classinfo*

will be checked. In any other case, a

[`TypeError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.TypeError)

exception is raised.

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

Возвращает объект

[*итератора*](https://python-all.ru/3.0/glossary.html#term-iterator)

. Первый аргумент интерпретируется совершенно по-разному в зависимости от наличия второго аргумента. Без второго аргумента

*o*

должен быть объектом-коллекцией, поддерживающим протокол итерации (метод

[`__iter__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__iter__)

), или он должен поддерживать протокол последовательности (метод

[`__getitem__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__getitem__)

с целочисленными аргументами, начиная с

`0`

). Если он не поддерживает ни один из этих протоколов, возбуждается

[`TypeError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.TypeError)

. Если задан второй аргумент

*sentinel*

, то

*o*

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

*o*

без аргументов для каждого вызова своего метода

`__next__()`

; если возвращённое значение равно

*sentinel*

, будет возбуждено

[`StopIteration`](https://python-all.ru/3.0/library/exceptions.html#exceptions.StopIteration)

, в противном случае будет возвращено значение.

#### `[len]len(s)`

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

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

Возвращает список, элементы которого такие же и расположены в том же порядке, что и элементы *iterable*. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является списком, создаётся и возвращается его копия, аналогично `iterable[:]`. Например, `list('abc')` возвращает `['a', 'b', 'c']`, а `list( (1, 2, 3) )` возвращает `[1, 2, 3]`. Если аргумент не передан, возвращает новый пустой список `[]`.

[`list`](https://python-all.ru/3.0/library/functions.html#list) – изменяемый тип последовательности, как описано в [*Sequence Types – str, bytes, bytearray, list, tuple, range*](https://python-all.ru/3.0/library/stdtypes.html#typesseq).

#### `[locals]locals()`

Обновляет и возвращает словарь, представляющий текущую таблицу локальных символов.

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

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

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

Возвращает итератор, который применяет

*function*

к каждому элементу

*iterable*

и возвращает результаты. Если переданы дополнительные аргументы

*iterable*

, то

*function*

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

#### `[max]max(iterable[, args...], *[, key])`

С одним аргументом *iterable* возвращает наибольший элемент непустой итерабельной последовательности (например, строки, кортежа или списка). С несколькими аргументами возвращает наибольший из них.

Необязательный аргумент *key*, передаваемый только по ключевому слову, задаёт функцию упорядочивания с одним аргументом, подобную используемой в `list.sort()`.

#### `memoryview(obj)`

Возвращает объект «memory view», созданный из переданного аргумента. Подробнее см.

[*Типы memoryview*](https://python-all.ru/3.0/library/stdtypes.html#typememoryview)

.

#### `[min]min(iterable[, args...], *[, key])`

С одним аргументом *iterable* возвращает наименьший элемент непустой итерируемой последовательности (например, строки, кортежа или списка). С несколькими аргументами возвращает наименьший из аргументов.

Необязательный аргумент *key*, передаваемый только по ключевому слову, задаёт функцию упорядочивания с одним аргументом, подобную используемой в `list.sort()`.

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

Извлекает следующий элемент из

*iterator*

, вызывая его метод

`__next__()`

. Если передан

*default*

, он возвращается, когда итератор исчерпан; в противном случае возбуждается исключение

[`StopIteration`](https://python-all.ru/3.0/library/exceptions.html#exceptions.StopIteration)

.

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

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

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

#### `[oct]oct(x)`

Преобразует целое число в восьмеричную строку. Результат – допустимое выражение Python. Если

*x*

не является объектом

[`int`](https://python-all.ru/3.0/library/functions.html#int)

Python, он должен определить метод

[`__index__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__index__)

, возвращающий целое число.

#### `[open]open(file[, mode='r'[, buffering=None[, encoding=None[, errors=None[, newline=None[, closefd=True]]]]]])`

Открыть файл. Если файл не удалось открыть, возбуждается исключение [`IOError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.IOError).

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

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

| Символ | Значение |
| --- | --- |
| `'r'` | открытие для чтения (по умолчанию) |
| `'w'` | открытие для записи, с предварительным усечением файла |
| `'a'` | открытие для записи, дозапись в конец файла, если он существует |
| `'b'` | двоичный режим |
| `'t'` | текстовый режим (по умолчанию) |
| `'+'` | открывает дисковый файл для обновления (чтения и записи) |
| `'U'` | универсальный режим перевода строк (для обратной совместимости; не нужен для нового кода) |

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

Python различает файлы, открытые в бинарном и текстовом режимах, даже если базовая операционная система этого не делает. Файлы, открытые в бинарном режиме (добавление `'b'` к аргументу *mode*), возвращают содержимое как объекты `bytes` без какого-либо декодирования. В текстовом режиме (по умолчанию или при добавлении `'t'` к аргументу *mode*) содержимое файла возвращается в виде строк, при этом байты сначала декодируются с использованием кодировки, зависящей от платформы, или указанной *encoding*, если она задана.

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

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

*errors* – необязательная строка, задающая способ обработки ошибок кодирования – этот аргумент не следует использовать в бинарном режиме. Передайте `'strict'`, чтобы возбуждать исключение [`ValueError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.ValueError) при наличии ошибки кодирования (значение по умолчанию `None` имеет тот же эффект), или передайте `'ignore'` для игнорирования ошибок. (Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.) Список допустимых строк ошибок кодирования см. в документации к [`codecs.register()`](https://python-all.ru/3.0/library/codecs.html#codecs.register).

*newline* управляет работой режима универсального перевода строк (применяется только в текстовом режиме). Может принимать значения `None`, `''`, `'\n'`, `'\r'` и `'\r\n'`. Работает следующим образом:

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

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

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

#### `[ord]ord(c)`

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

Если длина аргумента не равна единице, будет возбуждено исключение [`TypeError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.TypeError). (Если Python собран с UCS2 Unicode, кодовая точка символа должна находиться в диапазоне \[0..65535\] включительно; в противном случае длина строки равна двум!)

#### `[pow]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.0/library/functions.html#int) результат имеет тот же тип, что и операнды (после приведения), если только второй аргумент не отрицателен; в этом случае все аргументы преобразуются в float и возвращается результат типа float. Например, `10**2` возвращает `100`, а `10**-2` возвращает `0.01`. Если второй аргумент отрицателен, третий аргумент должен быть опущен. Если указан *z*, то *x* и *y* должны быть целочисленными, а *y* – неотрицательным.

#### `[print]print([object, ...][, sep=' '][, end='\n'][, file=sys.stdout])`

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

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

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

#### `[property]property([fget[, fset[, fdel[, doc]]]])`

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

*fget* – функция для получения значения атрибута, *fset* – функция для установки, а *fdel* – функция для удаления атрибута. Обычное использование – определение управляемого атрибута x:

```python
class C(object):
    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.")
```

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

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

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
```

превращает метод `voltage()` в «геттер» для атрибута только для чтения с тем же именем.

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

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

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

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

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

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

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

Это универсальная функция для создания итерируемых объектов, порождающих арифметические прогрессии. Чаще всего она используется в циклах [`for`](https://python-all.ru/3.0/reference/compound_stmts.html#for). Аргументы должны быть целыми числами. Если аргумент *step* опущен, по умолчанию он равен `1`. Если аргумент *start* опущен, по умолчанию он равен `0`. Полная форма возвращает итерируемый объект из целых чисел `[start, start + step, start + 2 * step, ...]`. Если *step* положителен, последний элемент – это наибольшее `start + i * step`, строго меньшее *stop*; если *step* отрицателен, последний элемент – это наименьшее `start + i * step`, строго большее *stop*. *step* не должен быть равен нулю (иначе вызывается [`ValueError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.ValueError)). Пример:

```python
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]
```

#### `[repr]repr(object)`

Возвращает строку, содержащую печатное представление объекта. Для многих типов эта функция пытается вернуть строку, которая при передаче в

[`eval()`](https://python-all.ru/3.0/library/functions.html#eval)

дала бы объект с тем же значением; в противном случае представление – это строка в угловых скобках, содержащая имя типа объекта вместе с дополнительной информацией, часто включающей имя и адрес объекта. Класс может управлять тем, что эта функция возвращает для его экземпляров, определив метод

[`__repr__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__repr__)

.

#### `[reversed]reversed(seq)`

Возвращает обратный

[*итератор*](https://python-all.ru/3.0/glossary.html#term-iterator)

.

*seq*

должен быть объектом, который имеет метод

[`__reversed__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__reversed__)

или поддерживает протокол последовательности (метод

[`__len__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__len__)

и метод

[`__getitem__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__getitem__)

с целочисленными аргументами, начиная с

`0`

).

#### `[round]round(x[, n])`

Возвращает значение с плавающей точкой *x*, округлённое до *n* знаков после десятичной точки. Если *n* опущено, по умолчанию используется ноль. Делегирует вызов `x.__round__(n)`.

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

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

Возвращает новое множество, необязательно с элементами, взятыми из

*iterable*

. Тип set описан в разделе

[*Типы множеств – set, frozenset*](https://python-all.ru/3.0/library/stdtypes.html#types-set)

.

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

Это аналог

[`getattr()`](https://python-all.ru/3.0/library/functions.html#getattr)

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

`setattr(x, 'foobar', 123)`

эквивалентно

`x.foobar = 123`

.

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

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

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

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

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

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

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

#### `[staticmethod]staticmethod(function)`

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

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

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

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

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

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

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

#### `[str]str([object[, encoding[, errors]]])`

Возвращает строковое представление объекта, используя один из следующих режимов:

Если указаны *encoding* и/или *errors*, [`str()`](https://python-all.ru/3.0/library/functions.html#str) декодирует *object*, который может быть либо байтовой строкой, либо символьным буфером, используя кодек для *encoding*. Параметр *encoding* – это строка, задающая имя кодировки; если кодировка неизвестна, возбуждается [`LookupError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.LookupError). Обработка ошибок выполняется в соответствии с *errors*; этот параметр определяет обращение с символами, недопустимыми во входной кодировке. Если *errors* равно `'strict'` (по умолчанию), при ошибках возбуждается [`ValueError`](https://python-all.ru/3.0/library/exceptions.html#exceptions.ValueError), тогда как значение `'ignore'` приводит к игнорированию ошибок без уведомления, а значение `'replace'` приводит к использованию официального заменяющего символа Unicode U+FFFD для замены входных символов, которые не могут быть декодированы. См. также модуль [`codecs`](https://python-all.ru/3.0/library/codecs.html#module-codecs).

Если указан только *object*, возвращает его хорошо читаемое строковое представление. Для строк это сама строка. Отличие от `repr(object)` в том, что `str(object)` не всегда пытается вернуть строку, которую можно передать в [`eval()`](https://python-all.ru/3.0/library/functions.html#eval); его цель – вернуть печатаемую строку. Без аргументов возвращает пустую строку.

Объекты могут определять, что возвращает `str(object)`, путём определения специального метода [`__str__()`](https://python-all.ru/3.0/reference/datamodel.html#object.__str__).

Дополнительную информацию о строках см. в [*Sequence Types – str, bytes, bytearray, list, tuple, range*](https://python-all.ru/3.0/library/stdtypes.html#typesseq), где описывается функциональность последовательностей (строки являются последовательностями), а также строковые методы, описанные в разделе [*Строковые методы*](https://python-all.ru/3.0/library/stdtypes.html#string-methods). Для вывода форматированных строк см. раздел [*Форматирование строк*](https://python-all.ru/3.0/library/string.html#string-formatting). Кроме того, см. раздел [*Строковые сервисы*](https://python-all.ru/3.0/library/strings.html#stringservices).

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

Суммирует

*start*

и элементы

*iterable*

слева направо и возвращает сумму.

*start*

по умолчанию равен

`0`

. Элементы

*iterable*

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

`''.join(sequence)`

.

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

Возвращает объект *super*, который действует как прокси для суперклассов *type*.

Если второй аргумент опущен, возвращается несвязанный объект super. Если второй аргумент является объектом, `isinstance(obj, type)` должно быть истинно. Если второй аргумент является типом, `issubclass(type2, type)` должно быть истинно. Вызов [`super()`](https://python-all.ru/3.0/library/functions.html#super) без аргументов эквивалентен `super(this_class, first_arg)`.

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

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

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

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

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

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

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

Возвращает кортеж, элементы которого совпадают с элементами *iterable* и сохраняют их порядок. *iterable* может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если *iterable* уже является кортежем, он возвращается без изменений. Например, `tuple('abc')` возвращает `('a', 'b', 'c')`, а `tuple([1, 2, 3])` возвращает `(1, 2, 3)`. Если аргумент не указан, возвращает новый пустой кортеж, `()`.

[`tuple`](https://python-all.ru/3.0/library/functions.html#tuple) – неизменяемый тип последовательности, как описано в разделе [*Типы последовательностей – str, bytes, bytearray, list, tuple, range*](https://python-all.ru/3.0/library/stdtypes.html#typesseq).

#### `[type]type(object)`

Возвращает тип *object*. Возвращаемое значение – объект типа и обычно тот же объект, который возвращается `object.__class__`.

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

С тремя аргументами [`type()`](https://python-all.ru/3.0/library/functions.html#type) работает как конструктор, как описано ниже.

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

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

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

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

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

`__dict__`

) – возвращает словарь, соответствующий таблице символов объекта. Возвращаемый словарь не следует изменять: последствия для соответствующей таблицы символов не определены.

[\[1\]](https://python-all.ru/3.0/library/functions.html#id2)

#### `[zip]zip(*iterables)`

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

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

```python
def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    iterables = map(iter, iterables)
    while iterables:
        result = [it.next() for it in iterables]
        yield tuple(result)
```

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

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

[`zip()`](https://python-all.ru/3.0/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 == x2, y == y2
True
```

#### `[__import__]__import__(name[, globals[, locals[, fromlist[, level]]]])`

> **Примечание**
>
> Это продвинутая функция, не требующаяся в повседневном программировании на Python.

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

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

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

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

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

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

Инструкция `import spam.ham` приводит к следующему вызову:

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

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

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

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

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

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

```python
>>> import sys
>>> name = 'foo.bar.baz'
>>> __import__(name)
<module 'foo' from ...>
>>> baz = sys.modules[name]
>>> baz
<module 'foo.bar.baz' from ...>
```

Сноски

| [\[1\]](https://python-all.ru/3.0/library/functions.html#id1) | Указание размера буфера в настоящее время не влияет на системы, не имеющие `setvbuf`. Интерфейс для указания размера буфера не использует метод, вызывающий `setvbuf`, потому что это может привести к дампу ядра при вызове после выполнения любого ввода-вывода, и нет надёжного способа определить, так ли это. |
| --- | --- |

| \[2\] | В текущей реализации локальные привязки переменных обычно нельзя так изменить, но переменные, полученные из других областей видимости (например, из модулей), можно. Это может измениться. |
| --- | --- |