Bezdepbonusu7Программирование: статьи и ответы

Python для начинающих

Функции в Python: def, аргументы, return, *args и **kwargs, lambda, область видимости

Функции в Python создаются ключевым словом def, получают аргументы и возвращают результат через return. Ниже все основы с запускаемыми примерами: виды аргументов, ловушка изменяемого значения по умолчанию, *args и **kwargs, lambda, область видимости LEGB, docstring и аннотации типов.

Функции в Python: def, аргументы, return, *args и **kwargs, lambda, область видимости
Содержание
  1. Что такое функция и как её создать через def
  2. Return: как функция возвращает результат
  3. Аргументы: позиционные, именованные и значения по умолчанию
  4. Произвольное число аргументов: *args и **kwargs
  5. Lambda-функции
  6. Области видимости и правило LEGB
  7. Docstring и аннотации типов
  8. Рекурсия и функции как объекты
  9. Частые вопросы

Что такое функция и как её создать через def

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

def greet(name, greeting="Привет"):
    """Возвращает приветствие."""
    return f"{greeting}, {name}!"

print(greet("Аня"))
print(greet("Олег", greeting="Здравствуй"))
print(greet(greeting="Хай", name="Жан"))

Вывод: Привет, Аня!, Здравствуй, Олег!, Хай, Жан!. Здесь name и greeting - параметры (имена в определении), а значения "Аня" или "Олег" - аргументы (то, что передают при вызове).

Определение функции только создаёт её, выполняется тело при вызове: greet("Аня"). Вызывать функцию можно только после того, как она определена выше по ходу программы.

Кроме своих функций в Python много встроенных: print, input, len, range, int, str, sum, min, max, sorted, map, filter. Работа со списками и строками тоже построена на функциях и методах (метод - это функция, привязанная к объекту).

Return: как функция возвращает результат

Оператор return завершает функцию и отдаёт значение туда, где её вызвали. Если return нет или он без значения, функция вернёт None. Частая ошибка новичков - использовать print вместо return: напечатанное значение нельзя потом использовать в вычислениях.

def show():
    print("x")        # только печатает

print(show())          # x, затем None

def minmax(nums):
    return min(nums), max(nums)    # возвращает кортеж из двух значений

lo, hi = minmax([4, 1, 9])
print(lo, hi, minmax([4, 1, 9]))   # 1 9 (1, 9)

Во втором примере функция вернула сразу два значения. На самом деле Python упаковал их в кортеж, а при вызове распаковал в две переменные. После выполнения return остальной код функции не выполняется, поэтому его удобно использовать для раннего выхода из функции по условию.

Аргументы: позиционные, именованные и значения по умолчанию

Аргументы можно передавать по позиции (greet("Аня", "Хай")) или по имени (greet(name="Аня", greeting="Хай")). Именованные можно ставить в любом порядке, но после первого именованного позиционных быть не должно. Параметры со значением по умолчанию (greeting="Привет") можно не указывать при вызове, и их записывают после обязательных.

Вид параметраЗапись в defКак передавать
Обычныйdef f(a, b)по позиции или по имени
Со значением по умолчаниюdef f(a, b=10)можно пропустить
Произвольное число позиционныхdef f(*args)f(1, 2, 3), внутри args - кортеж
Произвольное число именованныхdef f(**kwargs)f(x=1, y=2), внутри kwargs - словарь
Только по имениdef f(a, *, b)b обязательно с именем: f(1, b=2)
Только по позицииdef f(a, b, /)без имён: f(1, 2)

Параметры после одиночной звёздочки * принимаются только по имени, а до косой черты / только по позиции. Эти формы нужны, когда вы проектируете публичные функции и хотите зафиксировать способ вызова, а новичку достаточно знать первые четыре строки таблицы.

Ловушка изменяемого значения по умолчанию

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

def add_bad(item, bucket=[]):
    bucket.append(item)
    return bucket

print(add_bad(1), add_bad(2))      # [1, 2] [1, 2] - один и тот же список!

def add_ok(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

print(add_ok(1), add_ok(2))        # [1] [2]

В первой версии список один на все вызовы, поэтому второй вызов дописывает в него же. Обе печатаемые ссылки указывают на один объект, потому вывод одинаков. Правильный приём показан во второй функции: по умолчанию ставят None и создают новый список внутри. Увидеть сохранённое значение можно так: add_bad.__defaults__.

Не используйте списки, словари и множества как значения по умолчанию. Берите None и создавайте объект внутри функции. Для чисел, строк, True и False таких проблем нет, потому что они неизменяемые.

Произвольное число аргументов: *args и **kwargs

Если заранее неизвестно, сколько аргументов передадут, используют *args (собирает лишние позиционные в кортеж) и **kwargs (собирает лишние именованные в словарь). Названия args и kwargs - это соглашение, важны только звёздочки.

def total(*args):
    return sum(args)

def info(**kwargs):
    for k, v in kwargs.items():
        print(k, v)

def f(a, b, *args, sep="-", **kwargs):
    return (a, b, args, sep, kwargs)

print(total(1, 2, 3), total())              # 6 0
info(a=1, b="два")                           # a 1 и b два на двух строках
print(f(1, 2, 3, 4, sep="+", x=5))           # (1, 2, (3, 4), '+', {'x': 5})

Звёздочки работают и при вызове, в обратную сторону: * разворачивает список или кортеж в позиционные аргументы, а ** - словарь в именованные.

nums = [1, 2, 3]
print(total(*nums))                          # 6
d = {"name": "Мия", "greeting": "Хэй"}
print(greet(**d))                            # Хэй, Мия!

Такая запись удобна, когда данные приходят уже в списке или словаре, например из JSON. Порядок параметров в определении всегда один: обычные, затем значения по умолчанию, затем *args, потом параметры только по имени и в конце **kwargs.

Lambda-функции

Лямбда (lambda) - это короткая анонимная функция из одного выражения, результат которого возвращается автоматически. Без имени, без return и без нескольких строк. Чаще всего её передают как аргумент другой функции: в sorted, map, filter, max и параметр key.

sq = lambda x: x * x
print(sq(5), (lambda a, b: a + b)(2, 3))     # 25 5

print(sorted(["bb", "a", "ccc"], key=lambda s: -len(s)))   # ['ccc', 'bb', 'a']
print(list(map(lambda x: x * 2, [1, 2, 3])))               # [2, 4, 6]
print(list(filter(lambda x: x > 1, [1, 2, 3])))            # [2, 3]

Присваивать лямбду переменной, как в первой строке, можно, но стиль PEP 8 рекомендует для именованных функций использовать def. Для map и filter часто читабельнее генератор списка. Лямбду оставляйте для коротких одноразовых ключей сортировки.

Области видимости и правило LEGB

Переменная живёт только в той области, где создана. Python ищет имя по цепочке LEGB: сначала локальная область функции (Local), затем объемлющие функции (Enclosing), потом глобальная область модуля (Global) и в конце встроенные имена (Built-in).

Порядок поиска имени переменной в Python по правилу LEGB
Четыре уровня области видимости: от локальной до встроенной
ОбластьГде находитсяПример
Localвнутри текущей функциипеременные, созданные в def
Enclosingво внешней функции для вложеннойпеременная n в outer для inner
Globalна уровне файлаx = 1 в начале модуля
Built-inвстроенные имена Pythonlen, print, range

Присваивание внутри функции создаёт локальную переменную, даже если глобальная с таким именем есть. Чтобы изменить глобальную, объявляют global, а для переменной внешней функции используют nonlocal.

x = "глобальная"
def a1():
    x = "локальная"
    print(x)
a1(); print(x)             # локальная, затем глобальная

cnt = 0
def inc():
    global cnt
    cnt += 1
inc(); inc(); print(cnt)   # 2

def outer():
    n = 0
    def inner():
        nonlocal n
        n += 1
        return n
    return inner

c = outer()
print(c(), c(), c())       # 1 2 3

Вложенная функция inner помнит переменную n даже после завершения outer: такой механизм называется замыканием. Типичная ошибка: прочитать переменную и потом присвоить её в той же функции без global. Тогда Python считает имя локальным, и обращение до присваивания вызывает UnboundLocalError. Глобальных переменных лучше избегать: передавайте данные параметрами и возвращайте результат через return.

Изменяемые аргументы и передача по ссылке

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

def f2(x):
    x.append(1)      # меняем сам список

def f3(x):
    x = x + 1        # создаём новое число, внешнее не затрагивается

lst = []; f2(lst); print(lst)    # [1]
v = 1; f3(v); print(v)           # 1

Если функция не должна менять входные данные, работайте с их копией: data = list(data).

Docstring и аннотации типов

Строка документации (docstring) - это строка в тройных кавычках первой строкой тела функции. Она описывает, что делает функция, и доступна через help(функция) и атрибут __doc__. Аннотации типов указывают ожидаемые типы параметров и результата. Python их не проверяет при запуске, но их используют редакторы (PyCharm, VS Code) и анализаторы вроде mypy.

def area(w: float, h: float = 1.0) -> float:
    """Площадь прямоугольника.

    w - ширина, h - высота.
    """
    return w * h

print(area(2, 3))                          # 6
print(area.__doc__.splitlines()[0])        # Площадь прямоугольника.
print(area.__annotations__)
# {'w': <class 'float'>, 'h': <class 'float'>, 'return': <class 'float'>}

Запись -> float означает, что функция возвращает число с плавающей точкой. Хороший docstring пишут по существу: что принимает, что возвращает, какие бывают исключения. Именно эту строку покажет подсказка в редакторе при вводе вызова.

Рекурсия и функции как объекты

Функция может вызывать сама себя. Такая рекурсия нужна для обхода деревьев и вычислений, которые естественно делятся на меньшие части. У неё обязательно должно быть условие остановки.

def fact(n):
    return 1 if n <= 1 else n * fact(n - 1)

print(fact(5))     # 120

Глубина рекурсии ограничена (по умолчанию около тысячи вызовов), при превышении будет RecursionError, поэтому для больших задач используют циклы. В Python функции - обычные объекты: их можно присваивать переменным, класть в списки и передавать в другие функции, как лямбды выше.

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

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

Как создать функцию в Python?

Напишите def, имя, скобки с параметрами и двоеточие, а тело с отступом: def hello(name): return f"Привет, {name}". Вызов - hello("Аня").

Чем отличаются print и return?

print выводит значение на экран, а return отдаёт его вызвавшему коду, и его можно сохранить в переменную. Функция без return возвращает None.

Что такое *args и **kwargs?

*args собирает лишние позиционные аргументы в кортеж, **kwargs - лишние именованные в словарь. Звёздочки при вызове, наоборот, разворачивают список и словарь в аргументы.

Почему нельзя ставить список значением по умолчанию?

Значение создаётся один раз при определении функции и делится между всеми вызовами. Используйте None и создавайте список внутри функции.

Что такое lambda в Python?

Это анонимная функция из одного выражения: lambda x: x * 2. Её обычно передают в sorted, map, filter или параметр key.

Выбери верное утверждение о функциях в Python: что считается верным?

Функция без return возвращает None, параметры со значением по умолчанию записываются после обязательных, а функции в Python являются объектами и могут передаваться как аргументы.

Как изменить глобальную переменную внутри функции?

Объявите её через global в начале функции. Для переменной внешней функции используйте nonlocal, но чаще лучше передавать значения параметрами и возвращать результат.

Источники

  • More Control Flow Tools: Defining Functions, Python Software Foundation
  • Python Scopes and Namespaces, Python Software Foundation
  • Built-in Functions, Python Software Foundation

Python

Похожие материалы

Версии программ и команды проверены на дату публикации. Если что-то изменилось, сверяйтесь с официальной документацией. Нашли неточность? Напишите на admin@bezdepbonusu7.win.