Какая инструкция используется для определения функции в python

Иллюстрация: Оля Ежак для Skillbox Media

Пишет про digital и машинное обучение для корпоративных блогов. Топ-автор в категории «Искусственный интеллект» на Medium. Kaggle-эксперт.

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

Содержание

• Синтаксис функций
• Область видимости функций
• Аргументы функций
• Возвращаемые значения (return)
• Lambda-функции
• Процедуры и функции: различия

---

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

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

def имя_функции (аргументы):
    тело_функции
    return результат

Здесь:

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

Важно соблюдать правила форматирования, включая скобки, отступы и двоеточия. Иначе программа вернёт ошибку.

Картинка с сайта: skillbox.ru

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

def sum(a, b):
    return a + b

Функцию в Python можно создать один раз, а после вызывать её в коде неограниченное количество раз. Это позволяет экономить время и сокращает количество строк в проекте.

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

имя_функции(аргументы)

Теперь вызовем функцию для нахождения суммы, которую мы создали ранее. Для этого введём название sum и в скобках передадим переменные a и b. Результат значения запишется в переменную c:

c = sum(a, b)

Теперь рассмотрим более сложный пример. Представим, что мы хотим написать программу, которая запрашивает результаты ЕГЭ по разным предметам, считает итог и сообщает, насколько хорошо ученик справился с экзаменами.

# Запрашиваем результаты ЕГЭ
math = int(input())
russian = int(input())
informatics = int(input())

# Объявляем функцию, которая принимает результаты ЕГЭ, считает сумму и возвращает результат
def passed (math, russian, informatics):
    total = math + russian + informatics
   
    if 120 <= total < 210:
        print('Хорошо')
    elif 210 <= total < 240:
        print('Очень хорошо')
    elif total >= 240:
        print('Отлично')
    else:
        print('Неудовлетворительно')
    return total
# Вызываем функцию и выводим результат
print(passed(math, russian, informatics))

# Вывод:
40
80
80
Хорошо
200

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

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

В примере ниже переменная c объявлена внутри функции sum. Её можно использовать только внутри функции, если попробовать сделать это в другом месте, то Python выдаст ошибку:

def sum(a, b):
    c = a + b
    return c

Картинка с сайта: skillbox.ru

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

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

def make_counter():
    # Объявляем переменную count в объемлющей функции
    count = 0

    def counter():
        # Указываем, что count находится в объемлющей функции
        nonlocal count 
        count += 1
        return count

    return counter

# Создаём счётчик
call_counter = make_counter()

# Пример использования счётчика
print(call_counter())  # Вывод: 1
print(call_counter())  # Вывод: 2
print(call_counter())  # Вывод: 3

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

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

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

# Глобальная переменная, которая обозначает количество сделанных тортов
cake_count = 10

def modify_cake():
    global cake_count
    # Изменяем значение глобальной переменной
    cake_count = 15

modify_cake()
print(modify_cake)  # Вывод: 15

В Python функции могут работать с разными типами аргументов. Это делает язык гибким и позволяет решать разные задачи.

Этот тип встречается чаще всего. Представьте книжный магазин, где уже есть разные секции: «История», «Литература», «Программирование». Сотрудники расставляют новинки по соответствующим секциям. Так будет легче найти нужную книгу.

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

# Функция принимает два аргумента в таком порядке: секция и книгаdef search(section, book): print (‘Ваша книга: ‘, section, book) # Передаём данные в том же порядкеsearch (‘История’, ‘История государства Российского’)

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

# Функция принимает два аргумента в таком порядке: секция и книга
def search(section, book):
    print('Ваша книга: ', section, book) 
# Передаём данные в том же порядке
search('История','История государства Российского')

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

• *args используют, когда неясно, сколько позиционных аргументов у нас есть. Звёздочка * перед args указывает на то, что все позиционные аргументы, переданные при вызове функции, должны быть собраны в кортеж tuple и присвоены args.

Картинка с сайта: skillbox.ru

• **kwargs используют, чтобы передать именованные аргументы в виде словаря (dictionary), когда мы не знаем, сколько их у нас. Две звёздочки (**) перед kwargs означают, что все именованные аргументы должны быть собраны в словарь и присвоены kwargs.

Например, создадим функцию greet с использованием *args и **kwargs, которая будет приветствовать людей, используя их имена и дополнительную информацию о настроении.

def greet(greeting, *args, **kwargs):
    for name in args:
        message = f'{greeting}, {name}!'
        if 'mood' in kwargs:
            message += f 'Ты чувствуешь себя {kwargs['mood']}.'
        print(message)

# Пример использования
greet('Привет', 'Катя', 'Лена', 'Вика', mood= 'весело')
greet('Здравствуйте', 'Саша, 'Таня')

Функция greet принимает приветствие, список имён *args и дополнительные параметры **kwargs. Проходит через каждое имя в args и формирует приветственное сообщение. Если в kwargs есть ключ mood, то в сообщение добавляется информация о настроении.

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

Например, если бы книжный магазин был интернет-магазином, каждый посетитель получал бы одинаковое приветственное сообщение. Но авторизированные пользователи, то есть те, кто передал свои данные магазину, получают персональное приветствие.

def greet(name = 'Посетитель', message = 'Привет, '):
    print(message, name)

# Вызов функции без указания значения по умолчанию
greet()  # Вывод: Привет, Посетитель

# Вызов функции с изменённым значением по умолчанию
greet('Артём')  # Вывод: Привет, Артём

В этом примере функция greet принимает два аргумента: name и message. У аргумента message значение по умолчанию Привет, а у name ― посетитель. Если при вызове функции не указывается значение, то используется значение по умолчанию.

Картинка с сайта: skillbox.ru

Один из частых вопросов, который волнует новичков в Python, — как передаются переменные в функции и методы: по значению или по ссылке.

• По значению — это когда в функцию передаётся копия значения переменной, а не сама переменная. А значит, если вы вносите изменения в этот аргумент при вызове функции, на оригинальную переменную это не влияет.
• По ссылке означает, что в функцию передаётся ссылка на тот же объект в памяти, который содержит переменную, и любые изменения, внесённые внутри функции в этот аргумент, будут отражаться на оригинальной переменной.

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

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

Пример:

def add_item(my_list, item):
    # Изменяем переданный список
    my_list.append(item)

numbers = [1, 2, 3]
add_item(numbers, 4)
print(numbers)  # Вывод: [1, 2, 3, 4]

Здесь видно, что мы внесли изменения в список, когда взяли его в качестве аргумента, и он теперь выглядит по-другому.

С помощью словаря (**kwargs) можно передавать произвольное количество именованных аргументов.

Например, переменную можно использовать, чтобы выводить персональную информацию для каждого пользователя интернет-магазина. У кого-то будут заполнены графы Ф. И. О., Возраст и Место жительства, а кто-то поленился указать город ― тогда можно вывести только ту информацию, что есть.

def print_person_info(**kwargs):
    print(f'Имя: {kwargs.get('name')}')
    print(f'Возраст: {kwargs.get('age')}')

# Передача словаря в качестве именованных аргументов
person_1 = {'name': 'Аня', 'age': 10}
person_2 = {'name': 'Борис'}
person_3 = {'age': 12}
person_4 = {}
print_person_info(**person_1)

В Python ключевое слово return используется для возврата значения из функции. Полученное значение можно дальше использовать в программе.

В примере ниже функция add принимает два аргумента a и b, складывает их и с помощью return возвращает сумму a + b:

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # Вывод: 8

Если не использовать в функции ключевое слово return, она по умолчанию вернёт None.

Картинка с сайта: skillbox.ru

Лямбда-функции (lambda-функции) ― это безымянные функции, которые могут быть определены в одной строке кода. Выше мы упомянули, что название функции используют, чтобы вызвать функцию повторно. Лямбда-функцию нельзя переиспользовать ― у неё нет имени, по которому её можно вызвать. Обычно их используют там, где требуется передать небольшую функцию в качестве аргумента.

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

lambda аргументы: выражение

В качестве примера рассмотрим лямбда-функцию, которая проверяет чётность числа и выводит True или False. В качестве параметра передаётся переменная num, а после двоеточия указано выражение num % 2 == 0:

is_even = lambda num: num % 2 == 0

print(is_even(4))  # Вывод: True
print(is_even(7))  # Вывод: False

Слова «процедура» и «функция» в Python часто обозначают одно и то же — блок кода для выполнения определённой задачи. Однако есть различия.

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

Например, greet из примеров выше ― это процедура, которая принимает имя в качестве аргумента и выводит приветствие на экран. Она не возвращает никакого значения: её цель только выполнить действие.

• Функция ― тоже фрагмент кода, который выполняет определённую задачу или действие. Но она возвращает результат с помощью ключевого слова return.

В Python нет строгого различия между процедурами и функциями. В коде их определяют одним и тем же ключевым словом def.

• Функции в Python объявляют с помощью ключевого слова def, за которым следует имя функции, круглые скобки для аргументов и двоеточие. Тело функции пишется с отступом.
• Python поддерживает несколько видов аргументов в функциях, включая позиционные, именованные, аргументы со значением по умолчанию, а также переменное количество аргументов с помощью *args и **kwargs.
• Локальные переменные видны только внутри функции, глобальные доступны во всём коде, а вложенные функции имеют доступ к переменным друг друга.
• Функции могут возвращать значения с помощью ключевого слова return. Если оно отсутствует, то функция возвращает None.
• Помимо стандартных функций, Python поддерживает создание анонимных функций с помощью ключевого слова lambda, они могут содержать лишь одно выражение.
• В Python нет явного различия между функциями и процедурами.

Картинка с сайта: skillbox.ru

Курс с трудоустройством: «Профессия Python-разработчик»
Узнать о курсе

Введение в функции

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

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

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

Картинка с сайта: sky.pro

Определение функции

Для определения функции в Python используется ключевое слово def, за которым следует имя функции и круглые скобки. Внутри скобок можно указать параметры функции. Тело функции начинается с двоеточия и должно быть отступлено на один уровень.

Пример определения функции:

В этом примере мы определили функцию greet, которая выводит на экран сообщение «Привет, мир!». Обратите внимание на структуру определения функции: ключевое слово def, имя функции, круглые скобки и двоеточие. Тело функции должно быть отступлено на один уровень, что указывает на его принадлежность к функции.

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

Вызов функции

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

Пример вызова функции:

Этот вызов функции greet выведет на экран сообщение «Привет, мир!». Вызов функции осуществляется с помощью её имени и круглых скобок. Если функция не принимает параметры, скобки остаются пустыми.

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

Аргументы и параметры

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

Пример функции с параметрами:

В этом примере функция greet принимает один параметр name. При вызове функции мы можем передать ей аргумент:

Этот вызов функции выведет на экран сообщение «Привет, Алексей!». Аргументы позволяют передавать данные в функцию, что делает её более гибкой и универсальной. Параметры функции указываются в круглых скобках при её определении и могут быть использованы внутри тела функции.

Множественные параметры

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

Пример функции с несколькими параметрами:

В этом примере функция add принимает два параметра a и b и возвращает их сумму.

Вызов функции с несколькими аргументами:

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

Возвращаемые значения и ключевое слово return

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

Пример функции, возвращающей значение:

В этом примере функция square принимает один параметр x и возвращает его квадрат.

Вызов функции и использование возвращаемого значения:

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

Возвращение нескольких значений

Функции в Python могут возвращать несколько значений, используя кортежи.

Пример функции, возвращающей несколько значений:

В этом примере функция get_full_name возвращает полное имя и инициалы.

Вызов функции и использование возвращаемых значений:

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

Заключение

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

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

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

Читайте также

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

Что такое функция

Функции в Python (да и в программировании в целом) нужны для того, чтобы делать код проще и удобнее.

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

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

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

Функциональная парадигма программирования

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

Многие думают, что функциональное программирование — это когда используешь функции, но это не так. 

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

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

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

Для создания функций в Python есть ключевой параметр-слово def. В Python def означает, что сейчас будет объявлена функция.

Порядок определения функции такой:

Вот пример функции describe_pet, которая выводит описание домашнего питомца. Эта функция принимает два аргумента: тип животного и его имя. Если вызвать её и передать эти два аргумента, она вставит их в строку и выведет на экран:

# объявляем функцию и даём ей имя
def describe_pet(animal_type, pet_name):
   """
   Выводит информацию о питомце.

   :param animal_type: Тип животного (например, "кошка", "собака").
   :param pet_name: Имя питомца.
   """
   print(f"У вас есть {animal_type}, ее зовут {pet_name}.")


# вызываем функцию и передаём ей аргументы для работы
describe_pet("кошка", "Мурка")

Результат вызова:

У вас есть кошка, ее зовут Мурка.

Возвращаемые значения (return)

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

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

# объявляем функцию
def add(a, b):
   # говорим функции возвращать результат сложения
   return a + b


# сохраняем результат в переменную
result = add(3, 5)
# выводим результат на экран
print(result)

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

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

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

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

Пример — возвращаем минимальное и максимальное значение из списка:

# объявляем функцию
def min_max(numbers):
   # просим вернуть минимальное и максимальное значение
   # из коллекции элементов, которую мы передадим
   # эти значения вернутся в виде кортежа
   return min(numbers), max(numbers)


# распаковываем значения в отдельные переменные minimum и maximum
minimum, maximum = min_max([10, 20, 30])
# выводим значения на экран
print(f"Минимум: {minimum}, Максимум: {maximum}")

При вызове этого блока кода на экране получим:

Минимум: 10, Максимум: 30

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

Для создания пустой функции её нужно объявить и в теле функции прописать только одно слово — pass.

# объявляем пустую функцию
def placeholder_function():
   pass

Функции и процедуры

Процедуры в Python — это функции, которые ничего не возвращают. 

Наша функция describe_pet() про вывод информации о домашнем животном — это процедура, потому что в ответ мы ничего не получаем. А add() с возвращением суммы двух чисел — классическая функция. 

👉 Правило простое: чтобы превратить функцию в процедуру в Python, нужно не использовать команду return() в конце функции.

Объявление и вызов функций

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

Так происходит потому, что Python — интерпретируемый язык, и весь код перед исполнением будет переработан в список инструкций для машины. Этот список интерпретатор Python будет выполнять построчно. Когда интерпретатор встречает вызов функции, к этому моменту он уже должен знать, что это за функция и как она определена. Если функция ещё не объявлена — Python выдаст ошибку и остановит выполнение кода.

Область видимости функций

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

Областей видимости при использовании функций в Python три. 

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

Пример — локальная переменная x. Её нельзя будет использовать в других местах программы, только внутри этой функции (то есть там, где она объявлена):

# объявляем функцию с локальной переменной
def local_example():
   # эта переменная видна только внутри функции
   x = 10

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

Этот код:

# объявляем объемлющую функцию
def outer_function():
   # переменная в области объемлющей функции
   y = 20

   # объявляем вложенную функцию
   def inner_function():
       # переменная в области объемлющей функции доступна
       # для использования во вложенной функции, но не для изменения
       print(f"Переменная из объемлющей области y = {y}")
   
   # вызываем вложенную функцию
   inner_function()

# вызываем объемлющую функцию
outer_function()

Выведет в консоли такой результат:

Переменная из объемлющей области y = 20

Если нужно сделать так, чтобы вложенная функция могла изменять значения в объемлющей, нужно отметить эти значения словом nonlocal:

# объявляем объемлющую функцию
def outer_function():
   # переменная в области объемлющей функции
   y = 20

   # объявляем вложенную функцию
   def inner_function():
       # указываем, что хотим изменить переменную объемлющей области
       nonlocal y
       # изменяем переменную
       y = 30
       print(f"Вложенная функция изменила y на {y}")

   # вызываем вложенную функцию
   inner_function()
   print(f"После изменения: y = {y}")


# вызываем объемлющую функцию
outer_function()

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

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

# глобальная переменная в теле кода
z = 50 


# объявляем функцию
def global_example():
   # используем доступ к глобальной переменной
   print(f"Глобальная переменная z = {z}")


# вызываем функцию
global_example()

Результат в консоли:

Глобальная переменная z = 50

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

# глобальная переменная
z = 50
# проверяем переменную
print(f"До вызова функции z = {z}")


# объявляем функцию
def modify_global():
   # указываем, что хотим изменить глобальную переменную
   global z
   # изменяем глобальную переменную
   z = 100
   # выводим результат изменения
   print(f"Внутри функции z = {z}")


# вызываем функцию
modify_global()
# проверяем результат работы функции
print(f"После вызова функции z = {z}")

Запускаем:

До вызова функции z = 50

Внутри функции z = 100

После вызова функции z = 100

Аргументы функций

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

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

# объявляем функцию и передаём позиционные аргументы
def greet(name, age):
   # пишем тело функции
   print(f"Привет, {name}! Тебе {age} лет.")


# аргументы передадутся в таком порядке:
# name="Алиса", age=30
greet("Алиса", 30) 

Если при передаче значений поменять их местами, то в name вместо "Алиса" функция запишет 30, а вместо возраста — "Алиса".

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

# объявляем функцию и передаём позиционные аргументы
def greet(name, age):
   # пишем тело функции
   print(f"Привет, {name}! Тебе {age} лет.")


# при такой передаче аргументов их порядок можно менять
greet(age=30, name="Алиса")

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

# объявляем функцию и передаём для аргумента
# age значение по умолчанию
def greet(name, age=18):
   # пишем тело функции
   print(f"Привет, {name}! Тебе {age} лет.")


# вызываем функцию без передачи age
greet("Алиса")
# вызываем функцию и изменяем значение age
greet("Боб", 25)

Аргументы переменной длины (*args и **kwargs) нужны, если мы не знаем, сколько аргументов нам понадобится. Чем они отличаются:

Вот как это будет выглядеть для позиционных аргументов:

# объявляем функцию с произвольным количеством позиционных аргументов
def sum_numbers(*args):
   # пишем тело функции
   total = sum(args)
   # выводим на экран сумму позиционных аргументов
   print(f"Сумма: {total}")


# вызываем функцию
sum_numbers(1, 2, 3, 4)

Такой код выведет в консоли:

Сумма: 10

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

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

# объявляем функцию с произвольным количеством именованных аргументов
def describe_person(**kwargs):
   # пишем тело функции
   for key, value in kwargs.items():
       # выводим на экран словарь вида аргумент:значение
       print(f"{key}: {value}")


# вызываем функцию
describe_person(name="Алиса", age=30, city="Москва")

Получаем:

name: Алиса

age: 30

city: Москва

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

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

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

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

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

Словарь в качестве аргументов выглядит как переменная, которую передали в функцию через **kwargs. Внутри функции этот аргумент можно распаковать. Для этого нужно знать, как выглядит словарь — тогда мы можем задать правильный алгоритм:

# объявляем функцию с позиционными аргументами
def describe_person(name, age, city):
   # пишем тело функции
   print(f"{name}, {age} лет, живёт в {city}")


# создаём словарь
person = {"name": "Алиса", "age": 30, "city": "Москва"}
# распаковываем словарь функцией
describe_person(**person)

При запуске Python распакует переменную со словарём и разложит значения по указанным в логике местам:

Алиса, 30 лет, живёт в Москва

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

Def в Python даёт начало обычным, классическим функциям, но есть и другие.

Lambda-функция — короткая анонимная функция, которая создаётся с помощью ключевого слова lambda. Чаще всего они используются для создания простых функций, которые нужны в одном месте.

Как создать лямбда-функцию:

Пример, как может определяться простая lambda-функция подсчёта квадрата числа:

# объявляем переменную и присваиваем ей лямбда-функцию
square = lambda x: x ** 2
# выводим результат работы
print(square(5))

В консоли получаем ответ:

5

Напоследок: чистые функции и побочные эффекты

Чистая функция — функция, которая:

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

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

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

Определение функции

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

Синтаксис:

    def имя_функции(параметры):
        """docstring"""
        инструкция1
        инструкция2
        ...
        ...
        return [выражение]

За ключевым словом def следует подходящий идентификатор (имя функции) и круглые скобки. В круглых скобках может быть дополнительно указан один или несколько параметров. Символ ‘:’ после круглых скобок начинает блок с отступом (тело функции).

Первой инструкцией в теле функции может быть строка, которая называется docstring. Она описывает функциональность функции/класса. Строка docstring не является обязательной.

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

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

В следующем примере определена функция welcome().

Пример созданной пользователем функции:

    def welcome():
        """This function prints 'Welcome!'"""
        print('Welcome!')

Выше мы определили функцию welcome(). Первая инструкция — это docstring, в котором сообщается о том, что делает эта функция. Вторая — это метод print, который выводит указанную строку на консоль. Обратите внимание, что welcome() не содержит оператор return.

Чтобы вызвать определенную ранее функцию, просто используйте выражение, состоящее из ее имени и двух круглых скобок ‘()’, в любом месте кода. Например, приведенная выше функция может быть вызвана так: welcome().

Пример вызова определенной пользователем функции:

Вывод:

По умолчанию все функции возвращают None, если отсутствует оператор return.

returned_value = welcome()
print(returned_value)

Вывод:

Функция help() выводит docstring, как показано ниже.

    >>> help(welcome)
    Help on function welcome in module __main__:
    
    welcome()
        This function prints 'Welcome!'

Параметры функции

Функции также могут принимать на вход один или несколько параметров (они же аргументы) и использовать их для вычислений, определенных внутри функционального блока. В таком случае параметрам/аргументам даются подходящие формальные имена. Для примера изменим функцию welcome(): теперь она принимает в качестве параметра строку user_name; также изменена инструкция с функцией print() для отображения более персонализированного приветствия.

Пример функции с аргументами:

def welcome(user_name):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # вызов функции с параметром

Вывод:

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

Параметры функции могут иметь аннотацию для указания типа аргумента с использованием синтаксиса parameter:type. Например, следующая аннотация указывает тип параметра string.

Пример использования аннотации типов:

def welcome(user_name:str):
    print('Welcome, ' + user_name + '!')

welcome('Anon') # передача строки в функцию
                # пройдет нормально
welcome(42) # а передача числа в функцию
            # вызовет ошибку

Передача нескольких параметров

Функция может иметь множество параметров. Представленная ниже вариация welcome() принимает три аргумента.

Пример определения функции с несколькими параметрами:

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome('Anton', 'Chekhov') # передача аргументов в функцию

Вывод:

Неизвестное количество аргументов

Функция в Python может иметь неизвестное заранее число параметров. Укажите * перед аргументом, если вы не знаете, какое количество параметров передаст пользователь.

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

def welcome(*name_parts):
    message = 'Welcome, ' + name_parts[0] + " "
    message += name_parts[1] + " " + name_parts[2]
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov')

Вывод:

Welcome, Anton Pavlovich Chekhov!

Следующая функция работает с любым количеством аргументов.

Пример функции, использующей все переданные ей параметры:

def welcome(*name_parts):
    message = 'Welcome,'
    for part in name_parts:
        message += " " + part
    print(message + "!")

welcome('Anton', 'Pavlovich', 'Chekhov',
    'and', 'Fyodor', 'Mikhailovich', 'Dostoevsky')

Вывод:

Welcome, Anton Pavlovich Chekhov and Fyodor Mikhailovich Dostoevsky!

Аргументы-ключевые слова

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

def welcome(first_name:str, last_name:str):
    print('Welcome, ' + first_name + ' ' + last_name + '!')

welcome(last_name='Chekhov', first_name='Anton') # передача
    # аргументов в функцию в произвольном порядке

Вывод:

Аргументы-ключевые слова **kwarg

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

Пример использования **kwarg:

def welcome(**name_parts):
    print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')

welcome(last_name='Chekhov', first_name='Anton')
welcome(last_name='Chekhov', first_name='Anton', age='28')
welcome(last_name='Chekhov') # вызовет KeyError 

Вывод:

Welcome, Anton Chekhov!
Welcome, Anton Chekhov!

При использовании параметра ** порядок аргументов не имеет значения. Однако их имена должны быть идентичными. Доступ к аргументам-ключевым словам для получения переданных значений осуществляется с помощью такого выражения: имя_параметра_kwarg[‘имя_переданного_аргумента’].

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

Пример функции, вызывающей KeyError:

    def welcome(**name_parts):
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
    
    welcome(last_name='Chekhov') # вызывет KeyError: необходимо предоставить аргумент 'first_name'

Вывод:

    Traceback (most recent call last):
        ...
        line 2, in welcome
        print('Welcome, ' + name_parts['first_name'] + ' ' + name_parts['last_name'] + '!')
        KeyError: 'first_name'

Параметры со значением по умолчанию

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

Представленная ниже функция welcome() определена с параметром name, имеющим значение по умолчанию ‘Anon’. Оно будет заменено только в том случае, если вызывающей стороной будет передан какой-либо фактический аргумент.

Пример функции со значением по умолчанию:

def welcome(user:str = 'Anon'):
    print('Welcome, ' + user + '!')

welcome()
welcome('Chekhov')

Вывод:

Welcome, Anon!
Welcome, Chekhov!

Функция с возвращаемым значением

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

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

Пример функции с возвращаемым значением:

def get_product(a, b): 
    return a * b

Ниже показано, как при вызове функции get_product() получить результат ее работы.

Пример использования функции с возвращаемым значением:

result = get_product(6, 7) 
print(result)
result = get_product(3, get_product(4, 5))
print(result)

Вывод:

Функции

Последнее обновление: 16.01.2022

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

def имя_функции ([параметры]):
    инструкции

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

Например, определение простейшей функции:

def say_hello():
    print("Hello")

Функция называется say_hello. Она не имеет параметров и содержит одну единственную инструкцию,
которая выводит на консоль строку «Hello».

Обратите внимание, что инструкции функции должны иметь отступы от начала функции. Например:

def say_hello():
    print("Hello")


print("Bye")

Здесь инструкция print("Bye") не имеет отступов от начала функции say_hello и поэтому в эту функцию не входит.
Обычно между определением функции и остальными инструкциями, которые не входят в функцию, располагаются две пустых строки.

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

имя_функции ([параметры])

Например, определим и вызовем функцию:

def say_hello():    # определение функции say_hello
    print("Hello")


say_hello()         # вызов функции say_hello
say_hello()
say_hello()

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

Hello
Hello
Hello

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

Если функция имеет одну инструкцию, то ее можно разместить на одной строке с остальным определением функции:

def say_hello(): print("Hello")

say_hello()

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

def say_hello():
    print("Hello")


def say_goodbye():
    print("Good Bye")


say_hello()
say_goodbye()

Консольный вывод:

Hello
Good Bye

Локальные функции

Одни функции могут определяться внутри других функций — внутренние функции еще называют локальными. Локальные функции
можно использовать только внутри той функции, в которой они определены. Например:

def print_messages():
    # определение локальных функций
    def say_hello(): print("Hello")
    def say_goodbye(): print("Good Bye")
    # вызов локальных функций
    say_hello()
    say_goodbye()

# Вызов функции print_messages
print_messages()

#say_hello() # вне функции print_messages функция say_hello не доступна

Здесь функции say_hello() и say_goodbye() определены внутри функции print_messages() и поэтому по отношению к ней
являются локальными. Соответственно они могут использоваться только внутри функции print_messages()

Организация программы и функция main

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

def main():
    say_hello()
    say_goodbye()

def say_hello():
    print("Hello")

def say_goodbye():
    print("Good Bye")

# Вызов функции main
main()