Встроенные функции Python: какие нужно знать и на какие не стоит тратить время

, отредактировано

Ключевые выводы
- В Python около 70 встроенных функций, но для начала достаточно знать 20-25 основных
- Функции print, len, str, int, list, dict, range используются практически в каждом проекте
- enumerate, zip, sorted, any/all — неочевидные, но крайне полезные функции для чистого кода
- Функции breakpoint, dir, type, help незаменимы при отладке
- Остальные встроенные функции изучайте по мере необходимости — не тратьте время на запоминание всего списка

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

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

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

Встроенные функции в первых двух категориях являются основными. Они в конечном итоге будут нужны почти всем начинающим программистам на Python. Встроенные модули в следующих двух категориях являются специализированными, но потребности в них будут варьироваться в зависимости от вашей специализации. Категория 5 — это скрытые встроенные функции. Они очень полезны, когда в них есть необходимость, но многим программистам Python они, вероятно, никогда не понадобятся.

Общеизвестные функции

Если вы уже писали код на Python, эти модули должны быть вам знакомы.

print

Вряд ли найдётся разработчик, даже начинающий, который не знает эту функцию вывода на экран:

			>>> print("I am Groot")
I am Groot
>>> print(1, 2, 3)
1 2 3
>>> print("I am Groot", end="!\n")
I am Groot!

len

В Python нет синтаксиса вроде my_list.length() или my_string.length, чтобы получить длину строки или списка. Для этого есть функция len:

			>>> len(["a", "b", "c"])
3
>>> len("hello")
5

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

str

К сожалению, в отличие от многих других языков программирования, в Python нельзя объединить строку с нестроковым типом данных:

			>>> version = 3
>>> "Python " + version
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Python отказывается приводить целое число 3 к типу строка, поэтому нужно сделать это вручную:

			>>> "Python " + str(version)
'Python 3'

int

Если нужно пользовательский ввод преобразовать в integer, или если нужно извлечь десятичное число из числа с плавающей запятой:

			>>> int("3")
3
>>> int(3.14)
3
>>> int("3.14")
ValueError: invalid literal for int() with base 10: '3.14'

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

			>>> int(1.7)
1
>>> int(-1.7)
-1
>>> int(0.5)
0

Обратите внимание, если нужно обрезать дробную часть при делении, оператор «//» будет более эффективным:

			>>> 7 // 2
3

float

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

			>>> float("3.14")
3.14
>>> float("3")
3.0
>>> float("3,14")
ValueError: could not convert string to float: '3,14'
>>> float("3.14.159")
ValueError: could not convert string to float: '3.14.159'

Float также можно использовать для преобразования целых чисел в числа с плавающей запятой для деления с плавающей запятой:

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

list

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

			>>> list({1, 2, 3})
[1, 2, 3]
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(enumerate("hello"))
[(0, 'h'), (1, 'e'), (2, 'l'), (3, 'l'), (4, 'o')]

При работе со списком метод copy позволяет создать его копию:

			>>> original = [2, 1, 3, 4]
>>> copy = original.copy()

Если вы не знаете, с какими элементами работаете, функция list даёт универсальный механизм:

			>>> copy = list(original)
>>> copy
[2, 1, 3, 4]

Также можно использовать списковое включение, но делать это не рекомендуется.

Обратите внимание, когда вы хотите создать пустой список, следует использовать буквальный синтаксис:

			>>> characters = []
>>> characters = list()  # Не делайте так

Использование «[ ]» считается более идиоматическим, так как эта запись более эффективна и проста в освоении.

tuple

Эта функция во многом похожа на функцию list, за исключением того, что она создает tuple:

			>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple("hello")
('h', 'e', 'l', 'l', 'o')

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

dict

Эта функция создаёт новый словарь.

Подобно спискам и кортежам, dict эквивалентна проходу по множеству пар ключ-значение и созданию из них словаря.

Дан список кортежей, по два элемента в каждом.

			>>> color_counts = [("red", 2), ("green", 1), ("blue", 3), ("purple", 5)]

Выведем его на экран с помощью цикла.

			>>> colors = {}
>>> for color, count in color_counts:
...     colors[color] = count
...
>>> colors
{'red': 2, 'green': 1, 'blue': 3, 'purple': 5}

То же самое, но с использованием dict.

			>>> colors = dict(color_counts)
>>> colors
{'red': 2, 'green': 1, 'blue': 3, 'purple': 5}

Функция dict может принимать 2 типа аргументов:

другой словарь (в этом случае словарь копируется)
список кортежей (по 2 элемента в каждом), как в примере выше.

Поэтому следующий код также будет работать.

			>>> new_colors = dict(colors)
>>> new_colors
{'red': 2, 'green': 1, 'blue': 3, 'purple': 5}
>>> new_colors is colors
False

Функция dict также может принимать ключевые слова в качестве аргументов:

			>>> person = dict(name="Trey", profession="Python trainer")
>>> person
{'name': 'Trey', 'profession': 'Python trainer'}

Но рекомендуется всё же использовать литералы вместо ключевых слов.

			>>> person = {"name": "Trey", "profession": "Python trainer"}
>>> person
{'name': 'Trey', 'profession': 'Python trainer'}

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

Как в случае со списком и кортежем, пустой словарь следует создавать с использованием литерального синтаксиса:

			>>> counts = {}
>>> counts = dict()  # Не делайте так

Использование «{ }» более идиоматично и эффективно с точки зрения использования CPU.

set

Функция set создаёт новый набор. Она принимает итерации из хешируемых значений и возвращает набор (множество):

			>>> set(["red", "green", "blue"])
{'blue', 'green', 'red'}

Создать пустой набор с «{ }» нельзя (фигурные скобки создадут пустой словарь), поэтому необходимо использовать set:

			>>> empty_set = set()
>>> type(empty_set)
<class 'set'>

Можно использовать и другой синтаксис.

			>>> colors = {*["red", "green", "blue"]}
>>> colors
{'blue', 'green', 'red'}

Такой способ имеет недостаток — он сбивает с толку (он основан на редко используемом синтаксисе). Функция set понятнее.

Звёздный Python: где и как используются * и **

tproger.ru

range

Эта функция создаёт объект range, который представляет собой диапазон чисел:

			>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Результирующий диапазон чисел включает начальный номер, но исключает конечный (range(0, 10) не включает 10).

Данная функция полезна при переборе чисел.

			>>> for n in range(0, 5):
...     print(n)
...
0
1
2
3
4

Обычный вариант использования — выполнить операцию n раз.

			>>> for _ in range(3):
...     print("hip")
...
hip
hip
hip

Функция range в Python 2 возвращает список. Это означает, что range(10000) создаст список из 10 000 элементов, а range(1000000000) попытается создать список из 1 000 000 000 элементов, заняв много оперативной памяти. В Python 3 функция range возвращает ленивый диапазон.

Функции, неочевидные для новичков

bool

Эта функция проверяет достоверность (истинность) объектов Python. Относительно числовых типов ноль — falsy, а все остальные числа — truthy:

			>>> bool(0)
False
>>> bool(1)
True

Применяя bool к коллекциям, будет проверяться их длина (больше 0 или нет):

			>>> bool([])
False
>>> bool([1])
True
>>> bool("")
False
>>> bool("hello")
True
>>> bool({})
False
>>> bool({1: 1, 2: 4, 3: 9})
True

Проверка истинности очень важна в Python. Вместо того, чтобы задавать вопросы о длине контейнера, многие питонисты спрашивают о достоверности (истинности):

			>>> numbers = [2, 1, 3, 4, 7, 11]
>>> if numbers:  # instead of if len(numbers) > 0
...     print("this list is not empty")
...
this list is not empty

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

enumerate

Если нужно в цикле посчитать количество элементов (по одному элементу за раз), эта функция придёт на помощь:

Например, если нужно отслеживать номер строки в файле.

			>>> with open("diary980.md") as diary_file:
...     for n, line in enumerate(diary_file, start=1):
...         if "Trey" in line:
...             print(f"Line {n}: {line}")
...
Line 3: Dear Diary, I sat next to Trey again today.

Enumerate также часто используется для отслеживания индекса элемента в последовательности:

			>>> for i, item in enumerate(["a", "b", "c"]):
...     print(f"{i}: {item}")
...
0: a
1: b
2: c

Также следует обратить внимание, что новички в Python часто используют range(len(...)) вместо enumerate. Но делать этого не стоит.

			>>> colors = ["red", "green", "blue"]
>>> for i in range(len(colors)):
...     print(f"{i}: {colors[i]}")
...
0: red
1: green
2: blue

zip

Эта функция ещё более специализирована, чем enumerate. Zip используется для одновременного перебора нескольких итерируемых объектов:

			>>> one_to_four = [1, 2, 3, 4]
>>> letters = ["a", "b", "c", "d"]
>>> for number, letter in zip(one_to_four, letters):
...     print(number, letter)
...
1 a
2 b
3 c
4 d

По сравнению с enumerate, последняя функция удобна, когда нужен индекс для отслеживания позиции в цикле, а zip удобен для перебора двух итерируемых объектов одновременно.

reversed

Функция reversed, как enumerate и zip, возвращает итератор:

			>>> reversed(["a", "b", "c"])
<list_reverseiterator object at 0x7f2e0066e850>

Единственное, что можно сделать с этим итератором, пройтись по нему (но только один раз):

			>>> for item in reversed(["a", "b", "c"]):
...     print(item)
...
c
b
a

Подобно enumerate и zip, reversed является ленивым (lazy). Это означает, что можно зациклить его только один раз:

			>>> numbers = reversed([1, 2, 3])
>>> list(numbers)
[3, 2, 1]
>>> list(numbers)
[]

Есть несколько и других способов перевернуть списки в Python.

			>>> numbers = [1, 2, 3]
>>> numbers.reverse()  # мутирует список
>>> numbers
[3, 2, 1]
>>> numbers[::-1]  # создаёт копию
[1, 2, 3]

Данная функция, как правило, является лучшим способом «перевернуть» любой список.

В отличие от numbers.reverse(), reversed не изменяет исходный список.

reversed(numbers) (в отличие от numbers [::-1]) не создаёт копию списка, он выдаёт ленивый итератор.

Можно использовать факт, что reversed не копирует список. Например, для удаления элементов из списка в обратном порядке:

			>>> numbers = [1, 2, 3, 5, 8, 13, 21]
>>> for i in reversed(range(len(numbers))):
...     if numbers[i] % 2 == 0:
...         numbers.pop(i)
...
8
2
>>> numbers
[1, 3, 5, 13, 21]

sum

Эта функция берёт набор чисел и возвращает их сумму.

			>>> sum([1, 2, 3])
6

В Python есть много вспомогательных функций, которые выполняют циклы за вас (отчасти потому, что они были позаимствованы из функциональных языков программирования):

			>>> product = 1
>>> for n in [1, 2, 3]:
...     product *= n
...
>>> product
6

min и max

Эти функции выдают минимальное и максимальное число из набора соответственно.

			>>> min([3, 1, 2])
1
>>> max([3, 1, 2])
3

Данные методы сравнивают элементы, используя оператор <, а значит, все сравниваемые значения должны быть упорядочены:

Min и max также принимают key для пользовательского сравнения:

			>>> words = ["short", "very long", "medium"]
>>> min(words, key=len)
'short'
>>> max(words, key=len)
'very long'

sorted

Эта функция принимает любой набор элементов и возвращает новый список всех значений в отсортированном порядке:

			>>> sorted([3, 1, 2])
[1, 2, 3]
>>> sorted("hello")
['e', 'h', 'l', 'l', 'o']
>>> sorted({3: "c", 1: "a", 2: "b"})
[1, 2, 3]

Данная функция (как min и max) сравнивает элементы, используя оператор <.

Sorted также позволяет настраивать сортировку с помощью key и реверса.

any и all

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

Используя all, можно переписать функцию palindromic из цикла for:

			def palindromic(sequence):
    return all(
        sequence[i] == sequence[-(i+1)]
        for i in range(len(sequence) // 2)
    )

Отрицание условия и возвращаемого значения позволит также использовать any:

			def palindromic(sequence):
    return not any(
        sequence[i] != sequence[-(i+1)]
        for i in range(len(sequence) // 2)
    )

5 функций для отладки

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

breakpoint

Если нужно приостановить выполнение кода и перейти в командную строку Python, эта функция вам пригодится.

Эта встроенная функция была добавлена в Python 3.7, но если вы работаете в более ранних версиях, можно использовать import pdb; pdb.set_trace().

dir

Эта функция может использоваться в двух случаях:

просмотреть список всех локальных переменных;
просмотреть список всех атрибутов конкретного объекта.

Из примера можно увидеть локальные переменные сразу после запуска и после создания новой переменной:

			>>> dir()
['__annotations__', '__builtins__', ...]
>>> x = [1, 2, 3, 4]
>>> dir()
['__annotations__', '__builtins__', ..., 'x']

Если в dir передать созданный список x, можно увидеть все его атрибуты:

			>>> dir(x)
['__add__', '__class__', '__class_getitem__', '__contains__',
'__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__',
'__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__',
'append', 'clear', 'copy', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']

В выведенном списке атрибутов можно увидеть его типичные методы (append, pop, remove и пр.).

vars

Эта функция является своего рода смесью двух похожих инструментов: dir и locals.

Когда vars вызывается без аргументов, это эквивалентно вызову locals(), функции, которая показывает словарь всех локальных переменных и их значений:

			>>> vars()
{'__name__': '__main__', ...}
>>> x = [1, 2, 3, 4]
>>> vars()
{'__name__': '__main__', ..., 'x': [1, 2, 3, 4]}

Когда вызов происходит с аргументом, vars получает доступ к атрибуту __dict__ данного объекта:

			>>> class Point:
...     def __init__(self, x, y, z):
...         self.x = x
...         self.y = y
...         self.z = z
...
>>> p = Point(1, 2, 3)
>>> vars(p)
{'x': 1, 'y': 2, 'z': 3}
>>> p.__dict__
{'x': 1, 'y': 2, 'z': 3}

Перед использованием vars было бы неплохо сначала обратиться к dir, а затем по необходимости перейти к vars.

type

Эта функция возвращает тип объекта, который вы ей передаете.

Тип экземпляра класса есть сам класс.

			>>> type(1)
<class 'int'>
>>> type("hello")
<class 'str'>

Тип класса — это его метакласс, обычно это type.

			>>> type(int)
<class 'type'>
>>> type(str)
<class 'type'>

Атрибут __class__ даёт тот же результат, что и функция type:

			>>> (3).__class__
<class 'int'>
>>> "hello".__class__
<class 'str'>

Функция type, кроме отладки, иногда полезна и в реальном коде.

Обратите внимание, что при проверке типов обычно вместо type рекомендуется использовать isinstance, но иногда type — лучший вариант.

help

Если вы находитесь в Python Shell или делаете отладку кода с использованием breakpoint и нужна помощь для понимания какого-либо объекта, help окажет содействие.

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

Функции, которые пригодятся позже

В начале изучения Python эти функции вам по большей части будут не нужны, но в какой-то момент они станут актуальны.

open

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

Несмотря на то, что работа с файлами очень распространена, далеко не все программисты на Python работают с файлами ежедневно.

input

Эта функция запрашивает у пользователя ввод, ждёт нажатия клавиши Enter, а затем возвращает введённый текст.

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

repr

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

Для многих объектов функции str и repr возвращают одинаковый результат:

			>>> str(4)
'4'
>>> repr(4)
'4'

Но есть объекты, для которых их применение различается.

			>>> str("hello")
'hello'
>>> repr("hello")
"'hello'"
>>> from datetime import date
>>> str(date(2020, 1, 1))
'2020-01-01'
>>> repr(date(2020, 1, 1))
"datetime.date(2020, 1, 1)"

Строковое представление, которое вы видите в Python Shell, использует repr, а не str:

			>>> "hello"
'hello'
>>> date(2020, 1, 1)
datetime.date(2020, 1, 1)

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

super

Эта функция очень важна, если используется наследование одного класса от другого.

Многие пользователи Python редко создают классы. Они не являются важной частью Python так же, как и в других объектно-ориентированных языках. Но если вы создаёте класс с наследованием, super будет незаменим.

property

Эта функция является декоратором для создания свойств объекта.

Декораторы в Python: понять и полюбить

tproger.ru

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

Пример класса, который использует property.

			class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def diameter(self):
        return self.radius * 2

Здесь вы можете увидеть доступ к атрибуту diameter объекта Circle:

			>>> c = Circle(5)
>>> c.diameter
10
>>> c.radius = 3
>>> c.diameter
6

Если вы занимаетесь объектно-ориентированным программированием на Python, вам, вероятно, стоит изучить property.

issubclass и isinstance

Функция issubclass проверяет, является ли класс подклассом одного или нескольких других классов:

			>>> issubclass(bool, int)
True
>>> issubclass(bool, (int, str))
True

Функция isinstance проверяет, является ли объект экземпляром одного или нескольких классов:

			>>> isinstance(True, int)
True
>>> isinstance(True, (int, str))
True
>>> isinstance(True, str)
False

Функция isinstance может быть представлена как делегирование к issubclass:

			>>> issubclass(type(True), int)
True
>>> issubclass(type(True), (int, str))
True
>>> issubclass(type(True), str)
False

Если вы перегружаете операторы, вам может понадобиться использование isinstance. Также isinstance используется для защитной проверки типов аргументов.

hasattr, getattr, setattr и delattr

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

Например, есть объект thing, который нужно проверить на конкретный атрибут:

			>>> thing.x
AttributeError: ...

Функция hasattr позволяет проверить, имеет ли объект определённый атрибут:

			>>> hasattr(thing, "x")
False
>>> hasattr(thing, "y")
True

Функция getattr позволяет получить значение атрибута (с необязательным значением по умолчанию):

			>>> getattr(thing, "y")
4
>>> getattr(thing, "x", None)
None

Функция setattr позволяет установить значение атрибута.

			>>> setattr(thing, "x", 5)
>>> thing.x
5

И delattr соответственно удаляет атрибут.

			>>> delattr(thing, "x")
>>> thing.x
AttributeError: ...
>>> delattr(thing, "x")
AttributeError: ...

classmethod и staticmethod

Если у вас есть метод, который должен вызываться в экземпляре или в классе, вам нужен classmethod:

			class RomanNumeral:
    SYMBOLS = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100}
    def __init__(self, number):
        self.number = number
    @classmethod
    def from_string(cls, string):
        return cls(cls.roman_to_int(string))

Немного сложнее придумать хорошее использование staticmethod. Вот пример с roman_to_int:

			class RomanNumeral:
    SYMBOLS = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100,
               "D": 500, "M": 1000}
    def __init__(self, number):
        self.number = number
    @classmethod
    def from_string(cls, string):
        return cls(cls.roman_to_int(string))
    @staticmethod
    def roman_to_int(numeral):
        total = 0
        for symbol, next_symbol in zip_longest(numeral, numeral[1:]):
            value = RomanNumeral.SYMBOLS[symbol]
            next_value = RomanNumeral.SYMBOLS.get(next_symbol, 0)
            if value < next_value:
                total -= value
            else:
                total += value
        return total

Функция roman_to_int не требует доступа к экземпляру или к самому классу, поэтому имеет смысл сделать её статическим методом.

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

Она может работать со следующими видами итераторов:

файлы (отдаёт строки)
zip
enumerate
reversed
генераторы
объекты csv.reader
и другие

Функция next может быть представлена как способ вручную пройти по итерируемому объекту.

Функции, которые когда-нибудь можно выучить

Следующие встроенные функции Python определённо не бесполезны, но они более специализированы.

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

map
filter
compile
exec
eval
abs
round
hash
id

Прочие специфические функции

__import__
ascii
bin, oct, hex
bytes, bytearray, memoryview
chr, ord
complex
divmod, pow
format
frozenset
globals, locals
object

Заключение

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

Частые вопросы

Сколько встроенных функций в Python?

В Python 3.12 — 71 встроенная функция и класс. Полный список доступен через dir(__builtins__) или в официальной документации. Для повседневной работы достаточно знать 20-25 из них.

Какие встроенные функции Python используются чаще всего?

Наиболее часто используются: print, len, range, str, int, list, dict, type, isinstance, enumerate, zip, sorted, open, input и super.

Чем отличается встроенная функция от метода в Python?

Встроенная функция вызывается напрямую (len(my_list)), а метод — через объект (my_list.append(x)). Встроенные функции доступны глобально без импорта, а методы принадлежат конкретному типу данных.

Можно ли переопределить встроенную функцию Python?

Технически да — достаточно присвоить переменной имя встроенной функции, например list = [1, 2, 3]. Но это крайне нежелательно: вы потеряете доступ к оригинальной функции в текущей области видимости. Линтеры вроде pylint и flake8 предупреждают об этом.

Как посмотреть документацию по встроенной функции?

Используйте help(func_name) в интерактивном режиме или func_name.__doc__ для краткого описания. Также можно обратиться к docs.python.org.

Хочу научиться программировать на Python. С чего начать?

tproger.ru

В этой статье

Общеизвестные функции
Функции, неочевидные для новичков
5 функций для отладки
Функции, которые пригодятся позже
Функции, которые когда-нибудь можно выучить
Прочие специфические функции
Заключение
Частые вопросы