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

В программировании на 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 возвращает сообщение, если подстрока не найдена.

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

ТемаОписаниеПример кодаРезультат
Что такое вложенная функция?Функция, определённая внутри другой функции. Её можно вызвать только внутри внешней функции.python<br>def outer_function():<br> def inner_function():<br> print("Это вложенная функция")<br> inner_function()<br>outer_function()Вывод: 
"Это вложенная функция"
Определение вложенной функцииВложенные функции создаются с помощью def, как и обычные, но внутри другой функции.python<br>def greet(name):<br> def display_message():<br> print("Приветствую!")<br> display_message()<br> print(f"Как дела, {name}?")<br>greet("Алексей")Вывод: 
"Приветствую!"
"Как дела, Алексей?"
Почему использовать вложенные функции?Вложенные функции: 
- Улучшают читаемость 
- Разделяют логику 
- Ограничивают область видимости
--
Вызов вложенных функцийВнутреннюю функцию можно вызвать только из внешней функции, иначе будет ошибка.python<br>def outer_function():<br> def inner_function():<br> print("Это вложенная функция")<br> inner_function()<br>outer_function()<br>inner_function()Ошибка: 
NameError: inner_function is not defined
Пример 1: Математические операцииОпределение вложенных функций для сложения и вычитания.python<br>def calculate(a, b):<br> def add():<br> return a + b<br> def subtract():<br> return a - b<br> return add(), subtract()<br>print(calculate(5, 3))Вывод: (8, 2)
Пример 2: Работа с текстомПреобразование строки в верхний регистр и подсчёт гласных.python<br>def process_text(text):<br> def to_uppercase():<br> return text.upper()<br> def count_vowels():<br> vowels = "AEIOU"<br> return sum(1 for char in text.upper() if char in vowels)<br> return to_uppercase(), count_vowels()<br>print(process_text("Hello World"))Вывод: ('HELLO WORLD', 3)
Передача аргументов во вложенные функцииВнутренние функции могут использовать переменные внешней функции.python<br>def multiply_by_factor(number, factor):<br> def multiply():<br> return number * factor<br> return multiply()<br>print(multiply_by_factor(10, 2))Вывод: 20
Пример 3: Сортировка спискаВложенная функция используется для сортировки студентов по оценкам.python<br>def sort_students(students):<br> def get_grade(student):<br> return student[1]<br> return sorted(students, key=get_grade, reverse=True)<br>students = [("Алексей", 90), ("Мария", 95), ("Дмитрий", 85)]<br>print(sort_students(students))Вывод: [('Мария', 95), ('Алексей', 90), ('Дмитрий', 85)]
Пример 4: Проверка подстрокиПроверка, содержится ли подстрока в тексте, с использованием вложенных функций.python<br>def check_substring(text, substring):<br> def contains():<br> return substring in text<br> def not_contains():<br> return substring + " не найдена."<br> return contains() if substring in text else not_contains()<br>print(check_substring("Привет, мир!", "мир"))Вывод: True

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

 

 

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

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

Комментарии