Встроенные функции Python: полный справочник

В Python есть около семидесяти имён, которые можно вызвать, ни разу не написав строку import. Они живут в модуле builtins, который интерпретатор автоматически подмешивает в пространство имён каждого модуля — именно поэтому len([1, 2, 3]) работает где угодно без всякой настройки. В этом руководстве разобраны все 63 самые востребованные встроенные функции (включая конструкторы вроде dict(), list() и set() — в CPython они ведут себя точно как функции, хотя формально являются объектами типов), с рабочими примерами, реальным выводом и подводными камнями, на которые реально натыкаются на практике.

Если хотите сами посмотреть на полный список:

import builtins
print(dir(builtins))

А чтобы убедиться, что конкретное имя действительно встроенное, а не определено в вашем собственном файле, проверьте vars(builtins) или просто 'sorted' in dir(builtins).

Числа и математика

abs()

Возвращает модуль числа — расстояние от нуля, без учёта знака.

print(abs(-7), abs(3.5), abs(3 + 4j))

7 3.5 5.0

Для комплексного числа abs() возвращает модуль в виде float, поэтому abs(3 + 4j) равно 5.0, а не целому числу.

bin()

Преобразует целое число в его двоичное строковое представление с префиксом 0b.

print(bin(10), bin(-10))

0b1010 -0b1010

Подвох: результат — это str, а не число, а у отрицательных чисел просто ставится знак минус впереди, а не используется представление в дополнительном коде. Уберите префикс через bin(10)[2:] или используйте format(10, "08b"), если нужен вывод фиксированной ширины.

divmod()

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

q, r = divmod(47, 5)
print(q, r)

9 2

Подвох: для отрицательных чисел Python округляет деление вниз, поэтому divmod(-7, 2) даёт (-4, 1), а не (-3, -1).

pow()

Вычисляет base ** exp, а с третьим аргументом выполняет быстрое модульное возведение в степень — критично важно для криптографии.

print(pow(2, 10))
print(pow(4, 13, 497))

1024
445

Используйте pow(base, exp, mod) вместо (base ** exp) % mod для больших показателей степени — это намного быстрее и не строит гигантское промежуточное число.

round()

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

print(round(2.5), round(3.5), round(3.14159, 2))

2 4 3.14

Подвох: round(2.5) равно 2, а не 3 — почти всех это удивляет в первый раз.

hex()

Преобразует целое число в его шестнадцатеричное строковое представление с префиксом 0x.

print(hex(255))

0xff

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

float()

Преобразует значение в число с плавающей точкой или разбирает его из строки.

print(float("3.14"), float(10))

3.14 10.0

Подвох: float("nan") и float("inf") — валидные значения, всегда проверяйте пользовательский числовой ввод.

int()

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

print(int(3.9), int("101", 2))

3 5

Используйте int(x, base), чтобы разбирать шестнадцатеричные/двоичные/восьмеричные строки без ручной арифметики.

Приведение типов в Python: явное и неявное

int(), float(), str(), bool(), list() и tuple() — это функции явного приведения типа: вы сами указываете целевой тип. Python также выполняет неявное приведение, но только между числовыми типами, и только когда информация не теряется:

print(3 + 2.0)          # int is widened to float -> 5.0
print(True + 1)         # bool is a subclass of int -> 2
print("2" + 2)          # TypeError: no implicit str/int conversion

Python никогда неявно не преобразует строку в число и наоборот, поэтому input() всегда требует явного приведения: age = int(input("Age: ")). Для ваших собственных классов неявного приведения тоже нет — определите __int__, __float__, __str__ или __bool__, и соответствующая встроенная функция воспользуется ими при явном вызове.

Итерируемые объекты и последовательности

any()

Функция any() в Python возвращает True, если хотя бы один элемент итерируемого объекта истинен, и False в противном случае.

print(any([0, "", None, 4]))
print(any([]))

True
False

Стоит запомнить две вещи: any([]) для пустого итерируемого объекта равно False, а any() работает по короткому замыканию — она прекращает обход на первом же истинном элементе, поэтому any(is_valid(x) for x in huge_list) никогда не вычисляет больше, чем нужно. Передавайте генераторное выражение, а не списковое включение, чтобы сохранить это преимущество.

all()

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

print(all([1, "text", [0]]))
print(all([1, 0, 2]))
print(all([]))

True
False
True

Подвох: all([]) равно True, а не False. «Вакуумная истина» подводит в коде валидации — all(rule(x) for x in items) проходит, если items пуст, поэтому проверяйте пустоту отдельно, если это важно.

enumerate()

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

for i, name in enumerate(["a", "b", "c"], start=1):
    print(i, name)

1 a
2 b
3 c

Используйте, когда в цикле нужны и индекс, и значение — это чище, чем range(len(x)).

zip()

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

names = ["Alice", "Bob"]
ages = [30, 25]
print(list(zip(names, ages)))

[('Alice', 30), ('Bob', 25)]

Подвох: несовпадающие длины молча обрезаются — используйте itertools.zip_longest, если это не то, что нужно.

map()

Применяет функцию к каждому элементу итерируемого объекта, возвращая ленивый итератор.

print(list(map(str.upper, ["a", "b", "c"])))

['A', 'B', 'C']

Используйте, когда списковое включение свелось бы просто к [f(x) for x in xs] — часто map(f, xs) читается чище для простых преобразований.

filter()

Оставляет только те элементы, для которых функция возвращает истинное значение.

print(list(filter(lambda x: x % 2 == 0, range(10))))

[0, 2, 4, 6, 8]

Передача None вместо функции сразу отфильтровывает ложные значения: filter(None, [0, 1, "", "x"]).

sorted()

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

print(sorted(["banana", "apple", "cherry"], key=len))

['apple', 'banana', 'cherry']

Используйте key= вместо собственного компаратора — это быстрее и идиоматично. Добавьте reverse=True для сортировки по убыванию.

reversed()

Возвращает обратный итератор по последовательности без копирования.

print(list(reversed([1, 2, 3])))

[3, 2, 1]

Работает с любым объектом, реализующим __reversed__ или поддерживающим индексацию — но не с произвольными итераторами.

range()

Создаёт неизменяемую, экономную по памяти последовательность целых чисел, вычисляемую лениво.

print(list(range(2, 10, 2)))

[2, 4, 6, 8]

Объекты range не хранят все значения в памяти — range(10**18) создаётся мгновенно.

len()

Возвращает количество элементов в контейнере, вызывая его метод __len__.

print(len("hello"), len([1, 2, 3]))

5 3

Подвох: выбрасывает TypeError на объектах без __len__, включая обычные итераторы и генераторы.

sum()

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

print(sum([1, 2, 3], 100))

106

Избегайте sum() для конкатенации строк — используйте "".join(), это значительно быстрее.

min() и max()

Возвращают наименьший/наибольший элемент, опционально по своему key.

words = ["kiwi", "banana", "fig"]
print(min(words, key=len), max(words, key=len))

fig banana

Обе функции принимают и несколько позиционных аргументов: max(3, 7, 2).

iter()

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

it = iter([1, 2, 3])
print(next(it), next(it))

1 2

Двухаргументная форма iter(callable, sentinel) — чистый способ читать файл или поток до маркера-разделителя.

next()

Продвигает итератор и возвращает следующий элемент, с опциональным значением по умолчанию.

it = iter([])
print(next(it, "done"))

done

Без значения по умолчанию next() выбрасывает StopIteration при исчерпании итератора — всегда передавайте значение по умолчанию, если не уверены.

slice()

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

s = slice(1, 5, 2)
print([0, 1, 2, 3, 4, 5, 6][s])

[1, 3]

Используйте именованные объекты slice, чтобы документировать намерение, когда логика индексации усложняется (например, при разборе полей фиксированной ширины).

Конструкторы типов

bool()

Преобразует любой объект в True или False по тем же правилам истинности, которые Python применяет в инструкции if.

print(bool(0), bool(""), bool([]), bool("0"), bool([0]))

False False False True True

Подвох: bool("0") и bool([0]) оба равны True — непустая строка или список истинны независимо от содержимого. По умолчанию ложны только None, нулевые числа и пустые контейнеры.

bytes()

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

print(bytes("héllo", "utf-8"))
print(bytes([72, 105]))
print(bytes(3))

b'h\xc3\xa9llo'
b'Hi'
b'\x00\x00\x00'

Три формы вызова часто путают: из строки нужно обязательно указать кодировку, из итерируемого объекта целых чисел получаются именно эти байты, а из «голого» числа n получается n нулевых байтов, а не само число.

bytearray()

Изменяемый аналог bytes() — те же конструкторы, но с возможностью присваивания.

buf = bytearray(5)
buf[0] = 0xFF
buf[1:3] = b"\xAA\xAA"
print(buf)

bytearray(b'\xff\xaa\xaa\x00\x00')

Чтобы заполнить весь буфер одним повторяющимся байтом, обойдите цикл: bytearray(b"\xff" * 1024) намного быстрее, чем присваивание по элементу.

str()

Преобразует любой объект в его удобочитаемую строковую форму через __str__.

print(str(3.14), str([1, 2]))

3.14 [1, 2]

Отличается от repr(): str() ориентирован на читаемость, repr() — на однозначное восстановление объекта.

list()

Строит список из любого итерируемого объекта или пустой список без аргументов.

print(list("abc"), list(range(3)))

['a', 'b', 'c'] [0, 1, 2]

Используйте list(x), чтобы материализовать генератор или результат map/filter, который нужно перебрать больше одного раза.

dict()

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

print(dict(a=1, b=2), dict([("x", 1), ("y", 2)]))

{'a': 1, 'b': 2} {'x': 1, 'y': 2}

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

set()

Строит неупорядоченную коллекцию уникальных хешируемых элементов.

print(set([1, 2, 2, 3]))

{1, 2, 3}

Используйте для проверки принадлежности за O(1) и дедупликации — x in my_set обгоняет x in my_list на больших коллекциях.

frozenset()

Неизменяемая, хешируемая версия set — её можно использовать как ключ словаря или элемент множества.

fs = frozenset([1, 2, 3])
print(hash(fs) is not None)

True

Используйте, когда нужно значение, похожее на множество, но само по себе хешируемое, например в качестве ключа кэша.

tuple()

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

print(tuple([1, 2, 3]))

(1, 2, 3)

Кортежи хешируемы, если хешируемо их содержимое — это делает их естественными ключами словарей и элементами множеств.

memoryview()

Открывает доступ к памяти буфера без копирования — критично важно для производительности при работе с большими бинарными данными.

data = bytearray(b"hello")
mv = memoryview(data)
mv[0] = ord("H")
print(data)

bytearray(b'Hello')

Используйте при многократном срезании больших объектов bytes/bytearray — memoryview избегает копирования, которое иначе происходило бы при каждом срезе.

object()

Создаёт «голый» экземпляр базового класса, от которого наследуется любой объект в Python.

sentinel = object()
print(sentinel is object())

False

Классическое применение — уникальное «сигнальное» значение, гарантированно не равное ничему другому, полезное как маркер по умолчанию вместо None.

Интроспекция и атрибуты

type()

Возвращает тип объекта, а с тремя аргументами — динамически создаёт новый класс.

print(type(42), type("hi"))
Dynamic = type("Dynamic", (object,), {"x": 1})
print(Dynamic().x)

<class 'int'> <class 'str'>
1

Трёхаргументная форма — это способ, которым метаклассы и ORM генерируют классы во время выполнения.

isinstance()

Проверяет, является ли объект экземпляром класса или любого из кортежа классов.

print(isinstance(5, (int, float)))

True

Предпочитайте isinstance() вместо type(x) == SomeClass — она учитывает наследование и утиную типизацию.

issubclass()

Проверяет отношение между классами, а не между экземплярами.

print(issubclass(bool, int))

True

Подвох: в Python bool — подкласс int, поэтому True == 1 вычисляется в True.

dir()

Выводит имена в текущей области видимости или атрибуты/методы объекта.

print([n for n in dir([]) if not n.startswith("_")][:5])

['append', 'clear', 'copy', 'count', 'extend']

Отлично подходит для интерактивного исследования в REPL, но не является надёжным API-контрактом — для инструментов используйте модуль inspect.

vars()

Возвращает __dict__ объекта или ведёт себя как locals() без аргументов.

class P:
    def __init__(self):
        self.x = 1
print(vars(P()))

{'x': 1}

Не работает на объектах, использующих __slots__, поскольку у них нет __dict__.

callable()

Показывает, можно ли вызвать объект с () — функции, классы и любой экземпляр, определяющий __call__.

class Adder:
    def __call__(self, x): return x + 1

print(callable(len), callable(Adder), callable(Adder()), callable(42))

True True True False

Обратите внимание: callable(SomeClass) равно True, потому что вызов класса создаёт экземпляр.

hasattr()

Проверяет, существует ли у объекта атрибут, не выбрасывая исключение.

print(hasattr("hi", "upper"), hasattr("hi", "nope"))

True False

Внутри просто вызывает getattr() и перехватывает AttributeError — в критичных к производительности участках предпочитайте подход EAFP (try/except).

getattr()

Получает атрибут по имени, с опциональным значением по умолчанию, чтобы избежать исключения.

print(getattr("hi", "upper")(), getattr("hi", "missing", "N/A"))

HI N/A

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

setattr()

Устанавливает атрибут по имени — динамический аналог getattr().

class C: pass
obj = C()
setattr(obj, "value", 42)
print(obj.value)

42

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

id()

Возвращает уникальный идентификатор объекта — в CPython это адрес в памяти.

a = [1, 2]
b = a
print(id(a) == id(b))

True

Используйте id() (или оператор is, который его использует) для проверки идентичности объектов, но никогда для проверки равенства — для этого есть ==.

hash()

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

print(hash("hello") == hash("hello"))

True

hash() поддерживают только хешируемые (обычно неизменяемые) объекты — списки и словари выбрасывают TypeError.

repr()

Возвращает однозначное, ориентированное на разработчика строковое представление объекта.

print(repr("hi\nthere"))

'hi\nthere'

Хорошая реализация __repr__ в идеале должна выглядеть как валидный код Python, воссоздающий объект.

oct()

Преобразует целое число в его восьмеричное строковое представление с префиксом 0o.

print(oct(64))

0o100

Часто применяется при работе с правами доступа к файлам, например oct(os.stat("f").st_mode).

ord()

Функция ord() в Python преобразует один символ в его код Unicode — целое число, которое идентифицирует этот символ.

print(ord("A"), ord("€"))

65 8364

Подвох: выбрасывает TypeError, если передана строка длиной не в один символ — ord("AB") завершится ошибкой, поэтому применяйте функцию к строке через отображение, когда нужны коды всех символов: [ord(c) for c in "AB"].

chr()

Обратная функция к ord(): превращает код Unicode обратно в строку из одного символа.

print(chr(65), chr(8364))
print(int(chr(50)) + int(chr(50)))

A €
4

Вторая строка — классический экзаменационный вопрос. chr(50) — это символ "2", а не число 2; затем int() разбирает его обратно в 2, поэтому сумма равна 4. Без int() получилась бы "22" — конкатенация строк, а не сложение. Допустимые аргументы — от 0 до 0x10FFFF; всё, что выходит за эти границы, вызывает ValueError.

ascii()

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

print(repr("café"), ascii("café"))

'café' 'caf\xe9'

Полезно при логировании в терминалы или файлы, кодировку которых вы не контролируете.

Выполнение кода и ввод-вывод

print()

Записывает текст в стандартный вывод (или любой файлоподобный объект через file=).

print("a", "b", sep="-", end="!\n")

a-b!

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

input()

Читает строку текста со стандартного ввода, опционально показывая приглашение.

name = input("Name: ")

Name: (waits for user input, returns the typed string)

Всегда возвращает str — приводите явно через int()/float(), если нужно число.

open()

Открывает файл и возвращает файловый объект; почти всегда используется вместе с блоком with.

with open("example.txt", "w") as f:
    f.write("hello")

(writes "hello" to example.txt)

Всегда используйте with open(...) as f: — это гарантирует закрытие файла даже при возникновении исключения.

format()

Форматирует одно значение согласно спецификации формата — механизм, лежащий в основе f-строк.

print(format(3.14159, ".2f"), format(255, "#x"))

3.14 0xff

Для всего, что сложнее одного значения, f-строка (f"{x:.2f}") обычно понятнее прямого вызова format().

eval()

Вычисляет строку как выражение Python и возвращает результат.

print(eval("2 + 3 * 4"))

14

Подвох: никогда не вызывайте eval() на недоверенных данных — она выполняет произвольный код с полными правами интерпретатора.

exec()

Выполняет строку как инструкции Python — надмножество eval(), без возвращаемого значения.

exec("x = 5\nprint(x * 2)")

10

То же предупреждение о безопасности, что и для eval(), только вдвойне — exec() может определять функции, классы и импорты.

help()

Запускает интерактивную систему справки Python для модуля, функции или объекта.

help(str.strip)

(prints the docstring for str.strip in an interactive pager)

Лучше всего использовать в сессии REPL; в скриптах предпочитайте чтение документации напрямую.

globals()

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

x = 1
print("x" in globals())

True

Изменение словаря, возвращаемого globals(), действительно меняет глобальные переменные — мощно и опасно.

locals()

Возвращает словарь-снимок текущего локального пространства имён.

def f():
    y = 10
    print(locals())
f()

{'y': 10}

Подвох: внутри функции изменение словаря из locals() не гарантированно обновляет локальные переменные — CPython трактует его как снимок.

import()

Низкоуровневая функция, которую под капотом вызывает инструкция import.

math = __import__("math")
print(math.sqrt(16))

4.0

В реальном коде используйте importlib.import_module() вместо неё — __import__() существует в основном для нужд самого интерпретатора.

Помощники для ООП

property()

Свойство (property) в Python — это управляемый атрибут: property() превращает метод в нечто, читаемое обычным синтаксисом обращения к атрибуту, обеспечивая вычисляемые значения с доступом в стиле атрибута.

class Circle:
    def __init__(self, r):
        self.r = r
    @property
    def area(self):
        return 3.14159 * self.r ** 2

print(Circle(2).area)

12.56636

Используйте property, чтобы добавить проверку или вычисляемые значения к атрибуту, не ломая существующие места вызова obj.attr.

staticmethod()

Помечает метод, который не получает self или cls — по сути, обычную функцию, помещённую в пространство имён класса.

class Math:
    @staticmethod
    def add(a, b):
        return a + b

print(Math.add(2, 3))

5

Используйте, когда метод логически принадлежит классу, но никогда не обращается к состоянию экземпляра или класса.

super()

Возвращает прокси-объект для вызова методов родительского или соседнего класса — необходим для совместного множественного наследования.

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return super().speak() + " Woof!"

print(Dog().speak())

... Woof!

Всегда предпочитайте super() жёсткому указанию имени родительского класса — она корректно следует порядку разрешения методов (MRO) в иерархиях с множественным наследованием.

Сводная таблица

Категория	Функции
Числа и математика	abs, bin, divmod, pow, round, hex, oct, float, int
Итерируемые объекты и последовательности	any, all, enumerate, zip, map, filter, sorted, reversed, range, len, sum, min, max, iter, next, slice
Конструкторы типов	bool, bytes, bytearray, str, list, dict, set, frozenset, tuple, memoryview, object
Интроспекция и атрибуты	type, isinstance, issubclass, callable, dir, vars, hasattr, getattr, setattr, id, hash, repr, ascii, oct, ord, chr
Выполнение кода и ввод-вывод	print, input, open, format, eval, exec, help, globals, locals, __import__
Помощники для ООП	property, staticmethod, super

Что изучать дальше

Освоив набор встроенных функций, логичный следующий шаг — применить его в реальных пайплайнах данных и AI. Если вы работаете с чем-то, что затрагивает большие модели локально, посмотрите Quantization for LLMs: Run Big Models on Small Hardware — многие функции из этого руководства (bytes, memoryview, работа с буферами) постоянно встречаются при работе с тензорными данными. Если вы оцениваете пайплайны retrieval, Building a RAG Evaluation Pipeline with Python активно опирается на zip(), enumerate() и sorted() для подсчёта оценок и ранжирования результатов. А если следующим в вашем списке идёт асинхронный код, экосистема async в Python строится непосредственно поверх протокола итераторов, который раскрывают эти встроенные функции — iter() и next() это тот самый механизм, который под капотом использует async for.