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

Вступление

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

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

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

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

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

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

Начнем с превращения классической программы https://www.digitalocean.com/community/tutorials/how-to-write-your-first-python-3-pro[[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

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

OutputHello, World!

Функции могут быть более сложными, чем функция + hello () +, которую мы определили выше. Например, мы можем использовать https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-python-3 [+ for + loops], https: //www.digitalocean .com / community / tutorials / how-to-write-условные операторы в python-3-2 [условные операторы] и многое другое в нашем функциональном блоке.

Например, определенная ниже функция использует условный оператор, чтобы проверить, содержит ли вход для переменной + 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 + как две отдельные функции.

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

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

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

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

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

Мы передали число + 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

Output3 4 5

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

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

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

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

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

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

profile.py

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

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

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

profile.py

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

# Call function with parameters assigned as above


# Call function with keyword arguments

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

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

python profile.py

OutputUsername: 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

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

OutputUsername: cameron-catfish
Followers: 820

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

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

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

profile.py

def profile_info(username, ):
   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 +, мы получим следующий вывод:

OutputUsername: 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

Output9

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

Чтобы понять, как работает оператор + return, мы можем закомментировать оператор` + return` в программе:

square.py

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

result = square(3)
print(result)

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

python square.py

OutputNone

Без использования оператора + 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 + равной результату функции, принимающей + 1 +, + 2 + и + 3 +, как мы делали выше. Затем мы вызвали печать переменной + sums +.

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

python add_numbers.py

Output(3, 4, 5)

Мы получаем те же числа + 3 +, + 4 + и + 5 +, что и выходные данные, которые мы получили ранее, используя оператор + print () + в функции. На этот раз он поставляется в виде tuple, поскольку оператор + return + содержит https://docs.python.org/ 3.6 / reference / expressions.html # grammar-token-expression_list [список выражений] содержит хотя бы одну запятую.

Функции завершаются немедленно, когда они нажимают оператор + 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` завершает функцию, поэтому строка, находящаяся вне цикла, не будет выполняться. Если бы вместо этого мы использовали https://www.digitalocean.com/community/tutorials/how-to-use-break-continue-and-pass-statements-when-working-with-loops-in-python- 3 # break-оператор [+ break + оператор], в это время мог бы выйти только цикл, и запустилась бы последняя строка + print () +.

Оператор + return + выходит из функции и может возвращать значение при выдаче с параметром.

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

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

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

hello.py

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

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

hello.py

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


def main():

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

hello.py

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

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

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

python hello.py

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

OutputThis is the main function.
Hello, World!

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

Далее мы будем работать с несколькими функциями, поэтому стоит рассмотреть переменную область действия https://www.digitalocean.com/community/tutorials/how-to-use-variables-in-python-3#global -и-локальные-переменные [глобальные и локальные переменные]. Если вы определите переменную в функциональном блоке, вы сможете использовать эту переменную только внутри этой функции. Если вы хотите использовать переменные в функциях, лучше объявить глобальную переменную.

В 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

Наконец, мы добавим конструкцию + 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





# Execute main() function

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

python more_names.py

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

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

more_names.py

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

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

Заключение

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

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

TOC

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

Вступление

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

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

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

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

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

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

Заключение

Related

TOC

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

Вступление

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

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

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

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

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

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

Заключение

Related

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