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

Вступление

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

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

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

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

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

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

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

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

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

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

hello.py
def hello():

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

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

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

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

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

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

hello()

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

  • python hello.py

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

Output
Hello, World!

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

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

names.py
# 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цикл как две отдельные функции.

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

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

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

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

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

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

add_numbers(1, 2, 3)

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

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

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

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

  • python add_numbers.py

Output

3 4 5

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

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

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

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

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

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

profile.py
# Define function with parameters
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

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

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

profile.py
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, во втором вызове функции мы использовали аргументы ключевого слова, присваивая значения переменным аргумента.

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

python profile.py

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

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

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

profile.py
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:

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

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

profile.py
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передачей в нее.

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

result = square(3)
print(result)

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

  • python square.py

Output

9

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

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

square.py
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утверждения.

add_numbers.py
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равной результату вхождения функции 12и, 3как мы это делали выше. Затем мы назвали печать sumsпеременной.

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

  • python add_numbers.py

Output

(3, 4, 5)

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

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

return_loop.py
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()функцию:

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

def main():

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

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


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

Наконец, в нижней части программы мы будем называть main()функцию:

hello.py
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__':
    # Code to run when this is the main program here

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

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

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

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

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

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

more_names.py
# 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()функций.

more_names.py
# 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утверждением.

more_names.py
# 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()

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

  • python more_names.py

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

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

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

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

Заключение

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

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *