Основы Python: Функции

Функции – это строительные блоки программирования.

Функция – это блок кода, который используется для выполнения задачи/действия или преобразования данных.
Она может быть вызвана несколько раз, с разными входными данными.

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

Функция печати

Обычно первое, что вы изучаете в Python (или любом другом языке программирования), – это вывод предложения “Hello World!” на вывод терминала.
Вот как выглядел бы код:

print("Hello World!")

Здесь мы фактически вызываем встроенную функцию print со строкой в качестве аргумента со значением "Hello World!".

Можно упростить и представить функцию print следующим образом:

def print(value):
    # do something with the value to 
    # display it on the terminal output.
    # ...
    return None

Эта воображаемая функция print имеет параметр value. Затем она выводит value на терминал и возвращает None.
Более подробно о том, что такое параметр a и что такое оператор return, мы расскажем позже.

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

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

• скрыть детали реализации
• дать им осмысленное имя
• сделать их максимально пригодными для повторного использования

Создание собственных функций

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

Как определить функцию

Чтобы определить собственную функцию, вам необходимо:

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

Первая строка, когда вы определяете функцию, называется сигнатурой функции, она содержит ключевое слово (def), имя функции и, по желанию, некоторые параметры.

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

Определение функции без параметров

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

def my_first_function():
    print("Hello inside a function!")

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

Определение функции с параметрами

Вот два примера функций с параметрами:

def greeting(name):
    print(f"Hello {name}, from inside a function!")

def polite_greeting(title, surname):
    print(f"Dear {title} {surname}, greetings from inside a function!")

Здесь имя первой функции greeting, она принимает один параметр name (внутри круглых скобок).

Имя второй функции polite_greeting, она принимает два параметра title и surname (внутри круглой скобки).

Опять же, они обе вызывают встроенную функцию print, на этот раз с f-строкой.

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

Как вызвать функцию

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

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

my_first_function()

Это должно быть ниже определения функции в вашей программе.

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

my_first_function()
my_first_function()
my_first_function()

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

1. С помощью встроенных переменных

В этом методе мы напрямую передаем встроенные значения в функцию:

greeting("Jane")
polite_greeting("Mrs", "Jackson")

• Мы передаем значение "Jane" непосредственно в функцию greeting.
  Когда функция выполняется, мы имеем name="Jane" внутри функционального блока.

• Мы передаем значения "Mrs" и "Jackson" непосредственно в функцию polite_greeting.
  Когда функция будет выполнена, у нас будет title="Mrs" surnname="Jackson" внутри функционального блока.

2. С помощью существующей(их) переменной(ых)

В этом методе мы передаем существующие переменные в функцию:

first_name = "John"
greeting(first_name)
title = "Dr"
surname = "Jackson"
polite_greeting(title, surname)

• Мы передаем переменную first_name в функцию greeting.
  Когда функция будет выполнена, внутри блока функций у нас будет name=first_name (что эквивалентно name="John").

• Мы передаем переменные title и surname в функцию polite_greeting.
  Когда функция выполняется, мы имеем title=title surnname=surname внутри блока функции (что эквивалентно title="Dr" surnname="Jackson").

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

3. С аргументами в виде ключевых слов

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

first_name = "John"
greeting(name=first_name)
title = "Dr"
surname = "Jackson"
polite_greeting(title=title, surname=surname)

Мы явно говорим, что хотим, чтобы при вызове переменной внутри нашего функционального блока greeting ее имя было first_name.

Вот пример со встроенными значениями:

polite_greeting(title="Mrs", surname="Jackson")

Оператор возврата функции в Python

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

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

Приведенная выше функция принимает 2 параметра, a и b, вычисляет сумму этих переменных и сохраняет ее в переменной result.
Затем она возвращает эту переменную result.
Когда вы вызываете эту функцию, вы можете присвоить ее возвращаемое значение переменной следующим образом:

c = add(5, 5)
# here c = 10

d = add(1, 5)
# here d = 6

one = 1
two = 2
f = add(one, two)

g = add(c, d)
# here g = 16

Здесь вы видите пример того, как функция add может быть использована и вызвана несколько раз.
Она может вызываться непосредственно со значениями (пример c и d) или с существующими переменными (пример f и g).

В Python функция всегда возвращает значение. Если вы явно не напишете оператор return в определении функции, Python добавит неявный return None.
Другими словами, если функция не имеет явного оператора возврата, она вернет None.

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

def does_nothing():
    pass

nothing = does_nothing()
# here nothing = None

Пример использования 1: среднее значение списка

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

grades_1 = [12, 15, 10, 17]

sum  = 0
for grade in grades_1:
    sum += grade
avg = round(sum / len(grades_1), 2)

Мы суммируем все элементы в списке, а затем делим сумму на длину списка, округляя результат максимум до 2 знаков после запятой.

Это работает, но не пригодно для повторного использования. Если я захочу сделать это снова для другого списка оценок, например grades_2 = [18, 15, 11, 13],
мне придется скопировать и вставить мой код выше и подправить его, чтобы он работал с переменной grades_2.
Однако, если я создам функцию average, я смогу легко использовать ее повторно для двух списков. Давайте сделаем это:

def average(grades):
    sum  = 0
    for grade in grades:
        sum += grade
    avg = round(sum / len(grades), 2)
    return avg

Это тот же код, что и выше, только извлеченный в функцию.

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

grades_1 = [12, 15, 10, 17]
grades_2 = [18, 15, 11, 13]
avg_1 = average(grades=grades_1)
# here avg_1 = 13.5
avg_2 = average(grades=grades_2)
# here avg_2 = 14.25

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

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

def format(names):
    result = []
    for name in names:
        formatted_name = name.title()
        result.append(formatted_name)
    return result


unformatted_names = ["JANE", "john", "Janet"]
formatted_names = format(names=unformatted_names)
# here formatted_names = ['Jane', 'John', 'Janet']

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

Заключение

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

Код

Весь код из этой статьи можно найти в этом репите.