Определение и вызов вложенных функций

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

Что такое вложенная функция?

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

Пример:

def outer_function():
    def inner_function():
        print("Это вложенная функция")
    
    inner_function()  # Вызов вложенной функции

outer_function()  # Вызов внешней функции

Когда вы запускаете этот код, результат будет:

Это вложенная функция

Определение вложенной функции

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

Пример:

def greet(name):
    def display_message():
        print("Приветствую!")
    
    display_message()
    print(f"Как дела, {name}?")

greet("Алексей")

Вывод будет таким:

Приветствую!
Как дела, Алексей?

Здесь функция display_message — это вложенная функция, которая вызывается внутри основной функции greet.

Почему использовать вложенные функции?

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

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

Вызов вложенных функций

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

def outer_function():
    def inner_function():
        print("Это вложенная функция")
    
    # Внутри внешней функции мы можем вызвать внутреннюю
    inner_function()

outer_function()

Попытка вызвать inner_function за пределами outer_function приведёт к ошибке:

inner_function()  # Ошибка, функция не видна в глобальной области

Пример 1: Математические операции

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

def calculate(a, b):
    def add():
        return a + b
    
    def subtract():
        return a - b
    
    addition = add()       # Вызов вложенной функции сложения
    subtraction = subtract()  # Вызов вложенной функции вычитания
    
    return addition, subtraction

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

Здесь функция calculate определяет две вложенные функции: add и subtract, которые выполняют свои операции. Они вызываются внутри основной функции, а результат возвращается в виде кортежа.

Пример 2: Работа с текстом

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

def process_text(text):
    def to_uppercase():
        return text.upper()
    
    def count_vowels():
        vowels = "AEIOU"
        return sum(1 for char in text.upper() if char in vowels)
    
    upper_text = to_uppercase()  # Преобразование строки в верхний регистр
    vowel_count = count_vowels()  # Подсчёт гласных
    
    return upper_text, vowel_count

result = process_text("Hello World")
print(result)  # Вывод: ('HELLO WORLD', 3)

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

Передача аргументов во вложенные функции

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

Пример:

def multiply_by_factor(number, factor):
    def multiply():
        return number * factor
    
    return multiply()

result = multiply_by_factor(10, 2)
print(result)  # Вывод: 20

Здесь функция multiply использует параметры number и factor, которые были переданы во внешнюю функцию multiply_by_factor.

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

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

def sort_students(students):
    def get_grade(student):
        return student[1]
    
    return sorted(students, key=get_grade, reverse=True)

students = [("Алексей", 90), ("Мария", 95), ("Дмитрий", 85)]
sorted_students = sort_students(students)
print(sorted_students)

Здесь функция get_grade — это вложенная функция, которая возвращает оценку студента. Она используется в качестве ключа для сортировки в основной функции sort_students.

Вывод будет:

[('Мария', 95), ('Алексей', 90), ('Дмитрий', 85)]

Вложенные функции для управления потоком выполнения

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

def check_age(age):
    def minor():
        return "Вы несовершеннолетний."
    
    def adult():
        return "Вы взрослый."
    
    if age < 18:
        return minor()
    else:
        return adult()

age = int(input("Введите ваш возраст: "))  # Ввод: 20
result = check_age(age)
print(result)

Если пользователь введёт возраст меньше 18, вызовется функция minor, иначе — adult. Это помогает организовать логику в зависимости от условий.

Пример 4: Проверка наличия подстроки

Допустим, мы хотим проверить, содержит ли строка определённую подстроку.

def check_substring(text, substring):
    def contains():
        return substring in text
    
    def not_contains():
        return substring + " не найдена."
    
    return contains() if substring in text else not_contains()

result = check_substring("Привет, мир!", "мир")
print(result)  # Вывод: True

Здесь вложенная функция contains проверяет наличие подстроки, а not_contains возвращает сообщение, если подстрока не найдена.

Таблица по лекции:
 

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

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

Перейти к следующему шагу