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

Введение

A function is a block of instructions that performs an action and, once defined, can be reused. Functions make code more modular, allowing you to use the same code over and over again.

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

• print(), которая выводит объект в терминал
• int(), которая преобразует строку или числовой тип данных в целочисленный тип данных
• len(), которая возвращает длину объекта

Имена функций включают скобки и могут включать параметры.

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

Предварительные требования

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас нет настроенной среды программирования, вы можете обратиться к руководствам по установке и настройке для локальной среды программирования или для среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).

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

Давайте начнем с преобразования классической программы «Привет, мир!» в функцию.

Мы создадим новый текстовый файл в нашем выбранном текстовом редакторе и назовем программу hello.py. Затем мы определим функцию.

A function is defined by using the def keyword, followed by a name of your choosing, followed by a set of parentheses which hold any parameters the function will take (they can be empty), and ending with a colon.

В этом случае мы определим функцию с именем hello():

def hello():

Это устанавливает начальное утверждение для создания функции.

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

def hello():
    print("Hello, World!")

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

Итак, за пределами нашего определенного блока функций, давайте вызовем функцию с помощью hello():

def hello():
    print("Hello, World!")

hello()

Теперь давайте запустим программу:

python hello.py

Вы должны получить следующий вывод:

Output
Hello, World!

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

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

# Определение функции names()
def names():
    # Настройка переменной name с вводом
    name = str(input('Enter your name: '))
    # Проверка наличия гласной в имени
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Итерация по имени
    for letter in name:
        print(letter)

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

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

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

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

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

A parameter is a named entity in a function definition, specifying an argument that the function can accept.

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

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

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

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

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

Функция также выводит a, b и c, и исходя из вышеуказанной математики мы ожидаем, что a будет равно 3, b будет равен 4, а c будет равен 5. Давайте запустим программу:

python add_numbers.py

Output
3 4 5

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

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

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

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

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

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

# Определение функции с параметрами
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

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

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

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Вызов функции с назначенными параметрами, как указано выше
profile_info("sammyshark", 945)

# Вызов функции с именованными аргументами
profile_info(username="AlexAnglerfish", followers=342)

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

Давайте запустим программу:

python profile.py

Output
Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

Результат показывает нам имена пользователей и количество подписчиков для обоих пользователей.

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

def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Изменение порядка параметров
profile_info(followers=820, username="cameron-catfish")

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

Output
Username: cameron-catfish
Followers: 820

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

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

Мы также можем предоставить значения по умолчанию для одного или обоих параметров. Давайте создадим значение по умолчанию для параметра followers со значением 1:

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Теперь мы можем запустить функцию только с присвоенной функцией имени пользователя, и количество подписчиков автоматически установится по умолчанию равным 1. Мы также по-прежнему можем изменить количество подписчиков, если хотим.

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

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

Output
Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

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

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

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

A function can produce a value with the return statement, which will exit a function and optionally pass an expression back to the caller. If you use a return statement with no arguments, the function will return None.

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

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

def square(x):
    y = x ** 2
    return y

result = square(3)
print(result)

Мы можем запустить программу и получить вывод:

python square.py

Output
9

Целое число 9 возвращается в качестве вывода, что мы ожидали, запросив Python найти квадрат числа 3.

Чтобы лучше понять, как работает оператор return, мы можем закомментировать оператор return в программе:

def square(x):
    y = x ** 2
    # return y

result = square(3)
print(result)

Теперь давайте снова запустим программу:

python square.py

Output
None

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

Как еще один пример, в программе add_numbers.py выше мы могли бы заменить оператор print() оператором return.

def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

sums = add_numbers(1, 2, 3)
print(sums)

Вне функции мы устанавливаем переменную sums равной результату функции, принимающей 1, 2 и 3, как мы делали ранее. Затем мы вызываем печать переменной sums.

Давайте запустим программу снова, теперь когда в ней есть оператор return:

python add_numbers.py

Output
(3, 4, 5)

Мы получаем те же числа 3, 4 и 5 в качестве вывода, которые мы получили ранее, используя оператор print() в функции. На этот раз это представлено в виде кортежа, потому что список выражений оператора return имеет как минимум одну запятую.

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

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Остановить функцию при x == 5
            return
    print("This line will not execute.")

loop_five()

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

Оператор return завершает функцию и может возвращать значение при передаче параметра.

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

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

Мы начнем с добавления функции main() в программу hello.py выше. Мы оставим нашу функцию hello(), а затем определим функцию main():

def hello():
    print("Hello, World!")

def main():

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

def hello():
    print("Hello, World!")


def main():
    print("This is the main function")
    hello()

Наконец, в конце программы мы вызовем функцию main():

def hello():
    print("Hello, World!")

def main():
    print("This is the main function.")
    hello()

main()

На этом этапе мы можем запустить нашу программу:

python hello.py

Мы получим следующий вывод:

Output
This is the main function.
Hello, World!

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

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

В Python '__main__' – это имя области, в которой будет выполняться код верхнего уровня. Когда программа запускается из стандартного ввода, скрипта или интерактивной оболочки, ее __name__ устанавливается равным '__main__'.

Из-за этого существует соглашение использовать следующую конструкцию:

if __name__ == '__main__':
    # Код для выполнения, когда это основная программа здесь

Это позволяет файлам программы использоваться либо:

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

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

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

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

Вторая функция print_letters() будет выводить каждую букву строки name.

# Объявляем глобальную переменную name для использования во всех функциях
name = str(input('Enter your name: '))


# Определяем функцию для проверки наличия гласной буквы в имени
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Перебираем буквы в строке имени
def print_letters():
    for letter in name:
        print(letter)

С этим настроено, давайте определим функцию main(), которая будет содержать вызовы функций has_vowel() и print_letters().

# Объявляем глобальную переменную name для использования во всех функциях
name = str(input('Enter your name: '))


# Определяем функцию для проверки наличия гласной буквы в имени
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Перебираем буквы в строке имени
def print_letters():
    for letter in name:
        print(letter)


# Определяем главный метод, который вызывает другие функции
def main():
    has_vowel()
    print_letters()

Наконец, мы добавим конструкцию if __name__ == '__main__': в конце файла. Для наших целей, поскольку мы поместили все функции, которые мы хотели бы выполнить, в функцию main(), мы вызовем функцию main() после этого оператора if.

# Объявляем глобальную переменную name для использования во всех функциях
name = str(input('Enter your name: '))


# Определяем функцию для проверки, содержит ли имя гласную
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Перебираем буквы в строке имени
def print_letters():
    for letter in name:
        print(letter)


# Определяем главный метод, который вызывает другие функции
def main():
    has_vowel()
    print_letters()


# Выполняем функцию main()
if __name__ == '__main__':
    main()

Теперь мы можем запустить программу:

python more_names.py

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

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

...
if __name__ == '__main__':
    has_vowel()
    print_letters()

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

Заключение

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

Чтобы узнать больше о том, как сделать ваш код более модульным, вы можете прочитать наше руководство по Как писать модули в Python 3.