Введение

В Python есть известные для многих функции:

• функция Python print() выводит объект на печать в терминале;
• int() превращает данные в целое число;
• len() возвращает длину объекта.

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

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

Начнем с превращения в функцию классический «Hello, World!». Создадим в текстовом редакторе новый файл и назовем его hello.py. Затем определим функцию.

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

В нашем случае определяем функцию с названием hello():

1. hello.py
2. def hello():

Мы создали начальную инструкцию для создания функции.

Теперь добавляем вторую строку, в которой устанавливаем инструкции для функции. В примере мы будем печатать в консоли «Hello, World»!

1. hello.py
2. def hello():
3. print("Hello, World!")

Теперь Python строковая функция полностью определена, но если мы запустим программу, ничего не произойдет, так как мы не вызвали ее. Поэтому вызовем функцию с помощью hello():

1. hello.py
2. def hello():
3. print("Hello, World!")
4.  
5. hello()

Запускаем программу:

1. python hello.py

Должно получиться следующее:

1. Результат
2.  
3. Hello, World!

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

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

1. names.py
2.  
3. # Определяем функцию names()
4. def names():
5. # Задаем имя переменной с вводом
6. name = str(input('Введите имя: '))
7. # Проверить, содержит ли имя гласную
8. if set('aeiou').intersection(name.lower()):
9. print('Имя содержит гласную.')
10. else:
11. print('Имя не содержит гласную.')
12.  
13. # Итерация по имени
14. for letter in name:
15. print(letter)
16.  
17. # Вызываем функцию
18. names()

Python вызов функции names(), которую мы определили, задает условную инструкцию и цикл for. Из этого примера видно, как можно организовать код в пределах функции. Также можно определить условное выражение и цикл for как две отдельные функции.

Работа с параметрами

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

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

1. add_numbers.py
2. def add_numbers(x, y, z):
3. a = x + y
4. b = x + z
5. c = y + z
6. print(a, b, c)
7.  
8. add_numbers(1, 2, 3)

Мы передали число 1 в параметр x, число 2 в параметр y, и число 3 в параметр z. Эти значения соответствуют каждому параметру в том порядке, в котором они приведены.

Программа выполняет математические вычисления на основе значений параметров:

1. a = 1 + 2
2. b = 1 + 3
3. c = 2 + 3

Функция Python выводит результаты математических расчетов a, b, и c, где a должно равняться 3, b — 4 и c — 5. Запускаем программу:

1. python add_numbers.py
2.  
3. Результат
4. 3 4 5

Когда значения 1, 2 и 3 мы передаем в качестве параметров функции add_numbers(), то получаем ожидаемый результат.

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

Именованные аргументы

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

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

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

1. profile.py
2. # Определяем функцию с параметрами
3. def profile_info(username, followers):
4. print("Имя Username: " + username)
5. print("Followers: " + str(followers))

В определении функции username и followers находятся в скобках. Блок функции выводит информацию о пользователе в виде строк с применением двух параметров.

Теперь можем вызвать функцию и назначить ей параметры:

1. profile.py
2. def profile_info(username, followers):
3. print("Имя Username: " + username)
4. print("Followers: " + str(followers))
5.  
6. # Вызываем функцию с указанными выше параметрами
7. profile_info("sammyshark", 945)
8.  
9. # Вызываем функцию с именованными аргументами
10. profile_info(username="AlexAnglerfish", followers=342)

При первом Python вызове функции мы ввели имя пользователя sammyshark и его 945 подписчиков. При втором вызове функции мы использовали именованные аргументы, присваивая значения переменным аргументов.

Запускаем программу:

python profile.py

 

Результат

Username: sammyshark

Followers: 945

Username: AlexAnglerfish

Followers: 342

В результате получаем имена пользователей и количество их подписчиков.

Из следующего примера видим, что для той же программы, но с другим вызовом, можно менять последовательность параметров:

profile.py

def profile_info(username, followers):

print("Имя Username: " + username)

print("Followers: " + str(followers))

 

# Изменяем последовательность параметров

profile_info(followers=820, username="cameron-catfish")

 

Снова запустив программу, получаем следующее:

Результат

Username: cameron-catfish

Followers: 820

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

Значения аргументов по умолчанию

Также можно указать значения по умолчанию для обоих параметров. Создадим значение по умолчанию для параметра followers со значением 1:

1. profile.py
2. def profile_info(username, followers=1):
3. print("Имя Username: " + username)
4. print("Followers: " + str(followers))

Теперь можно запустить функцию с параметром username, а число подписчиков по умолчанию будет 1. При желании можно изменить количество пользователей:

1. profile.py
2. def profile_info(username, followers=1):
3. print("Имя Username: " + username)
4. print("Followers: " + str(followers))
5.  
6. profile_info(username="JOctopus")
7. profile_info(username="sammyshark", followers=945)

Запустив программу командой python profile.py, получаем следующее:

1. Результат
2.  
3. Username: JOctopus
4. Followers: 1
5. Username: sammyshark
6. Followers: 945

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

Возврат значения

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

До сих пор мы использовали print(), а не return. Создадим программу, которая вместо вывода в терминал будет возвращать переменную.

В новом текстовом файле создадим программу, которая будет возводить в квадрат параметр x и возвращать переменную y. Выполняем вызов, чтобы вывести переменную result после запуска функции square() с аргументом 3:

1. square.py
2. def square(x):
3. y = x ** 2
4. return y
5.  
6. result = square(3)
7. print(result)

Запускаем программу, чтобы увидеть результат:

1. python square.py
2.  
3. Результат
4. 9

В качестве выходных данных получаем число 9, что и является результатом возведения в квадрат числа 3. Рассмотрим действие инструкции return в программе:

1. square.py
2. def square(x):
3. y = x ** 2
4. # return y
5.  
6. result = square(3)
7. print(result)

Снова запускаем программу:

1. python square.py
2.  
3. Результат
4. None

Без return программа не может вернуть значение, поэтому оно равно None.

В следующем примере Python математической функции заменим print() из программы add_numbers.py на инструкцию return:

1. add_numbers.py
2. def add_numbers(x, y, z):
3. a = x + y
4. b = x + z
5. c = y + z
6. return a, b, c
7.  
8. sums = add_numbers(1, 2, 3)
9. print(sums)

Вне функции объявляем переменную sums, которая равна результату действия функции для чисел 1, 2 и 3 из примера, приведенного выше. Затем выводим переменную sums. Снова запускаем программу, теперь уже с инструкцией return:

1. python add_numbers.py
2.  
3. Результат
4.  
5. (3, 4, 5)

На выходе получаем те же числа, что и с использованием инструкции print(). Теперь результат предоставлен в виде кортежа, так как в списке выражений инструкции return имеется запятая.

Функции Python немедленно завершаются, когда встречают инструкцию return, независимо от того, возвращают они значение или нет:

1. return_loop.py
2. def loop_five():
3. for x in range(0, 25):
4. print(x)
5. if x == 5:
6. # Функция останавливается на x == 5
7. return
8. print("Эта строка не будет выполняться.")
9.  
10. loop_five()

Инструкция return в цикле for завершает функцию, поэтому строка вне цикла не будет выполняться. При использовании инструкции break был бы завершен только цикл, и выполнялась последняя строка print().

Инструкция return завершает функцию и может возвращать значение в случае применения параметров.

Использование main() в качестве функции

Хотя в Python можно вызывать функцию, которая находится в конце программы, во многих языках программирования (таких как C++ и Java) для выполнения программы требуется функция main. Применение функции main() не обязательно, но поможет организовать логику программы, помещая важные элементы в одну функцию.

Начнем с добавления Python функции main() в уже составленную программу hello.py. Оставляем функцию hello() и определяем функцию main():

1. hello.py
2. def hello():
3. print("Hello, World!")
4.  
5. def main():

Применяем инструкцию print(), чтобы знать, что мы находимся в функции main(). Кроме этого вызовем функцию hello() внутри функции main():

1. hello.py
2. def hello():
3. print("Hello, World!")
4.  
5. def main():
6. print("Это главная функция")
7. hello()

Ниже вызываем функцию main():

1. hello.py
2. def hello():
3. print("Hello, World!")
4.  
5. def main():
6. print("Это главная функция.")
7. hello()
8.  
9. main()

Теперь запускаем программу:

1. python hello.py
2.  
3. Получаем следующее:
4. Результат
5. Это главная функция.
6. Hello, World!

Поскольку мы вызвали Python строковую функцию hello() внутри main(), а затем вызвали только функцию main(), то получили текст «Hello, World!» один раз после строки, которая сообщает, что мы находимся в главной функции.

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

На языке Python ‘__main__’ — это имя области, в которой будет выполняться код верхнего уровня. Если программа запускается стандартным вводом или с помощью интерактивного запроса, то __name__ устанавливается равным ‘__main__’.

В связи с этим существует соглашение о применении следующей конструкции:

1. if __name__ == '__main__':
2.  
3. # Код для выполнения, когда это главная программа

Так мы получаем возможность использовать программные файлы в качестве:

• главной программы и запускать ту часть, которая следует после инструкции if;
• модуля и не запускать то, что следует после инструкции if.

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

Расширим программу names.py и создадим новый файл more_names.py. Объявим в этой программе глобальную переменную и изменим функцию names() так, чтобы инструкции находились в двух отдельных Python функциях.

Первая функция has_vowel() будет проверять, содержит ли строка name гласную. Вторая функция print_letters() выведет все буквы строки name:

1. more_names.py
2. # Объявляем глобальную переменную name для применения во всех функциях
3. name = str(input('Введите имя: '))
4.  
5. # Определяем функцию, чтобы проверить, содержит ли имя гласную букву
6. def has_vowel():
7. if set('aeiou').intersection(name.lower()):
8. print('Имя содержит гласную.')
9. else:
10. print('Имя не содержит гласную.')
11.  
12. # Итерация по буквам в строке имени
13. def print_letters():
14. for letter in name:
15. print(letter)

Определим main(), которая содержит вызов Python математических функций has_vowel() и print_letters():

1. more_names.py
2. # Объявить имя глобальной переменной для применения во всех функциях
3. name = str(input('Введите имя: '))
4.  
5. # Определяем функцию, чтобы проверить, содержит ли имя гласную букву
6. def has_vowel():
7. if set('aeiou').intersection(name.lower()):
8. print('Имя содержит гласную.')
9. else:
10. print('Имя не содержит гласную.')
11.  
12. # Итерация по буквам в строке имени
13. def print_letters():
14. for letter in name:
15. print(letter)
16.  
17. # Определяем основной метод для вызова других функций
18. def main():
19. has_vowel()
20. print_letters()

В конце файла добавляем конструкцию if __name__ == ‘__main__’:. Для запуска всех Python функций вызываем main() после инструкции if.

1. more_names.py
2.  
3. # Объявляем глобальную переменную name для применения во всех функциях
4. name = str(input('Введите имя: '))
5.  
6. # Определяем функцию, чтобы проверить, содержит ли имя гласную букву
7. def has_vowel():
8. if set('aeiou').intersection(name.lower()):
9. print('Имя содержит гласную.')
10. else:
11. print('Имя не содержит гласную.')
12.  
13. # Итерация по буквам в строке имени
14. def print_letters():
15. for letter in name:
16. print(letter)
17.  
18. # Определяем основной метод для вызова других функций
19. def main():
20. has_vowel()
21. print_letters()
22.  
23. # Выполняем функцию main()
24. if __name__ == '__main__':
25. main()

Запускаем программу:

1. python more_names.py

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

Если не хотите объявлять Python функцию main(), то можете закончить программу так:

1. more_names.py
2. ...
3. if __name__ == '__main__':
4. has_vowel()
5. print_letters()

Применение main() в качестве функции в сочетании с инструкцией if __name__ == ‘__main__’: поможет организовать код в логическом порядке, сделать его модульным и удобным для чтения.

Заключение

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