Как использовать функции в Python

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

Обычно у функции есть один или несколько аргументов. Их указывают в скобках во время вызова. Они делятся на обязательные (позиционные) и со значением по ключу (именованные).

Синтаксис функций в Python

Любые функции и методы начинаются с инструкции def (от английского define — «определять»). За def в Python идет название функции, после — набор аргументов. Двоеточие в конце открывает блок тела функции, которое располагают с новой строки.

Изучить все функции и методы можно на курсе Skypro «Python-разработчик». За несколько месяцев реально освоить теорию и навыки, чтобы найти работу по новой специальности. А специалисты центра карьеры помогут составить цепляющее резюме и подготовиться к собеседованию.

В Python нет фигурных скобок для блока кода. Вместо них применяют отступы в четыре пробела. Новая инструкция — новая строка. Или можно отделить их точкой с запятой.Чтобы завершить функцию и вернуть из нее значение, используют ключевое слово return. Если этого не указать, то, когда тело функции достигает конца, функция завершится. Возвращается объект типа None.

Аргументы и их виды

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

🚀 Позиционные

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

def addfunc(val1, val2):
    return val1 + val2

result = addfunc(3, 2)
print(result)
5

addfunc() # вызов без аргументов
Traceback (most recent call last):
...
TypeError: addfunc() missing 2 required positional arguments: 'val1' and 'val2'

addfunc(1) # вызов с одним аргументом
Traceback (most recent call last):
...
TypeError: addfunc() missing 1 required positional argument: 'val2'

Когда вызывают функцию addfunc, то передают ей два обязательных аргумента. Они  будут доступны внутри тела функции и ассоциированы с переменными val1 и val2. Если этого не сделаете, получите ошибку TypeError.

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

def addconcat(*args):
    value = 0

    for item in args:
        if isinstance(item, (int, float)):
            value += item
        else:
            print(f"{item} is not a digit")

    return value

total = addconcat(1, "Hello", 2, 3, 4, "Python", 5.0, 6.25, 7.15, 'string')
Hello is not a digit
World is not a digit
string is not a digit

print("Total:", total)
Total: 28.4

Обращаются к позиционному аргументу такого множества с помощью операции индексации:

def demo_func(*args):
    try:
        print(args[0])
        print(args[1])
    except IndexError:
        pass

🚀 Именованные

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

def hey_concat(*args, name="World!"):
    print("Hey there,", name)

hey_concat()
Hey there, World!

hey_concat(name="Alex")
Hey there, Alex

Атрибуту name присвоили иное значение. Это поменяет результат склеивания строк и последующий вывод.

Именованные аргументы могут быть переменной длины. Конструкция упаковывания параметров похожа на предыдущую, но вместо множества используют словарь:

def print_kwargs(**kwargs):
    print(kwargs) # отобразит словарь

print_kwargs(kone="One", ktwo=2, kthree=3.0)
{'kone': 'One', 'ktwo': 2, 'kthree': 3.0}

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

def kwargs_addconcat(**kwargs):

    a = kwargs.get("a", None)
    b = kwargs.get("b", None)

    if not isinstance(a, type(b)):
        raise TypeError("Ошибка! Разные типы")

    if isinstance(a, str):
        return f"Результат конкатенации строк\n{a + b}"

    elif isinstance(a, int):
        return f"Результат сложения чисел\n{a + b}"

    return "Ошибка"


print(kwargs_addconcat(a=1, b=2))
Результат сложения чисел
3

print(kwargs_addconcat(a=1, b="World!"))
...
TypeError: Ошибка! Разные типы

print(kwargs_addconcat(a="Hello, ", b="World!"))
Результат конкатенации строк
Hello, World!

# Без аргументов
print(kwargs_addconcat())
Ошибка

В примере упаковываем именованные аргументы в переменную с названием kwargs. Из нее в теле функции по ключам a и b пытаемся получить значения. А если они не найдутся — объект None. Далее проверяем наличие обоих аргументов и принадлежность одному типу данных. Затем возвращаем результат выполнения в зависимости от типа переданных параметров.

Еще можно комбинировать позиционные и именованные параметры. Сначала располагают позиционные (обязательные) аргументы. Сразу за ними идет переменная, в которую записывают все остальные параметры без явного ключа. Далее — именованные аргументы с предустановленным значением (значением по умолчанию). После него располагают переменную словаря с остальными именованными параметрами.

Общая форма последовательности:

def func(a, b, *args, name="Default", **kwargs):
    return None

Функции и области видимости

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

✈️ Глобальная

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

var1 = 12

def global_func():
    print(x)

Здесь целочисленный объект var1 и функция global_func — в глобальной области видимости.

✈️ Локальная

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

var1 = 2213 # глобальная переменная

# глобальная функция, использующая глобальную переменную
def func_one():
    print(var1)

# глобальная функция, использующая локальную переменную
def func_two():
    var1 = "Local value" # создание локальной переменной
    print(var1)

# функция, изменяющая значение глобальной переменной
def func_three():
    global var1
    var1 = "Local to global"

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

func_one()
2213

func_two()
Local value

func_three() # функция меняет значение глобальной переменной
func_one() # и результат функции func_one
Local to global

✈️ Область объемлющих функций

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

Так реализуют декоратор счетчика вызова функции Python с этим ключевым словом:

def count_deco(wrapper_func):
    var = 0

    def inner():
        nonlocal var
        wrapper_func()
        var += 1
        print(var)
    return inner


@count_deco
def deco_demo():
    print("A few of example text...")


for _ in range(5):
    deco_demo()

A few of example text...
1
A few of example text...
2
A few of example text...
3
A few of example text...
4
A few of example text...
5

Lambda-функции (анонимные)

Одна из интересных особенностей Python — это анонимные (лямбда) функции. Это простое выражение, которое можно присвоить переменной и использовать повторно. Чаще применяют для фильтрации элементов множества:

list_values = [1, 3, 4, 2, 6, 7, 5, 8, 9]
filter(lambda x : x % 2 == 0, list_values)
[2, 4, 6, 8]

Оператор возврата return

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

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

def arithmetics(x, y):
    return x + y, x - y, x * y, x / y, x // y

results = arithmetics(22, 3)

print(results)
(25, 19, 66, 7.333333333333333, 7)

print(results[0])
25

r1, r2, r3, r4, r5 = arithmetics(4, 4)

# результаты сложения и умножения
print(r1)
8

print(r3)
16

Оператор возврата yield

Помимо обычных есть функции-генераторы. Очевидный плюс — они в оперативной памяти не хранят все объекты, которые используют. Есть отложенное выполнение. Такая функция возобновляет работу там, где остановилась. Она генерирует значения, а не вычисляет их.

Эту функцию используют, чтобы создавать автоматические тесты, что здорово ускоряет и упрощает работу тестировщика. Научиться автоматизации можно на курсе Skypro «Инженер по тестированию». Опытные преподаватели-практики дадут всю необходимую теорию и помогут отработать знания на практических задачах.

def gen_demo(times, var):
    for _ in range(times):
        yield var

gen_inst = gen_demo(25, "Gen demo text")

for _ in range(26):
    print(next(gen_inst))

Gen demo text
Gen demo text
Gen demo text
Gen demo text
...

Traceback (most recent call last):
...
StopIteration

[FAQ] Частые вопросы

Функции vs процедуры — в чём отличие?

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

Для чего нужна область видимости? 

Чтобы решить конфликт имен.

Как провести распаковку множества? 

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

Обязательно ли наличие аргументов для функции? 

Нет, но чаще у функции есть один или несколько аргументов.

Главное о функциях в Python

• У каждой функции есть своя область видимости, в которую входят все пространства имен уровнем выше.
• Если явно не задать возвращаемое значение, функция вернет объект типа None.
• Функция с одной или несколькими инструкциями yield будет генератором.
• В Python аргументы функции бывают двух видов — именованные и позиционные. Оба типа аргументов могут быть переменной длины.

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

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