2. Встроенные функции¶Built-in Functions

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

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

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

all(iterable)¶

Возвращает True, если все элементы итерируемого объекта истинны (или если итерируемый объект пуст). Эквивалентно:

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

any(iterable)¶

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

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

ascii(object)¶: Как и repr(), возвращает строку, содержащую печатное представление объекта, но экранирует не-ASCII символы в строке, возвращаемой repr(), используя escape-последовательности \x, \u или \U. Это создаёт строку, похожую на возвращаемую repr() в Python 2.

bin(x)¶: Преобразует целое число в двоичную строку. Результат – корректное выражение Python. Если x не является объектом int, он должен определять метод __index__(), который возвращает целое число.

bool([x])¶: Преобразует значение в логический тип, используя стандартную процедуру проверки истинности. Если x равно false или опущено, возвращается False; в противном случае возвращается True. bool – это также класс, являющийся подклассом int. Класс bool не может быть далее подклассифицирован. Его единственные экземпляры – это False и True.

bytearray([source[, encoding[, errors]]])¶

Возвращает новый массив байтов. Тип bytearray представляет собой изменяемую последовательность целых чисел в диапазоне 0 <= x < 256. Он содержит большинство обычных методов изменяемых последовательностей, описанных в Mutable Sequence Types, а также большинство методов, которые есть у типа bytes; см. Bytes and Byte Array Methods.

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

Если это строка, необходимо также указать параметры encoding (и, опционально, errors); затем bytearray() преобразует строку в байты с помощью str.encode().
Если это целое число, массив будет иметь указанный размер и будет инициализирован нулевыми байтами.
Если это объект, соответствующий интерфейсу buffer, то для инициализации массива bytes будет использоваться буфер этого объекта только для чтения.
Если это iterable (итерируемый объект), это должен быть итерируемый объект целых чисел в диапазоне 0 <= x < 256, которые используются как начальное содержимое массива.

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

bytes([source[, encoding[, errors]]])¶

Возвращает новый объект «bytes», который является неизменяемой последовательностью целых чисел в диапазоне 0 <= x < 256. bytes – неизменяемая версия bytearray: у него те же неизменяющие методы и такое же поведение при индексации и срезах.

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

Объекты bytes также можно создавать с помощью литералов, см. Литералы строк и bytes.

chr(i)¶

Возвращает строку, представляющую символ, кодовая точка Unicode которого равна целому числу i. Например, chr(97) возвращает строку 'a'. Это обратная операция для ord(). Допустимый диапазон аргумента – от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). Если i выходит за этот диапазон, возбуждается ValueError.

Обратите внимание, что в сборках с узким Unicode результат представляет собой строку длиной два для i больше 65 535 (0xFFFF в шестнадцатеричном формате).

classmethod(function)¶

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

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

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

Форма @classmethod является декоратором функций – подробнее см. описание определений функций в разделе Function definitions.

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

Методы класса отличаются от статических методов C++ или Java. Если нужны они, см. staticmethod() в этом же разделе.

Дополнительную информацию о методах класса см. в документации по стандартной иерархии типов в Стандартная иерархия типов.

compile(source, filename, mode, flags=0, dont_inherit=False)¶

Компилирует source в объект кода или AST. Объекты кода могут быть выполнены с помощью exec() или eval(). source может быть строкой или AST-объектом. Обратитесь к документации модуля ast за информацией о том, как работать с AST-объектами.

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

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

Необязательные аргументы flags и dont_inherit управляют тем, какие операторы будущего (см. PEP 236) влияют на компиляцию source. Если ни один из них не указан (или оба равны нулю), код компилируется с теми операторами будущего, которые действуют в коде, вызывающем compile. Если указан аргумент flags, а dont_inherit не указан (или равен нулю), то операторы будущего, заданные аргументом flags, используются в дополнение к тем, которые использовались бы в любом случае. Если dont_inherit – ненулевое целое число, то используется аргумент flags – операторы будущего, действующие в месте вызова compile, игнорируются.

Future-инструкции задаются битами, которые можно объединять с помощью побитового ИЛИ, чтобы указать несколько инструкций. Необходимое битовое поле для указания конкретной возможности можно найти как атрибут compiler_flag у экземпляра _Feature в модуле __future__.

Эта функция возбуждает исключение SyntaxError, если компилируемый исходный код некорректен, и TypeError, если исходный код содержит нулевые байты.

Примечание

При компиляции строки с многострочными операторами концы строк должны быть представлены одним символом новой строки ('\n'), и входные данные должны завершаться по крайней мере одним символом новой строки. Если концы строк представлены как '\r\n', используйте str.replace(), чтобы заменить их на '\n'.

complex([real[, imag]])¶

Создаёт комплексное число со значением real + imag*j или преобразует строку или число в комплексное число. Если первый параметр – строка, она будет интерпретирована как комплексное число, и функцию необходимо вызывать без второго параметра. Второй параметр никогда не может быть строкой. Каждый аргумент может быть любого числового типа (включая комплексный). Если imag опущен, по умолчанию он равен нулю, и функция выступает в роли функции преобразования числовых типов, такой как int() и float(). Если оба аргумента опущены, возвращает 0j.

Тип complex описан в разделе Числовые типы – int, float, complex.

delattr(object, name)¶: Это аналог setattr(). Аргументы – объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет именованный атрибут, если объект это позволяет. Например, delattr(x, 'foobar') эквивалентно del x.foobar.

dict([arg])

Создаёт новый словарь данных, опционально с элементами, взятыми из arg. Тип словаря описан в Mapping Types – dict.

Другие контейнеры см. во встроенных классах list, set, tuple и модуле collections.

dir([object])¶

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

Если у объекта есть метод с именем __dir__(), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, реализующим собственную функцию __getattr__() или __getattribute__(), настраивать то, как dir() сообщает об их атрибутах.

Если объект не предоставляет __dir__(), функция старается собрать информацию из атрибута __dict__ объекта (если он определён) и из его объекта-типа. Полученный список не обязательно полный и может быть неточным, если у объекта есть собственная реализация __getattr__().

Механизм dir() по умолчанию работает по-разному для разных типов объектов, поскольку он пытается предоставить наиболее уместную, а не полную, информацию:

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

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

>>> 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:
...     def __dir__(self):
...         return ["kan", "ga", "roo"]
...
>>> f = Foo()
>>> dir(f)
['ga', 'kan', 'roo']

Примечание

Поскольку 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 должен быть последовательностью, итератором или другим объектом, поддерживающим итерацию. Метод __next__() итератора, возвращаемого enumerate(), возвращает кортеж, содержащий счётчик (от start, по умолчанию равный 0) и соответствующее значение, полученное при итерации по iterable. enumerate() полезен для получения индексированной серии: (0, seq[0]), (1, seq[1]), (2, seq[2]), .... Например:

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

eval(expression, globals=None, locals=None)¶

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

Аргумент expression разбирается и вычисляется как выражение Python (технически – список условий) с использованием словарей globals и locals в качестве глобального и локального пространств имён. Если словарь globals присутствует и в нём нет '__builtins__', текущие глобальные переменные копируются в globals перед разбором expression. Это означает, что expression обычно имеет полный доступ к стандартному модулю builtins, и ограниченные окружения распространяются. Если словарь locals опущен, по умолчанию он равен globals. Если оба словаря опущены, выражение выполняется в том окружении, где вызвана eval(). Возвращаемое значение – результат вычисления выражения. Синтаксические ошибки сообщаются как исключения. Пример:

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

Эта функция также может использоваться для выполнения произвольных объектов кода (таких как созданные с помощью compile()). В этом случае передавайте объект кода вместо строки. Если объект кода был скомпилирован с 'exec' в качестве аргумента kind, возвращаемое значение eval() будет None.

Подсказки: динамическое выполнение инструкций поддерживается функцией exec(). Функции globals() и locals() возвращают текущий глобальный и локальный словари соответственно, которые могут быть полезны для передачи для использования с eval() или exec().

См. ast.literal_eval() – функцию, позволяющую безопасно вычислять строки с выражениями, содержащими только литералы.

exec(object[, globals[, locals]])¶

Эта функция поддерживает динамическое выполнение кода Python. object должен быть строкой или объектом кода. Если это строка, она разбирается как набор инструкций Python, который затем выполняется (если не возникнет синтаксическая ошибка). [1] Если это объект кода, он просто выполняется. В любом случае предполагается, что выполняемый код корректен как файловый ввод (см. раздел «Файловый ввод» в справочном руководстве). Обратите внимание, что операторы return и yield не могут использоваться вне определений функций, даже в контексте кода, переданного функции exec(). Возвращаемое значение – None.

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

Если словарь globals не содержит значения для ключа __builtins__, под этот ключ вставляется ссылка на словарь встроенного модуля builtins. Таким образом можно контролировать, какие встроенные функции доступны выполняемому коду, вставив собственный словарь __builtins__ в globals перед передачей его в exec().

Примечание

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

Примечание

Словарь locals по умолчанию действует так, как описано ниже для функции locals(): не следует пытаться изменять словарь locals по умолчанию. Передайте явный словарь locals, если нужно увидеть влияние кода на locals после возврата из функции exec().

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.

См. itertools.filterfalse() – дополняющую функцию, которая возвращает элементы iterable, для которых function возвращает ложь.

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.

format(value[, format_spec])¶: Преобразует значение в «форматированное» представление, управляемое спецификацией формата. Интерпретация спецификации формата зависит от типа аргумента значение, однако существует стандартный синтаксис форматирования, используемый большинством встроенных типов: Мини-язык спецификации формата.

Примечание

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.

Для других контейнеров см. встроенные классы dict, list, tuple, а также модуль collections.

getattr(object, name[, default])¶: Возвращает значение именованного атрибута объекта object. name должен быть строкой. Если строка является именем одного из атрибутов объекта, результатом будет значение этого атрибута. Например, getattr(x, 'foobar') эквивалентно x.foobar. Если именованный атрибут не существует, возвращается default, если он предоставлен, в противном случае возбуждается AttributeError.

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

hasattr(object, name)¶: Аргументами являются объект и строка. Результат – True, если строка является именем одного из атрибутов объекта, и False в противном случае. (Реализовано вызовом getattr(object, name) и проверкой, вызывает ли он исключение.)

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

help([object])¶

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

Эта функция добавляется во встроенное пространство имён модулем site.

hex(x)¶: Преобразует целое число в шестнадцатеричную строку. Результат является корректным Python выражением. Если x не является объектом int, он должен определять метод __index__(), который возвращает целое число.

Примечание

Чтобы получить шестнадцатеричное строковое представление числа с плавающей запятой, используйте метод float.hex().

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

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

input([prompt])¶

Если аргумент prompt присутствует, он выводится в стандартный вывод без завершающего перевода строки. Затем функция читает строку из ввода, преобразует её в строку (удаляя завершающий перевод строки) и возвращает её. Когда достигается конец файла (EOF), возбуждается EOFError. Пример:

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

Если модуль readline был загружен, то input() будет использовать его для предоставления расширенных возможностей редактирования строк и истории.

int([number | string[, base]])¶

Преобразует число или строку в целое число. Если аргументы не указаны, возвращается 0. Если указано число, возвращается number.__int__(). Преобразование чисел с плавающей запятой в целые выполняется с усечением в сторону нуля. Строка должна быть целочисленным литералом в указанной системе счисления, опционально с префиксом '+' или '-' (без пробела) и окружённым пробелами. Литерал в системе счисления 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.

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 exception is raised.

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 exception is raised.

iter(object[, sentinel])¶

Возвращает объект итератора. Первый аргумент интерпретируется по-разному в зависимости от наличия второго аргумента. Без второго аргумента object должен быть объектом-коллекцией, поддерживающим протокол итерации (метод __iter__()), или протокол последовательности (метод __getitem__() с целочисленными аргументами, начиная с 0). Если не поддерживается ни один из этих протоколов, возбуждается TypeError. Если указан второй аргумент sentinel, то object должен быть вызываемым объектом. В этом случае при каждом вызове метода __next__() созданный итератор будет вызывать object без аргументов; если возвращённое значение равно sentinel, возбуждается StopIteration, в противном случае значение возвращается.

Одно из полезных применений второй формы iter() – чтение строк файла до определённой строки. В следующем примере файл читается до тех пор, пока не встретится строка "STOP":

with open("mydata.txt") as fp:
    for line in iter(fp.readline, "STOP"):
        process_line(line)

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

list([iterable])¶

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

list – изменяемый тип последовательности, как описано в Sequence Types – str, bytes, bytearray, list, tuple, range.

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

Примечание

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

map(function, iterable, ...)¶: Возвращает итератор, который применяет function к каждому элементу iterable, возвращая результаты. Если переданы дополнительные аргументы iterable, function должна принимать столько же аргументов и применяется к элементам из всех итерируемых объектов параллельно. При нескольких итерируемых объектах итератор останавливается, когда самый короткий из них исчерпан. Для случаев, когда входные данные функции уже организованы в кортежи аргументов, см. itertools.starmap().

max(iterable[, args...], *[, key])¶

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

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

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

min(iterable[, args...], *[, key])¶

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

next(iterator[, default])¶: Извлекает следующий элемент из iterator, вызывая его метод __next__(). Если передан default, он возвращается, когда итератор исчерпан; в противном случае возбуждается исключение StopIteration.

object()¶: Возвращает новый объект без свойств. object – базовый класс для всех классов. Он имеет методы, общие для всех экземпляров классов Python. Эта функция не принимает аргументов.

Примечание

object не имеет __dict__, поэтому нельзя присваивать произвольные атрибуты экземпляру класса object.

oct(x)¶: Преобразует целое число в восьмеричную строку. Результат – допустимое выражение Python. Если x не является объектом int Python, он должен определить метод __index__(), возвращающий целое число.

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

Открывает file и возвращает соответствующий поток данных. Если файл не удаётся открыть, возбуждается исключение IOError.

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

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

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

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

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

Примечание

Python не зависит от представления текстовых файлов в базовой операционной системе; вся обработка выполняется самим Python и поэтому является платформонезависимой.

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

Двоичные файлы буферизуются блоками фиксированного размера; размер буфера выбирается эвристически, пытаясь определить «размер блока» нижележащего устройства и прибегая к io.DEFAULT_BUFFER_SIZE. На многих системах буфер обычно имеет размер 4096 или 8192 байта.
«Интерактивные» текстовые файлы (файлы, для которых isatty() возвращает True) используют построчную буферизацию. Остальные текстовые файлы используют политику, описанную выше для двоичных файлов.

encoding – это название кодировки, используемой для декодирования или кодирования файла. Она должна использоваться только в текстовом режиме. Кодировка по умолчанию зависит от платформы (то, что возвращает locale.getpreferredencoding()), но можно использовать любую кодировку, поддерживаемую Python. Список поддерживаемых кодировок см. в модуле codecs.

errors – необязательная строка, задающая способ обработки ошибок кодирования и декодирования. Этот параметр нельзя использовать в двоичном режиме. Передайте 'strict', чтобы вызвать исключение ValueError при ошибке кодирования (значение по умолчанию None даёт тот же эффект), или 'ignore' для игнорирования ошибок. (Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.) 'replace' приводит к вставке замещающего маркера (например, '?') там, где находятся некорректные данные. При записи можно использовать 'xmlcharrefreplace' (замена соответствующей XML-ссылкой на символ) или 'backslashreplace' (замена escape-последовательностями с обратной косой чертой). Любое другое имя обработчика ошибок, зарегистрированное с помощью codecs.register_error(), также допустимо.

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

При чтении, если newline равен None, включается режим универсального перевода строк. Строки во входных данных могут заканчиваться на '\n', '\r' или '\r\n', и они преобразуются в '\n' перед возвратом вызывающему коду. Если он равен '', режим универсального перевода строк также включён, но концы строк возвращаются вызывающему коду без преобразования. Если он имеет любое другое допустимое значение, входные строки завершаются только заданной строкой, и конец строки возвращается без преобразования.
При записи, если newline равен None, все записанные символы '\n' преобразуются в системный разделитель строк по умолчанию os.linesep. Если newline равен '', преобразование не выполняется. Если newline имеет любое другое допустимое значение, все записанные символы '\n' преобразуются в заданную строку.

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

Тип файлового объекта, возвращаемого функцией open(), зависит от режима. Когда open() используется для открытия файла в текстовом режиме ('w', 'r', 'wt', 'rt' и т.д.), она возвращает подкласс io.TextIOBase (а именно io.TextIOWrapper). При открытии файла в двоичном режиме с буферизацией возвращаемый класс является подклассом io.BufferedIOBase. Конкретный класс зависит от режима: в двоичном режиме чтения возвращается io.BufferedReader; в двоичных режимах записи и добавления – io.BufferedWriter, а в режиме чтения/записи – io.BufferedRandom. Если буферизация отключена, возвращается небуферизованный поток – подкласс io.RawIOBase, io.FileIO.

См. также модули для работы с файлами, такие как fileinput, io (где объявлена open()), os, os.path, tempfile и shutil.

ord(c)¶

Принимает строку, содержащую один символ Unicode, и возвращает целое число – кодовую точку Unicode этого символа. Например, ord('a') возвращает целое число 97, а ord('\u2020') возвращает 8224. Это обратная функция для chr().

В широких сборках Unicode, если длина аргумента не равна единице, будет возбуждено TypeError. В узких сборках Unicode принимаются строки длиной в два символа, если они образуют суррогатную пару UTF-16.

pow(x, y[, z])¶

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

Аргументы должны быть числовых типов. При смешанных типах операндов применяются правила приведения для бинарных арифметических операторов. Для операндов типа int результат имеет тот же тип, что и операнды (после приведения), если только второй аргумент не отрицателен; в этом случае все аргументы преобразуются в float и возвращается результат типа float. Например, 10**2 возвращает 100, а 10**-2 возвращает 0.01. Если второй аргумент отрицателен, третий аргумент должен быть опущен. Если указан z, то x и y должны быть целочисленными, а y – неотрицательным.

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

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

Все неименованные аргументы преобразуются в строки, как это делает str(), и записываются в поток, разделённые sep и завершаемые end. Оба параметра – sep и end – должны быть строками; они также могут быть None, что означает использование значений по умолчанию. Если object не передан, print() просто выведет end.

Аргумент file должен быть объектом, имеющим метод write(string); если он не указан или равен None, будет использоваться sys.stdout.

property(fget=None, fset=None, fdel=None, doc=None)¶

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

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

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 будет строкой документации свойства. В противном случае свойство копирует строку документации fget (если она существует). Это позволяет легко создавать свойства только для чтения, используя property() в качестве декоратора:

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

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

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

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

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).

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

range([start], stop[, step])¶

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

>>> 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(object)¶: Возвращает строку, содержащую печатное представление объекта. Для многих типов эта функция пытается вернуть строку, которая при передаче в eval() дала бы объект с тем же значением; в противном случае представление – это строка в угловых скобках, содержащая имя типа объекта вместе с дополнительной информацией, часто включающей имя и адрес объекта. Класс может управлять тем, что эта функция возвращает для его экземпляров, определив метод __repr__().

reversed(seq)¶: Возвращает обратный итератор. seq должен быть объектом, который имеет метод __reversed__() или поддерживает протокол последовательности (метод __len__() и метод __getitem__() с целочисленными аргументами, начиная с 0).

round(x[, n])¶

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

Для встроенных типов, поддерживающих round(), значения округляются до ближайшего кратного 10 в степени минус n; если два кратных одинаково близки, округление выполняется в сторону чётного выбора (так, например, и round(0.5), и round(-0.5) равны 0, а round(1.5) равно 2). Возвращаемое значение – целое число, если функция вызвана с одним аргументом, в противном случае – того же типа, что и x.

Примечание

Поведение round() для чисел с плавающей запятой может быть неожиданным: например, round(2.675, 2) даёт 2.67 вместо ожидаемого 2.68. Это не ошибка: это результат того, что большинство десятичных дробей не могут быть представлены точно как float. См. Floating Point Arithmetic: Issues and Limitations для дополнительной информации.

set([iterable]): Возвращает новое множество, опционально с элементами, взятыми из iterable. Тип множество описан в Set Types – set, frozenset.

setattr(object, name, value)¶: Это аналог getattr(). Аргументами являются объект, строка и произвольное значение. Строка может называть существующий атрибут или новый атрибут. Функция присваивает значение атрибуту, если объект это позволяет. Например, setattr(x, 'foobar', 123) эквивалентно x.foobar = 123.

slice([start], stop[, step])¶: Возвращает объект slice, представляющий множество индексов, заданных range(start, stop, step). Аргументы start и step по умолчанию None. Объекты среза имеют атрибуты только для чтения start, stop и step, которые просто возвращают значения аргументов (или значения по умолчанию). Никакой другой явной функциональности у них нет; однако они используются NumPy и другими сторонними расширениями. Объекты среза также создаются при использовании расширенного синтаксиса индексации. Например: a[start:stop:step] или a[start:stop, i]. Смотрите также itertools.islice() для альтернативной версии, возвращающей итератор.

sorted(iterable[, key][, reverse])¶

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

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

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

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

Чтобы преобразовать функцию cmp старого образца в функцию key, см. рецепт CmpToKey в поваренной книге ASPN.

Примеры сортировки и краткое руководство по сортировке см. в Sorting HowTo.

staticmethod(function)¶

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

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

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

Форма @staticmethod является декоратором функции – см. описание определений функций в Function definitions для подробностей.

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

Статические методы в Python похожи на статические методы в Java или C++. Для более продвинутой концепции см. classmethod() в этом разделе.

Для получения дополнительной информации о статических методах обратитесь к документации по стандартной иерархии типов в Стандартная иерархия типов.

str([object[, encoding[, errors]]])¶

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

Если указаны encoding и/или errors, str() декодирует object, который может быть либо байтовой строкой, либо символьным буфером, используя кодек для encoding. Параметр encoding – это строка, задающая имя кодировки; если кодировка неизвестна, возбуждается LookupError. Обработка ошибок выполняется в соответствии с errors; этот параметр определяет обращение с символами, недопустимыми во входной кодировке. Если errors равно 'strict' (по умолчанию), при ошибках возбуждается ValueError, тогда как значение 'ignore' приводит к игнорированию ошибок без уведомления, а значение 'replace' приводит к использованию официального заменяющего символа Unicode U+FFFD для замены входных символов, которые не могут быть декодированы. См. также модуль codecs.

Если указан только object, возвращает его хорошо читаемое строковое представление. Для строк это сама строка. Отличие от repr(object) в том, что str(object) не всегда пытается вернуть строку, которую можно передать в eval(); его цель – вернуть печатаемую строку. Без аргументов возвращает пустую строку.

Объекты могут определять, что возвращает str(object), путём определения специального метода __str__().

Дополнительную информацию о строках см. в Sequence Types – str, bytes, bytearray, list, tuple, range, где описывается функциональность последовательностей (строки являются последовательностями), а также строковые методы, описанные в разделе Строковые методы. Для вывода форматированных строк см. раздел Форматирование строк. Кроме того, см. раздел Строковые сервисы.

sum(iterable[, start])¶

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

Для некоторых случаев использования есть хорошие альтернативы sum(). Предпочтительный и быстрый способ объединения последовательности строк – вызов ''.join(sequence). Для сложения чисел с плавающей запятой с расширенной точностью см. math.fsum(). Чтобы объединить несколько итерабельных объектов, рассмотрите использование itertools.chain().

super([type[, object-or-type]])¶

Возвращает прокси-объект, который делегирует вызовы методов родительскому или родственному классу относительно type. Это полезно для доступа к унаследованным методам, которые были переопределены в классе. Порядок поиска такой же, как используется в getattr(), за исключением того, что сам type пропускается.

Атрибут __mro__ объекта type содержит порядок поиска метода при разрешении, используемый как getattr(), так и super(). Этот атрибут является динамическим и может изменяться при каждом обновлении иерархии наследования.

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

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

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

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

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

Обратите внимание, что super() реализован как часть процесса связывания для явного поиска атрибутов через точки, например super().__getitem__(name). Это достигается за счет реализации собственного метода __getattribute__() для поиска классов в предсказуемом порядке, поддерживающем кооперативное множественное наследование. Соответственно, super() не определен для неявного поиска с помощью операторов или инструкций, таких как super()[name].

Также обратите внимание, что super() не ограничивается использованием внутри методов. Двухаргументная форма задаёт аргументы явно и создаёт соответствующие ссылки. Безаргументная форма автоматически ищет в стеке вызовов класс (__class__) и первый аргумент.

tuple([iterable])¶

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

tuple – неизменяемый тип последовательности, как описано в разделе Типы последовательностей – str, bytes, bytearray, list, tuple, range.

type(object)¶

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

Для проверки типа объекта рекомендуется использовать встроенную функцию isinstance(), поскольку она учитывает подклассы.

С тремя аргументами type() работает как конструктор, как описано ниже.

type(name, bases, dict)

Возвращает новый объект типа. Это, по сути, динамическая форма инструкции class. Строка name – это имя класса, которое становится атрибутом __name__; кортеж bases перечисляет базовые классы и становится атрибутом __bases__; а словарь dict – это пространство имён, содержащее определения тела класса, и становится атрибутом __dict__. Например, следующие две инструкции создают идентичные объекты type:

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

vars([object])¶

Без аргумента работает как locals().

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

Примечание

Возвращаемый словарь не следует изменять: последствия для соответствующей таблицы символов не определены. [2]

zip(*iterables)¶

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

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

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

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

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

zip() в сочетании с оператором * можно использовать для распаковки списка:

>>> 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={}, locals={}, fromlist=[], level=0)¶

Примечание

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

Эта функция вызывается оператором import. Её можно заменить (импортировав модуль builtins и присвоив значение builtins.__import__), чтобы изменить семантику оператора import, однако в настоящее время обычно проще использовать перехватчики импорта (см. PEP 302). Прямое использование __import__() – редкость, за исключением случаев, когда требуется импортировать модуль, имя которого известно только во время выполнения.

Функция импортирует модуль name, возможно, используя заданные globals и locals для определения того, как интерпретировать имя в контексте пакета. Параметр fromlist задает имена объектов или подмодулей, которые должны быть импортированы из модуля, заданного name. Стандартная реализация вообще не использует свой аргумент locals, а использует globals только для определения контекста пакета инструкции import.

level указывает, использовать ли абсолютный или относительный импорт. 0 (по умолчанию) означает выполнять только абсолютный импорт. Положительные значения level указывают количество родительских каталогов для поиска относительно каталога модуля, вызывающего __import__().

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

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

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

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

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

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

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

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

Здесь модуль spam.ham возвращается из __import__(). Из этого объекта извлекаются импортируемые имена и присваиваются соответствующим именам.

Если вы просто хотите импортировать модуль (возможно, в составе пакета) по имени, вы можете вызвать __import__(), а затем найти его в sys.modules:

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

Сноски

[1]	Обратите внимание, что анализатор принимает только соглашение о концах строк в стиле Unix. Если вы читаете код из файла, убедитесь, что используете режим преобразования символов новой строки для преобразования концов строк в стиле Windows или Mac.

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