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

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

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(), используя \x, \u или \U экранирования. Это генерирует строку, подобную той, что возвращается repr() в Python 2.

bin(x)

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

class bool([x])

Возвращает булево значение, т.е. одно из True или False. x преобразуется с помощью стандартной процедуры проверки истинности. Если x ложно или опущено, возвращает False; в противном случае возвращает True. Класс bool является подклассом int (см. Числовые типы — int, float, complex). Его нельзя больше наследовать. Его единственными экземплярами являются False и True (см. Булевы значения).

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

Возвращает новый массив байтов. Класс bytearray представляет собой изменяемую последовательность целых чисел в диапазоне 0 <= x < 256. Он обладает большинством обычных методов изменяемых последовательностей, описанных в Изменяемые типы последовательностей, а также большинство методов типа bytes, см. Операции с типами bytes и bytearray.

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

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

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

См. также Бинарные типы последовательностей — bytes, bytearray, memoryview и Объекты Bytearray.

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

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

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

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

См. также Бинарные типы последовательностей — bytes, bytearray, memoryview, Bytes и Операции с типами bytes и bytearray.

callable(object)

Возвращает True, если аргумент object является вызываемым, False, если нет. Если это возвращает true, всё ещё возможно, что вызов завершится ошибкой, но если false, то вызов object никогда не будет успешным. Обратите внимание, что классы вызываемы (вызов класса возвращает новый экземпляр); экземпляры вызываемы, если у их класса есть метод __call__().

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

chr(i)

Возвращает строку, представляющую символ, код Unicode которого — целое число i. Например, chr(97) возвращает строку 'a', а chr(8364) возвращает строку '€'. Это обратное значение ord().

Допустимый диапазон для аргумента — от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). ValueError будет поднята, если i выходит за этот диапазон.

classmethod(function)

Возвращает метод класса для function.

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

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

Форма @classmethod — это функция декоратор — см. описание определений функций в Определения функций для получения более подробной информации.

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

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

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

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

Компилирует 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 является им — будущие операторы, действующие вокруг вызова компиляции, игнорируются.

Будущие операторы определяются битами, которые могут быть побитово объединены для задания нескольких операторов. Битовая маска, необходимая для указания данной функции, может быть найдена как атрибут compiler_flag на объекте _Feature в модуле __future__.

Аргумент optimize определяет уровень оптимизации компилятора; значение по умолчанию -1 выбирает уровень оптимизации интерпретатора, заданный параметрами -O. Явные уровни — 0 (без оптимизации; __debug__ истинно), 1 (утверждения удаляются, __debug__ ложно) или 2 (документация также удаляется).

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

Если вы хотите разобрать код Python в его представление AST, см. ast.parse().

Примечание

При компиляции строки с многострочным кодом в режиме 'single' или 'eval', ввод должен заканчиваться по крайней мере одним символом новой строки. Это необходимо для облегчения обнаружения незавершенных и завершенных операторов в модуле code.

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

Изменено в версии 3.5: Ранее при обнаружении нулевых байтов в source поднималось исключение TypeError.

class complex([real[, imag]])

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

Примечание

При преобразовании из строки, строка не должна содержать пробелы вокруг центрального + или - оператора. Например, complex('1+2j') подходит, но complex('1 + 2j') вызывает ValueError.

Тип комплексных чисел описан в Числовые типы — int, float, complex.

delattr(object, name)

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Создаёт новый словарь. Объект dict является классом словаря. Обратитесь к dict и Типы отображений — dict для документации по этому классу.

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

dir([object])

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

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

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

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

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

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

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module # doctest: +SKIP
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Примечание

Так как dir() в основном предназначен для удобства использования в интерактивной оболочке, он пытается предоставить более интересный набор имён, чем строго или последовательно определённый набор имён, и его подробное поведение может меняться между версиями. Например, атрибуты метакласса не попадают в список результатов, когда аргументом является класс.

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.

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

Эквивалентно:

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

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

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

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

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

Эта функция также может использоваться для выполнения произвольных объектов кода (таких, как те, что созданы функцией compile()). В этом случае передайте объект кода вместо строки. Если объект кода был скомпилирован с 'exec' в качестве аргумента mode, возвращаемое значение функции 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, он может быть любым объектом отображения. Помните, что на уровне модуля глобальные и локальные переменные — это один и тот же словарь. Если exec получает два отдельных объекта в качестве globals и locals, код будет выполняться так, как если бы он был вложен в определение класса.

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

Примечание

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

Примечание

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

filter(function, iterable)

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

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

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

class float([x])

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

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

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

Здесь floatnumber представляет собой форму Python-литерала с плавающей точкой, описанную в Литералы с плавающей точкой. Регистр не имеет значения, поэтому, например, «inf», «Inf», «INFINITY» и «iNfINity» — все приемлемые варианты написания для положительной бесконечности.

В противном случае, если аргумент — целое число или число с плавающей точкой, возвращается число с плавающей точкой с тем же значением (в пределах точности плавающей точки Python). Если аргумент выходит за пределы диапазона Python float, возникает OverflowError.

Для общего Python-объекта x, float(x) делегирует x.__float__().

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

Примеры:

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

Тип float описан в Числовые типы — int, float, complex.

format(value[, format_spec])

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

По умолчанию format_spec — это пустая строка, что обычно даёт тот же эффект, что и вызов str(value).

Вызов format(value, format_spec) переводится в type(value).__format__(value, format_spec), что обходит словарь экземпляра при поиске метода __format__() значения. Исключение TypeError генерируется, если поиск метода достигает object и format_spec не пустая, или если format_spec или возвращаемое значение не являются строками.

Изменено в версии 3.4: object().__format__(format_spec) вызывает TypeError, если format_spec не пустая строка.

class frozenset([iterable])

Возвращает новый объект frozenset, необязательно с элементами, взятыми из iterable. frozenset — встроенный класс. См. frozenset и Типы множеств — set, frozenset для документации по этому классу.

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

getattr(object, name[, default])

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

globals()

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

hasattr(object, name)

Аргументы — объект и строка. Результат — True если строка — имя одного из атрибутов объекта, False — если нет. (Это реализуется вызовом getattr(object, name) и проверкой, вызывает ли он AttributeError или нет.)

hash(object)

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

Примечание

Для объектов с пользовательскими методами __hash__() обратите внимание, что hash() усекает возвращаемое значение в соответствии с разрядностью битовой ширины хостовой машины. См. __hash__() для получения подробностей.

help([object])

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

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

Изменено в версии 3.4: Изменения в pydoc и inspect означают, что сообщаемые сигнатуры вызываемых объектов теперь более полные и согласованные.

hex(x)

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

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

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

См. также int() для преобразования шестнадцатеричной строки в целое число с основанием 16.

Примечание

Чтобы получить шестнадцатеричное строковое представление для числа с плавающей точкой, используйте метод 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() будет использовать его для предоставления расширенных возможностей редактирования строк и истории.

class int(x=0)

class int(x, base=10)

Возвращает объект целого типа, построенный из числа или строки x, или возвращает 0, если аргументы не заданы. Если x является числом, возвращает x.__int__(). Для чисел с плавающей точкой происходит отбрасывание дробной части.

Если x не является числом или если задан base, то x должен быть строкой, объектом bytes или bytearray, представляющим целое числовое литерал в системе счисления base. Литерал может необязательно предваряться + или - (без пробела) и окружён пробелами. Литерал в системе счисления base-n состоит из цифр от 0 до n-1, где a до z (или A до Z) имеют значения от 10 до 35. По умолчанию base равен 10. Разрешенные значения 0 и 2–36. Литералы в системах счисления 2, 8 и 16 могут необязательно предваряться 0b/0B, 0o/0O, или 0x/0X, как и целые литералы в коде. Значение 0 для base означает интерпретацию точно как литерала кода, так что фактическое основание равно 2, 8, 10 или 16, и int('010', 0) не является допустимым, а int('010') является допустимым, так же как и int('010', 8).

Тип целых чисел описан в Числовые типы — int, float, complex.

Изменено в версии 3.4: Если base не является экземпляром int и объект base имеет метод base.__index__, то вызывается этот метод для получения целого числа для основания. В предыдущих версиях использовался метод base.__int__ вместо base.__index__.

isinstance(object, classinfo)

Возвращает истину, если аргумент object является экземпляром аргумента classinfo или (прямого, косвенного или виртуального) подкласса thereof. Если object не является объектом данного типа, функция всегда возвращает ложь. Если classinfo является кортежем объектов типов (или рекурсивно, других подобных кортежей), возвращает истину, если object является экземпляром любого из этих типов. Если classinfo не является типом или кортежем типов и таких кортежей, возбуждается исключение TypeError.

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

См. также Типы итераторов.

Одно полезное применение второй формы iter() — это чтение строк файла до достижения определённой строки. Следующий пример читает файл, пока метод readline() не вернёт пустую строку:

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

len(s)

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

class list([iterable])

list — это на самом деле изменяемый тип последовательностей, как описано в Списки и Типы последовательностей — list, tuple, range.

locals()

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

Примечание

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

map(function, iterable, ...)

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

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

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

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

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

Есть два необязательных аргумента только с ключевыми словами. Аргумент key задаёт функцию упорядочения с одним аргументом, как и используется для list.sort(). Аргумент default задаёт объект, который должен быть возвращён, если предоставленный итерируемый объект пустой. Если итерируемый объект пустой и default не указан, генерируется исключение ValueError.

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

Введено в версии 3.4: Необязательный аргумент default только с ключевыми словами.

memoryview(obj)

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

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

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

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

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

Есть два необязательных аргумента только с ключевыми словами. Аргумент key задаёт функцию упорядочения с одним аргументом, как и используется для list.sort(). Аргумент default задаёт объект, который должен быть возвращён, если предоставленный итерируемый объект пустой. Если итерируемый объект пустой и default не указан, генерируется исключение ValueError.

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

Введено в версии 3.4: Необязательный аргумент default только с ключевыми словами.

next(iterator[, default])

Получает следующий элемент из iterator, вызывая его метод __next__(). Если задан default, он возвращается, если итератор исчерпан, в противном случае генерируется StopIteration.

class object

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

Примечание

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

oct(x)

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

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

Открыть файл и вернуть соответствующий объект файла. Если файл не может быть открыт, возникает OSError.

Файл — это либо строка или байтовый объект, содержащий путь к файлу (абсолютный или относительный к текущей рабочей директории), либо целочисленный дескриптор файла, который нужно обернуть. (Если указан дескриптор файла, он будет закрыт при закрытии возвращённого объекта ввода-вывода, если только closefd не установлено в False.)

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

Символ	Значение
'r'	открытие для чтения (по умолчанию)
'w'	открытие для записи, сначала обнуляя файл
'x'	открытие для исключительного создания, с отказом, если файл уже существует
'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 — это необязательная строка, указывающая, как должны обрабатываться ошибки кодирования и декодирования — это не может использоваться в двоичном режиме. Доступно множество стандартных обработчиков ошибок (перечислены в Обработчиках ошибок), хотя любое имя обработки ошибок, зарегистрированное с помощью codecs.register_error(), также допустимо. Стандартные имена включают:

• 'strict' для повышения исключения ValueError, если произошла ошибка кодирования. Значение по умолчанию None имеет тот же эффект.
• 'ignore' игнорирует ошибки. Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.
• 'replace' вставляет маркер замены (такой как '?') там, где есть некорректные данные.
• 'surrogateescape' представляет любые неправильные байты как код-точки в области приватного использования Юникода в диапазоне от U+DC80 до U+DCFF. Эти приватные код-точки затем преобразуются обратно в те же байты, когда используется обработчик ошибок surrogateescape при записи данных. Это полезно для обработки файлов неизвестной кодировки.
• 'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей XML-ссылкой на символ &#nnn;.
• 'backslashreplace' заменяет неправильные данные обратными слешами Python.
• 'namereplace' (также поддерживается только при записи) заменяет недопустимые символы экранированными последовательностями \N{...}.

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

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

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

Пользовательский открыватель может использоваться, передавая вызываемый объект как opener. Базовый дескриптор файла для объекта файла затем получается путем вызова opener с (file, flags). opener должен возвращать открытый дескриптор файла (передача os.open в качестве opener приводит к функциональности, аналогичной передаче None).

Созданный файл не может быть унаследован.

В следующем примере используется параметр dir_fd функции os.open() для открытия файла относительно заданной директории:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

Тип объекта файла объекта файла, возвращаемого функцией 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.

Изменено в версии 3.3: Добавлен параметр opener. Добавлена 'x' режим. IOError теперь является псевдонимом для OSError. Если файл открыт в режиме эксклюзивного создания ('x') и уже существует, то возбуждается FileExistsError.

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

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

Изменено в версии 3.5: Если системный вызов прерван, а обработчик сигнала не вызывает исключение, функция теперь повторно выполняет системный вызов вместо возбуждения исключения InterruptedError (см. PEP 475 для обоснования).

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

ord(c)

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

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(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

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

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

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

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

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

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

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

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

Типичное использование — определение управляемого атрибута x:

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 вызовет getter, c.x = value вызовет setter, а del c.x — deleter.

Если задано, doc будет строкой документации атрибута property. В противном случае property скопирует строку документации fget (если она существует). Это позволяет легко создавать read-only свойства с помощью property() в качестве декоратора:

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

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

Декоратор @property преобразует метод voltage() в «getter» для read-only атрибута с тем же именем, и задаёт строку документации для voltage как «Получить текущее напряжение».

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

class C:
    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 в данном случае.)

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

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

range(stop)

range(start, stop[, step])

Вместо того, чтобы быть функцией, range фактически является неизменяемым типом последовательности, как описано в Диапазонах и Типы последовательностей — list, tuple, range.

repr(object)

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

reversed(seq)

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

round(number[, ndigits])

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

Для встроенных типов, поддерживающих round(), значения округляются до ближайшего кратного 10 в степени минус ndigits; если два кратных одинаково близки, округление выполняется в сторону чётного выбора (например, как round(0.5) и round(-0.5) являются 0, а round(1.5) является 2). Любое целое значение является допустимым для ndigits (положительное, нулевое или отрицательное). Значение возврата — целое число, если вызывается с одним аргументом, в противном случае — того же типа, что и number.

Для общего Python объекта number, round(number, ndigits) делегирует вызов number.__round__(ndigits).

Примечание

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

class set([iterable])

Возвращает новый объект set, необязательно с элементами, взятыми из iterable. set — встроенный класс. См. set и Типы множеств — set, frozenset для документации по этому классу.

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

setattr(object, name, value)

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

class slice(stop)

class slice(start, stop[, step])

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

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

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

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

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

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

Используйте functools.cmp_to_key() для преобразования функции cmp старой формы в функцию key.

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

Примеры сортировки и краткий учебник по сортировке см. в Руководство по сортировке.

staticmethod(function)

Возвращает статический метод для function.

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

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

Форма @staticmethod — это декоратор функции — см. описание определения функций в Определения функций для получения подробностей.

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

Статические методы в Python похожи на те, что встречаются в Java или C++. Также см. classmethod() для варианта, который полезен для создания альтернативных конструкторов классов.

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

class str(object='')

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

Возвращает строковое представление объекта. См. str для получения подробностей.

str — встроенный строковый класс. Для общей информации о строках см. Тип текстовой последовательности — str.

sum(iterable[, start])

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

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

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

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

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

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

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

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

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

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

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

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

Практические рекомендации по проектированию кооперативных классов с использованием super() см. в руководстве по использованию super().

tuple([iterable])

tuple — это не функция, а фактически неизменяемый тип последовательности, как описано в Кортежах и Типы последовательностей — список, кортеж, диапазон.

class type(object)

class type(name, bases, dict)

С одним аргументом возвращает тип объекта. Значение возврата — объект типа и, как правило, такой же объект, как и возвращаемый object.__class__.

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

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

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

См. также Объекты типа.

vars([object])

Возвращает атрибут __dict__ для модуля, класса, экземпляра или любого другого объекта с атрибутом __dict__.

У объектов, таких как модули и экземпляры, есть обновляемый атрибут __dict__; однако у других объектов могут быть ограничения на запись в их атрибутах __dict__ (например, классы используют types.MappingProxyType, чтобы предотвратить прямые обновления словаря).

Без аргумента vars() действует как locals(). Обратите внимание, что словарь locals полезен только для чтения, так как обновления словаря locals игнорируются.

zip(*iterables)

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

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

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

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

zip() следует использовать только с входными данными неравной длины, когда вас не интересуют хвостовые несовпавшие значения из более длинных итерируемых объектов. Если эти значения важны, используйте 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=None, locals=None, fromlist=(), level=0)

Примечание

Это расширенная функция, которая не нужна в повседневной работе с Python, в отличие от importlib.import_module().

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

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

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

Когда переменная 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__(). Из этого объекта извлекаются имена для импорта и присваиваются соответствующим именам.

Если вам просто нужно импортировать модуль (возможно, внутри пакета) по имени, используйте importlib.import_module().

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

Примечания