Поиск по сайту:

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

Введение

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

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

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

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

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

Предпосылки

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

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

Начнем с классического «Hello, World!» программу в функцию.

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

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

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>.

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

def hello():

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

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

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

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

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

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

hello()

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

  1. python hello.py

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

Output
Hello, World!

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

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

# Define function names()
def names():
    # Set up name variable with input
    name = str(input('Enter your name: '))
    # Check whether name has a vowel
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')

    # Iterate over name
    for letter in name:
        print(letter)

# Call the function
names()

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

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

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

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

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

Давайте создадим небольшую программу, которая принимает параметры 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 . Запустим программу:

  1. python add_numbers.py



Output
3 4 5

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

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

Аргументы ключевых слов

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

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

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

# Define function with parameters
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))

# Call function with parameters assigned as above
profile_info("sammyshark", 945)

# Call function with keyword arguments
profile_info(username="AlexAnglerfish", followers=342)

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

Запустим программу:

  1. python profile.py



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

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

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

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

# Change order of parameters
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

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

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

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

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

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

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

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

result = square(3)
print(result)

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

  1. python square.py



Output
9

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

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

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

result = square(3)
print(result)

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

  1. 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:

  1. python add_numbers.py



Output
(3, 4, 5)

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

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

def loop_five():
    for x in range(0, 25):
        print(x)
        if x == 5:
            # Stop function at 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()

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

  1. python hello.py

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

Output
This is the main function.
Hello, World!

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

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

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

По этой причине принято использовать следующую конструкцию:

if __name__ == '__main__':
    # Code to run when this is the main program here

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

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

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

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

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

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

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)

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

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


# Define main method that calls other functions
def main():
    has_vowel()
    print_letters()

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

# Declare global variable name for use in all functions
name = str(input('Enter your name: '))


# Define function to check if name contains a vowel
def has_vowel():
    if set('aeiou').intersection(name.lower()):
        print('Your name contains a vowel.')
    else:
        print('Your name does not contain a vowel.')


# Iterate over letters in name string
def print_letters():
    for letter in name:
        print(letter)


# Define main method that calls other functions
def main():
    has_vowel()
    print_letters()


# Execute main() function
if __name__ == '__main__':
    main()

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

  1. python more_names.py

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

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

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

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

Заключение

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

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