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

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

		Встроенные функции
`abs()`	`dict()`	`help()`	`min()`	`setattr()`
`all()`	`dir()`	`hex()`	`next()`	`slice()`
`any()`	`divmod()`	`id()`	`object()`	`sorted()`
`ascii()`	`enumerate()`	`input()`	`oct()`	`staticmethod()`
`bin()`	`eval()`	`int()`	`open()`	`str()`
`bool()`	`exec()`	`isinstance()`	`ord()`	`sum()`
`bytearray()`	`filter()`	`issubclass()`	`pow()`	`super()`
`bytes()`	`float()`	`iter()`	`print()`	`tuple()`
`callable()`	`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()`

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

all(итерируемый объект)¶

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

python

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

any(итерируемый объект)¶

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

python

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

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

bin(x)¶

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

text

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Если требуется префикс “0b” или нет, можно использовать один из следующих способов.

text

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

См. также format() для получения дополнительной информации.

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

classbytearray([source[, encoding[, errors]]])

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

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

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

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

См. также Binary Sequence Types – bytes, bytearray, memoryview и Bytearray Objects.

classbytes([source[, encoding[, errors]]])

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

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

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

См. также Binary Sequence Types – bytes, bytearray, memoryview, Bytes Objects и Bytes and Bytearray Operations.

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

Преобразует метод в метод класса.

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

python

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

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

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

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

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

compile(исходный код, имя файла, режим, флаги=0, dont_inherit=False, оптимизация=-1)¶

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

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

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

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

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

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

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

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

Примечание

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

Предупреждение

Возможно аварийное завершение интерпретатора Python при компиляции достаточно большой/сложной строки в объект AST из-за ограничений глубины стека в компиляторе AST Python.

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

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

classcomplex([real[, imag]])¶

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

Примечание

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

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

Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.

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

classdict(**kwarg)

classdict(отображение, **kwarg)

classdict(итерируемый объект, **kwarg)

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

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

dir([объект])¶

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

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

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

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

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

Результирующий список отсортирован по алфавиту. Например:

text

>>> import struct
>>> dir()   # показать имена в пространстве имён модуля
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct 
['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(итерируемый объект, start=0)¶

Возвращает объект enumerate. iterable должен быть последовательностью, итератором или другим объектом, поддерживающим итерацию. Метод __next__() итератора, возвращаемого enumerate(), возвращает кортеж, содержащий счётчик (начиная с start, который по умолчанию равен 0) и значения, полученные при итерации по iterable.

text

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

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

python

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

eval(выражение, globals=None, locals=None)¶

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

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

text

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

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

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

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

exec(объект[, globals[, locals]])¶

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

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

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

Примечание

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

Примечание

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

filter(функция, итерируемый объект)¶

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

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

Смотрите itertools.filterfalse() для дополнительной функции, которая возвращает элементы итерируемого объекта, для которых функция возвращает ложь.

classfloat([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, будет возбуждено OverflowError.

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

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

Примеры:

python

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

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

Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.

format(значение[, format_spec])¶

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

Значение 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 не является пустой строкой.

classfrozenset([iterable])

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

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

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

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

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

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

Примечание

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

help([объект])¶

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

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

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

hex(x)¶

Преобразует целое число в строку шестнадцатеричного представления в нижнем регистре с префиксом “0x”. Если x не является объектом int Python, он должен определять метод __index__(), возвращающий целое число. Несколько примеров:

text

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

Если вы хотите преобразовать целое число в шестнадцатеричную строку в верхнем или нижнем регистре с префиксом или без, можно воспользоваться одним из следующих способов:

text

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

См. также format() для получения дополнительной информации.

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

Примечание

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

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

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

input([приглашение])¶

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

python

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

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

classint(x=0)¶

classint(x, base=10)

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

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

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

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

Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.

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

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

iter(объект[, sentinel])¶

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

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

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

python

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

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

classlist([iterable]): list на самом деле является изменяемым типом последовательности, а не функцией, как описано в Списки и Типы последовательностей – list, tuple, range.

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

Примечание

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

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

max(итерируемый объект, *[, ключ, значение по умолчанию])¶

max(arg1, arg2, *args[, ключ])

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

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

Есть два необязательных именованных аргумента. Аргумент 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(итерируемый объект, *[, ключ, значение по умолчанию])¶

min(arg1, arg2, *args[, ключ])

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

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

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

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

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

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

Примечание

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

oct(x)¶

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

text

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Чтобы преобразовать целое число в восьмеричную строку с префиксом «0o» или без него, можно использовать один из следующих способов.

text

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

См. также format() для получения дополнительной информации.

open(файл, режим='r', буферизация=-1, кодировка=None, ошибки=None, новая строка=None, closefd=True, opener=None)¶

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

file – это путеподобный объект, задающий путь (абсолютный или относительный к текущей рабочей директории) к открываемому файлу или целочисленный файловый дескриптор оборачиваемого файла. (Если передан файловый дескриптор, он закрывается при закрытии возвращаемого объекта ввода-вывода, если только 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' будет представлять любые некорректные байты как кодовые точки в области частного использования Unicode в диапазоне от U+DC80 до U+DCFF. Затем эти частные кодовые точки будут преобразованы обратно в те же байты при использовании обработчика ошибок surrogateescape при записи данных. Это полезно для обработки файлов в неизвестной кодировке.
'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей XML-ссылкой на символ &#nnn;.
'backslashreplace' заменяет повреждённые данные escape-последовательностями Python с обратной косой чертой.
'namereplace' (также поддерживается только при записи) заменяет неподдерживаемые символы escape-последовательностями \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() для открытия файла относительно заданного каталога:

python

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

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

FileExistsError теперь вызывается, если файл, открытый в эксклюзивном режиме создания ('x'), уже существует.

Изменено в версии 3.4:

Файл теперь не наследуется.

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

Изменено в версии 3.5:

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

Был добавлен обработчик ошибок 'namereplace'.

Изменено в версии 3.6:

Добавлена поддержка принятия объектов, реализующих os.PathLike.

В Windows открытие буфера консоли может вернуть подкласс io.RawIOBase, отличный от io.FileIO.

ord(c)¶: Принимает строку, представляющую один символ Unicode, и возвращает целое число, представляющее кодовую точку Unicode этого символа. Например, 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(*объекты, разделитель=' ', окончание='\n', файл=sys.stdout, сброс=False)¶

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

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

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

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

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

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

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

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

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

python

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

python

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

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

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

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

python

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

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

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

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

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

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

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

range(stop)
range(start, stop[, step]): На самом деле range – это не функция, а неизменяемый тип последовательности, как описано в Ranges и Sequence Types – list, tuple, range.

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

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

round(число[, ndigits])¶

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

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

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

Примечание

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

classset([iterable])

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

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

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

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

sorted(итерируемый объект, *, ключ=None, обратный порядок=False)¶

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

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

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

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

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

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

Для примеров сортировки и краткого руководства по сортировке см. Sorting HOW TO.

@staticmethod¶

Преобразует метод в статический метод.

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

python

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

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

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

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

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

python

class C:
    builtin_open = staticmethod(open)

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

class str(объект='')

class str(объект=b'', кодировка='utf-8', ошибки='strict')

Возвращает str версию объекта object. Подробнее см. str().

str – это встроенный строковый класс. Общую информацию о строках см. в Текстовый тип последовательности – str.

sum(итерируемый объект[, начальное значение])¶

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

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

super([тип[, объект или тип]])¶

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

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

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

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

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

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

python

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

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

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

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

tuple([итерируемый объект]): tuple – это не функция, а неизменяемый тип последовательности, как описано в Кортежах и Типы последовательностей – list, tuple, range.

classtype(объект)¶

class type(name, bases, dict)

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

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

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

text

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

См. также Type Objects.

Изменено в версии 3.6: Подклассы type, которые не переопределяют type.__new__, больше не могут использовать форму с одним аргументом для получения типа объекта.

vars([объект])¶

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

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

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

zip(*iterables)¶

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

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

python

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

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

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

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

python

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

__import__(имя, globals=None, locals=None, fromlist=(), level=0)¶

Примечание

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

Эта функция вызывается оператором import. Её можно заменить (импортировав модуль builtins и присвоив builtins.__import__), чтобы изменить семантику оператора import, но делать это настоятельно не рекомендуется, так как обычно проще использовать хуки импорта (см. 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 приводит к байт-коду, похожему на следующий код:

python

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

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

python

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

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

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

python

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

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

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

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

Сноски

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

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

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