Функция python: Интерактивный учебник языка Python

Интерактивный учебник языка Python

1. Функции

Напомним, что в математике факториал числа n определяется как n! = 1 ⋅ 2 ⋅ … ⋅ n. Например, 5! = 1 ⋅ 2 ⋅ 3 ⋅ 4 ⋅ 5 = 120. Ясно, что факториал можно легко посчитать, воспользовавшись циклом for. Представим, что нам нужно в нашей программе вычислять факториал разных чисел несколько раз (или в разных местах кода). Конечно, можно написать вычисление факториала один раз, а затем используя Copy-Paste вставить его везде, где это будет нужно.

	
# вычислим 3!
res = 1
for i in range(1, 4):
    res *= i
print(res)

# вычислим 5!
res = 1
for i in range(1, 6):
    res *= i
print(res)
Однако, если мы ошибёмся один раз в начальном коде, то потом эта ошибка попадёт в код во все места, куда мы скопировали вычисление факториала. Да и вообще, код занимает больше места, чем мог бы. Чтобы избежать повторного написания одной и той же логики, в языках программирования существуют функции.
Функции — это такие участки кода, которые изолированы от остальный программы и выполняются только тогда, когда вызываются.
  Вы уже встречались с функциями sqrt(), len() и print(). Они все обладают общим свойством: они могут принимать параметры (ноль, один или несколько), и они могут возвращать значение (хотя могут и не возвращать). Например, функция sqrt() принимает один параметр и возвращает значение (корень числа). Функция print() принимает переменное число параметров и ничего не возвращает.
Покажем, как написать функцию factorial(), которая принимает один параметр — число, и возвращает значение — факториал этого числа.
	
def factorial(n):
    res = 1
    for i in range(1, n + 1):
        res *= i
    return res

print(factorial(3))
print(factorial(5))
Дадим несколько объяснений. Во-первых, код функции должен размещаться в начале программы, вернее, до того места, где мы захотим воспользоваться функцией factorial(). Первая строчка этого примера является описанием нашей функции. factorial — идентификатор, то есть имя нашей функции. После идентификатора в круглых скобках идет список параметров, которые получает наша функция.
  Список состоит из перечисленных через запятую идентификаторов параметров. В нашем случае список состоит из одной величины n. В конце строки ставится двоеточие.
Далее идет тело функции, оформленное в виде блока, то есть с отступом. Внутри функции вычисляется значение факториала числа n и оно сохраняется в переменной res. Функция завершается инструкцией return res, которая завершает работу функции и возвращает значение переменной res.
Инструкция return может встречаться в произвольном месте функции, ее исполнение завершает работу функции и возвращает указанное значение в место вызова. Если функция не возвращает значения, то инструкция return используется без возвращаемого значения. В функциях, которым не нужно  возвращать значения, инструкция return может отсутствовать.
 
Приведём ещё один пример. Напишем функцию max(), которая принимает два числа и возвращает максимальное из них (на самом деле, такая функция уже встроена в Питон).
10
20
def max(a, b):
    if a > b:
        return a
    else:
        return b

print(max(3, 5))
print(max(5, 3))
print(max(int(input()), int(input())))
Теперь можно написать функцию max3(), которая принимает три числа и возвращает максимальное их них.
	
def max(a, b):
    if a > b:
        return a
    else:
        return b

def max3(a, b, c):
    return max(max(a, b), c)

print(max3(3, 5, 4))
Встроенная функция max() в Питоне может принимать переменное число аргументов и возвращать максимум из них. Приведём пример того, как такая функция может быть написана.
  
def max(*a):
    res = a[0]
    for val in a[1:]:
        if val > res:
            res = val
    return res

print(max(3, 5, 4))
Все переданные в эту функцию параметры соберутся в один кортеж с именем a, на что указывает звёздочка в строке объявления функции.
2. Локальные и глобальные переменные 
Внутри функции можно использовать переменные, объявленные вне этой функции
	
def f():
    print(a)

a = 1
f()
Здесь переменной a присваивается значение 1, и функция f() печатает это значение, несмотря на то, что до объявления функции f эта переменная 
не инициализируется. В момент вызова функции f() переменной a уже присвоено значение, поэтому функция f() может вывести его на экран.
Такие переменные (объявленные вне функции, но доступные внутри функции)
называются 
 глобальными.
Но если инициализировать какую-то переменную внутри функции,
использовать эту переменную вне функции не удастся. Например:
	
def f():
    a = 1

f()
print(a)
Получим ошибку NameError: name 'a' is not defined. Такие переменные, объявленные внутри функции,
называются локальными. Эти переменные становятся недоступными после выхода из функции.
Интересным получится результат, если попробовать изменить значение глобальной переменной внутри функции:
	
def f():
    a = 1
    print(a)

a = 0
f()
print(a)
Будут выведены числа 1 и 0. Несмотря на то, что значение переменной a изменилось внутри функции, вне функции оно осталось прежним! Это сделано в целях
“защиты” глобальных переменных от случайного изменения из функции.
  Например, если функция будет вызвана из цикла по переменной i, а в этой функции
будет использована переменная i также для организации цикла, то эти переменные должны
быть различными. Если вы не поняли последнее предложение, то посмотрите на следующий код и подумайте, как бы он работал,
если бы внутри функции изменялась переменная i.
	
def factorial(n):
    res = 1
    for i in range(1, n + 1):
        res *= i
    return res

for i in range(1, 6):
    print(i, '! = ', factorial(i), sep='')
Если бы глобальная переменная i изменялась внутри функции, то мы бы получили вот что:
5! = 1
5! = 2
5! = 6
5! = 24
5! = 120
Итак, если внутри функции модифицируется значение некоторой переменной,
то переменная с таким именем становится локальной переменной, и ее модификация не приведет
к изменению глобальной переменной с таким же именем.
Более формально: интерпретатор Питон считает переменную локальной для данной функции, если в её коде
 есть хотя бы одна инструкция, модифицирующая значение переменной, то эта переменная считается локальной
и не может быть использована до инициализации.
 
  Инструкция, модифицирующая значение переменной — это операторы =, +=, а также использование переменной в качестве параметра цикла for.
При этом даже если инструкция,
модицифицирующая переменную никогда не будет выполнена, интерпретатор это проверить
не может, и переменная все равно считается локальной. Пример:
	
def f():
    print(a)
    if False:
        a = 0

a = 1
f()
Возникает ошибка: UnboundLocalError: local variable 'a' referenced before assignment.
А именно, в функции f() идентификатор a становится локальной переменной,
т.к. в функции есть команда, модифицирующая переменную 
 a, пусть даже никогда и 
не выполняющийся (но интерпретатор не может это отследить). Поэтому вывод переменной a приводит к обращению к неинициализированной локальной переменной.
Чтобы функция могла изменить значение глобальной переменной, необходимо объявить эту переменную
внутри функции, как глобальную, при помощи ключевого слова global:
	
def f():
    global a
    a = 1
    print(a)

a = 0
f()
print(a)
В этом примере на экран будет выведено 1 1, так как переменная a объявлена, как глобальная,
и ее изменение внутри функции приводит к тому, что и вне функции переменная
будет доступна.
Тем не менее, лучше не изменять значения глобальных переменных внутри функции. Если ваша функция должна поменять
какую-то переменную, пусть лучше она вернёт это значением, и вы сами при вызове функции явно присвоите в переменную это значение.
Если следовать этим правилам, то функции получаются независимыми от кода, и их можно легко копировать из одной программы в другую.
 
Например, пусть ваша программа должна посчитать факториал вводимого числа, который вы потом захотите сохранить в переменной f.
Вот как это не стоит делать:
5
def factorial(n):
    global f
    res = 1
    for i in range(2, n + 1):
        res *= i
    f = res

n = int(input())
factorial(n)
# дальше всякие действия с переменной f
Этот код написан плохо, потому что его трудно использовать ещё один раз. Если вам завтра понадобится в другой программе использовать функцию «факториал», то вы не сможете просто скопировать эту функцию отсюда и вставить в вашу новую программу. Вам придётся поменять то, как она возвращает посчитанное значение.
 
Гораздо лучше переписать этот пример так:
5
# начало куска кода, который можно копировать из программы в программу
def factorial(n):
    res = 1
    for i in range(2, n + 1):
        res *= i
    return res
# конец куска кода

n = int(input())
f = factorial(n)
# дальше всякие действия с переменной f
Если нужно, чтобы функция вернула не одно значение, а два или более, то
для этого функция может вернуть список из двух или нескольких значений:
Тогда результат вызова функции можно будет использовать во множественном присваивании:
3. Рекурсия 
def short_story():
    print("У попа была собака, он ее любил.")
    print("Она съела кусок мяса, он ее убил,")
    print("В землю закопал и надпись написал:")
    short_story()
Как мы видели выше, функция может вызывать другую функцию. Но функция также может вызывать и саму себя! 
Рассмотрим это на примере функции вычисления факториала.
  Хорошо известно, что 0!=1, 1!=1. 
А как вычислить величину n! для большого n? Если бы мы могли вычислить величину (n-1)!,
то тогда мы легко вычислим n!, поскольку n!=n⋅(n-1)!. Но как вычислить (n-1)!? Если бы
мы вычислили (n-2)!, то мы сможем вычисли и (n-1)!=(n-1)⋅(n-2)!. А как вычислить (n-2)!? 
Если бы… В конце концов, мы дойдем до величины 0!, которая равна 1. Таким образом, для вычисления факториала
мы можем использовать значение факториала для меньшего числа. Это можно сделать и в программе на Питоне:
	
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))
Подобный прием  (вызов функцией самой себя) называется рекурсией, а сама функция называется рекурсивной.
Рекурсивные функции являются мощным механизмом в программировании. К сожалению, они не всегда эффективны. Также часто использование рекурсии приводит к ошибкам. Наиболее распространенная
из таких ошибок – бесконечная рекурсия, когда цепочка вызовов функций никогда не завершается и продолжается,
пока не кончится свободная память в компьютере. Пример бесконечной рекурсии приведен в эпиграфе к этому разделу. 
Две наиболее распространенные причины для бесконечной рекурсии:
Неправильное оформление выхода из рекурсии. Например, если мы в программе вычисления факториала
забудем поставить проверку if n == 0, то factorial(0) вызовет factorial(-1),
тот вызовет factorial(-2) и т. д.
Рекурсивный вызов с неправильными параметрами. Например, если функция factorial(n) будет
вызывать factorial(n), то также получится бесконечная цепочка.
Поэтому при разработке рекурсивной функции необходимо прежде всего оформлять условия завершения рекурсии
и думать, почему рекурсия когда-либо завершит работу.
 Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи. 
Введение в Python. Часть 8. Функции
Функция в Python — это объект, принимающий аргументы и возвращающий значение.  Со встроенными функциями вы уже сталкивались в предыдущих уроках. Например, когда  когда мы хотели узнать сумму всех чисел в списке. Можете заглянуть в выпуск про списки.
Видео: Глеб Лиманский
Тогда мы использовали встроенную функцию sum(). На вход мы передавали аргумент — список с числами, а функция возвращала нам результат — сумму этих чисел.
Если бы такой функции в Python не существовало, то мы бы могли написать что-то вроде такого кода:
И это сразу несколько строчек кода, хоть и очень простого. А с функцией мы можем заменить их на всего лишь на одно слово, что гораздо удобнее. К тому же функция устроена более универсальным образом. Какой-бы список мы ей не передали, она все равно вернет нам сумму его элементов. Не важно как будут называться этот список и будет ли у него вообще название. Главное, чтобы в списке были числа!
Подписывайтесь на рассылку «Мастерской»
Вы узнаете о крутых инструментах для сбора, анализа и визуализации данных
А в нашем коде, где мы сами считаем сумму, речь идет о конкретном списке, который называется my_list. То есть без замены названия этот код нельзя будет использовать для другого списка. Поэтому, если бы функции суммы не существовало в питоне, то нам было бы удобнее написать ее самим. Давайте оформим наш кусочек кода в функцию.
Чтобы определить функцию используется конструкция def. Дальше пишем имя функции, скобки и двоеточие. После двоеточия вы кодом прописываете, что именно должна делать функция, а дальше с помощью return функция возвращает результат. А чтобы использовать функцию нужно написать ее название и в скобка и передать ей аргумент.
Вот так почти всегда будет выглядеть функция.
Но она не всегда должна что-то принимать на вход или что-то возвращать. Вот пример функции, которая просто здоровается — распечатывает «Hi!», но не принимает аргументов и ничего не возвращает. И если напишете print(say_hi()), то в ответе вы увидите None.
Функция может ничего не принимать на вход, но что-то все же возвращать, а не просто распечатывать. Вот, например, функция, которая спрашивает у пользователя имя и возвращает его.
При этом функция может принимать и возвращать практически любые объекты и данные. Вот функция, которая принимает на вход имя человека и здоровается с ним. Но мы можем передать ей не просто имя не в виде строчки с ним, а нашу функцию get_name(). Она спросит у пользователя имя, и передаст его функции, которая с ним поздоровается.
Также для функций существует отдельный вид аргументов. Один из них — необязательный аргумент. Например, мы хотим усовершенствовать нашу функцию say_hi_to(). Теперь она должна не просто здороваться с пользователем, но и заводить с ним небольшую беседу. Поэтому добавим в функцию необязательный аргумент small_talk.
По умолчанию мы назначили small_talk = «Как дела?». Когда мы будем вызывать функцию, нам не нужно указывать этот аргумент, он уже есть по умолчанию. Нам нужно лишь передать имя, дальше функция сама спросит пользователя «Как дела?».
Отдельно указывать аргумент small_talk при вывозе функции нужно только тогда, когда мы хотим внести в него какие-то изменения. Например, мы хотим, чтобы вместо «Как дела?» функция спросила что-то другое.
Давайте посмотрим, как функции могут использоваться на практике. Напишем функцию, которая будет очищать телефонный номер от пробелов, дефисов и скобок. Допустим у нас есть датасет, где содержатся данные о владельцах телефонных номеров. И нам нужно бы привести все телефоны к одному формату. Сначала мы будем писать функцию, а потом использовать ее для датасета. 
Допустим, наши данные у нас хранятся в виде подобного словаря — phone_book = {‘Alice’: ‘8-987-657 12 11’, ‘Bob’:’89012345678′, ‘Jack’:’8 (9 1 2) 3 4 5 6 7 8 9′}. Ключами тут являются имена, а значениями — телефоны, которые написаны по-разному: с пробелами, дефисами, скобками. Нам нужно к каждому из этих номеров приметь функцию clean_tel(). 
Давайте теперь напишем функцию, которая именно это и будет делать. На вход ей нужно будет передать словарь с «грязными» номерами, а вернет она список с чистыми данными.
Такой список можно будет легко сохранить в табличку.
Анонимная функция 
В Python есть анонимные функции — лямбды. Они подчиняющиеся более строгому, но более лаконичному синтаксису, чем обычные функции Python. И работаю быстрее. Анонимные функции могут содержать лишь одно выражение. Они создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной.
Чтобы было проще, давайте сначала напишем уже известную обычную функцию, а потом перепишем ее с помощью lambda. Вот пример функции, которая просто складывает два числа.
А вот как она выглядит, если переписать ее с помощью lambda.
После инструкции lambda нужно указать аргументы, а через двоеточие, что функция должна сделать с этими аргументами.
Лямбда-функцию не обязательно как-то называть. Ее можно вызвать и без имени. Нужно поместить функцию в скобки. И рядом же в скобках указать аргументы.
Кстати, и нашу функцию say_hi() тоже можно переписать с помощью lambda.
 Это все основные принципы работы функций в Python. Если вы хотите прочитать о дополнительных возможностях функций, можете сделать это здесь. И, как всегда, тетрадка Jupyter Notebook с этого урока лежит на нашем GitHub.
Использование функций в Python—ArcGIS Pro
 Функция – это часть приложения, выполняющая определенную задачу. Функция может включаться в более крупную программу.
В ArcPy все функции геообработки представлены в виде функций, однако не все функции являются инструментами геообработки. Кроме инструментов в ArcPy имеется несколько функций для улучшения рабочих процессов геообработки с использованием Python. Функции могут использоваться для создания списков определенных наборов данных, извлечения свойств набора данных, проверки имени таблицы перед ее добавлением в базу геоданных, а также выполнения многих других полезных задач геообработки. Эти функции имеются только в ArcPy, они отсутствуют в числе инструментов ArcGIS, поскольку предназначены для алгоритмов Python.
В общем вид функции аналогичен виду инструмента, она принимает аргументы и возвращает какое-то значение. Значение, возвращаемое неинструментальными функциями, может быть различным – это может быть все что угодно, от строк до объектов геообработки. Инструментальные функции всегда возвращают объект Result и предоставляют поддержку сообщений геообработки.
В следующем примере используются две функции ArcPy: GetParameterAsText для получения входного аргумента и Exists для определения, существует ли вход. Функция Exists возвращает логический аргумент (Истина (True) или Ложь (False)).
import arcpy

input = arcpy.GetParameterAsText(0)
if arcpy.Exists(input):
    print("Data exists")
else: 
    print("Data does not exist")
В следующем примере кода с помощью функции ListFeatureClasses создается список Python классов пространственных объектов, после этого производится циклический обход списка и вырезание каждого отдельного класса пространственных объектов с помощью класса объектов границ.
import arcpy
import os

# The workspace environment needs to be set before ListFeatureClasses
#    to identify which workspace the list will be based on
#   
arcpy.env.workspace = "c:/data"
out_workspace = "c:/data/results/"
clip_features = "c:/data/testarea/boundary.shp"

# Loop through a list of feature classes in the workspace
#
for fc in arcpy.ListFeatureClasses():
    # Set the output name to be the same as the input name, and 
    #    locate in the 'out_workspace' workspace
    #
    output = os.path.join(out_workspace, fc)

    # Clip each input feature class in the list
    #
    arcpy.Clip_analysis(fc, clip_features, output, 0.1)
Связанные разделы
 Отзыв по этому разделу?
Функции в программировании. Курс «Python. Введение в программирование»
Функция в программировании представляет собой обособленный участок кода, который можно вызывать, обратившись к нему по имени, которым он был назван. При вызове происходит выполнение команд тела функции.
Функции можно сравнить с небольшими программками, которые сами по себе, то есть автономно, не исполняются, а встраиваются в обычную программу. Нередко их так и называют – подпрограммы. Других ключевых отличий функций от программ нет. Функции также при необходимости могут получать и возвращать данные. Только обычно они их получают не с ввода (клавиатуры, файла и др.), а из вызывающей программы. Сюда же они возвращают результат своей работы.
Существует множество встроенных в язык программирования функций. С некоторыми такими в Python мы уже сталкивались. Это print(), input(), int(), float(), str(), type(). Код их тела нам не виден, он где-то «спрятан внутри языка». Нам же предоставляется только интерфейс – имя функции.
С другой стороны, программист всегда может определять свои функции. Их называют пользовательскими. В данном случае под «пользователем» понимают программиста, а не того, кто пользует программу. Разберемся, зачем нам эти функции, и как их создавать.
Предположим, надо три раза подряд запрашивать на ввод пару чисел и складывать их. С этой целью можно использовать цикл:
i = 0
while i < 3:
    a = int(input())
    b = int(input())
    print(a+b)
    i += 1
Однако, что если перед каждым запросом чисел, надо выводить надпись, зачем они нужны, и каждый раз эта надпись разная. Мы не можем прервать цикл, а затем вернуться к тому же циклу обратно. Придется отказаться от него, и тогда получится длинный код, содержащий в разных местах одинаковые участки:
print("Сколько бананов и ананасов для обезьян?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт.")
 
print("Сколько жуков и червей для ежей?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт.")
 
print("Сколько рыб и моллюсков для выдр?")
a = int(input())
b = int(input())
print("Всего", a+b, "шт. ")
Пример исполнения программы:
Сколько бананов и ананасов для обезьян?
15
5
Всего 20 шт.
Сколько жуков и червей для ежей?
50
12
Всего 62 шт.
Сколько рыб и моллюсков для выдр?
16
8
Всего 24 шт.
Внедрение функций позволяет решить проблему дублирования кода в разных местах программы. Благодаря им можно исполнять один и тот же участок кода не сразу, а только тогда, когда он понадобится.
Определение функции. Оператор def
В языке программирования Python функции определяются с помощью оператора def. Рассмотрим код:
def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт.")
Это пример определения функции. Как и другие сложные инструкции вроде условного оператора и циклов функция состоит из заголовка и тела. Заголовок оканчивается двоеточием и переходом на новую строку. Тело имеет отступ.
Ключевое слово def сообщает интерпретатору, что перед ним определение функции. За def следует имя функции. Оно может быть любым, также как и всякий идентификатор, например, переменная. В программировании весьма желательно давать всему осмысленные имена. Так в данном случае функция названа «посчитатьЕду» в переводе на русский.
После имени функции ставятся скобки. В приведенном примере они пустые. Это значит, что функция не принимает никакие данные из вызывающей ее программы. Однако она могла бы их принимать, и тогда в скобках были бы указаны так называемые параметры.
После двоеточия следует тело, содержащее инструкции, которые выполняются при вызове функции. Следует различать определение функции и ее вызов. В программном коде они не рядом и не вместе. Можно определить функцию, но ни разу ее не вызвать. Нельзя вызвать функцию, которая не была определена. Определив функцию, но ни разу не вызвав ее, вы никогда не выполните ее тела.
Вызов функции
Рассмотрим полную версию программы с функцией:
def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт. ")
 
print("Сколько бананов и ананасов для обезьян?")
countFood()
 
print("Сколько жуков и червей для ежей?")
countFood()
 
print("Сколько рыб и моллюсков для выдр?")
countFood()
После вывода на экран каждого информационного сообщения осуществляется вызов функции, который выглядит просто как упоминание ее имени со скобками. Поскольку в функцию мы ничего не передаем скобки опять же пустые. В приведенном коде функция вызывается три раза.
Когда функция вызывается, поток выполнения программы переходит к ее определению и начинает исполнять ее тело. После того, как тело функции исполнено, поток выполнения возвращается в основной код в то место, где функция вызывалась. Далее исполняется следующее за вызовом выражение.
В языке Python определение функции должно предшествовать ее вызовам. Это связано с тем, что интерпретатор читает код строка за строкой и о том, что находится ниже по течению, ему еще неизвестно. Поэтому если вызов функции предшествует ее определению, то возникает ошибка (выбрасывается исключение NameError):
print("Сколько бананов и ананасов для обезьян?")
countFood()
 
print("Сколько жуков и червей для ежей?")
countFood()
 
print("Сколько рыб и моллюсков для выдр?")
countFood()
 
def countFood():
    a = int(input())
    b = int(input())
    print("Всего", a+b, "шт. ")
Результат:
Сколько бананов и ананасов для обезьян?
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    countFood()
NameError: name 'countFood' is not defined
Для многих компилируемых языков это не обязательное условие. Там можно определять и вызывать функцию в произвольных местах программы. Однако для удобочитаемости кода программисты даже в этом случае предпочитают соблюдать определенные правила.
Функции придают программе структуру
Польза функций не только в возможности многократного вызова одного и того же кода из разных мест программы. Не менее важно, что благодаря им программа обретает истинную структуру. Функции как бы разделяют ее на обособленные части, каждая из которых выполняет свою конкретную задачу.
Пусть надо написать программу, вычисляющую площади разных фигур. Пользователь указывает, площадь какой фигуры он хочет вычислить. После этого вводит исходные данные. Например, длину и ширину в случае прямоугольника. Чтобы разделить поток выполнения на несколько ветвей, следует использовать оператор if-elif-else:
figure = input("1-прямоугольник, 
2-треугольник, 3-круг: ")
 
if figure == '1':
  a = float(input("Ширина: "))
  b = float(input("Высота: "))
  print("Площадь: %.2f" % (a*b))
elif figure == '2':
  a = float(input("Основание: "))
  h = float(input("Высота: "))
  print("Площадь: %.2f" % (0.5 * a * h))
elif figure == '3':
  r = float(input("Радиус: "))
  print("Площадь: %.2f" % (3.14 * r**2))
else:
  print("Ошибка ввода")
Здесь нет никаких функций, и все прекрасно. Но напишем вариант с функциями:
def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    print("Площадь: %.2f" % (a*b))
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    print("Площадь: %.2f" % (0.5 * a * h))
 
def circle():
    r = float(input("Радиус: "))
    print("Площадь: %.2f" % (3.14 * r**2))
 
figure = input("1-прямоугольник, 
2-треугольник, 3-круг: ")
if figure == '1':
  rectangle()
elif figure == '2':
  triangle()
elif figure == '3':
  circle()
else:
  print("Ошибка ввода")
Он кажется сложнее, а каждая из трех функций вызывается всего один раз. Однако из общей логики программы как бы убраны и обособлены инструкции для нахождения площадей. Программа теперь состоит из отдельных «кирпичиков Лего». В основной ветке мы можем комбинировать их как угодно. Она играет роль управляющего механизма.
Если нам когда-нибудь захочется вычислять площадь треугольника по формуле Герона, а не через высоту, то не придется искать код во всей программе (представьте, что она состоит из тысяч строк кода как реальные программы). Мы пойдем к месту определения функций и изменим тело одной из них.
Если понадобиться использовать эти функции в какой-нибудь другой программе, то мы сможем импортировать их туда, сославшись на данный файл с кодом (как это делается в Python, будет рассмотрено позже).
Практическая работа
В программировании можно из одной функции вызывать другую. Для иллюстрации этой возможности напишите программу по следующему описанию.
Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции test(). В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция positive(), тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция negative(), ее тело содержит выражение вывода на экран слова «Отрицательное».
Понятно, что вызов test() должен следовать после определения функций. Однако имеет ли значение порядок определения самих функций? То есть должны ли определения positive() и negative() предшествовать test() или могут следовать после него? Проверьте вашу гипотезу, поменяв объявления функций местами. Попробуйте объяснить результат.
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
Pythonicway — Функции в Python
Функция это блок организованного, многократно используемоего кода, который используется для выполнения конкретного задания. Функции обеспечивают лучшую модульность приложения и значительно повышают уровень повторного использования кода.
Создание функции
Существуют некоторые правила для создания функций в Python.
Блок функции начинается с ключевого слова def, после которого следуют название функции и круглые скобки ( () ).
Любые аргументы, которые принимает функция должны находиться внутри этих скобок.
После скобок идет двоеточие ( : ) и с новой строки с отступом начинается тело функции.
Пример функции в Python:
def my_function(argument):
    print argument
 Вызов функции
После создания функции, ее можно исполнять вызывая из другой функции или напрямую из оболочки Python. Для вызова функции следует ввести ее имя и добавить скобки.
Например:
my_function("abracadabra")
Аргументы функции в Python
Вызывая функцию, мы можем передавать ей следующие типы аргументов:
Обязательные аргументы (Required arguments)
Аргументы-ключевые слова (Keyword argument)
Аргументы по умолчанию (Default argument)
Аргументы произвольной длины (Variable-length argumens)
Обязательные аргументы функции:
Если при создании функции мы указали количество передаваемых ей аргументов и их порядок, то и вызывать ее мы должны с тем же количеством аргументов, заданных в нужном порядке.
Например:
def bigger(a,b):
    if a > b:
        print a
    else:
       print b

# В описании функции указано, что она принимает 2 аргумента

# Корректное использование функции
bigger(5,6)

# Некорректное использование функции
bigger()
bigger(3)
bigger(12,7,3) 
Аргументы — ключевые слова
Аргументы — ключевые слова используются при вызове функции. Благодаря ключевым аргументам, вы можете задавать произвольный (то есть не такой каким он описа при создании функции) порядок аргументов.
Например:
def person(name, age):
    print name, "is", age, "years old"

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

person(age=23, name="John")
Аргументы, заданные по-умолчанию
Аргумент по умолчанию, это аргумент, значение для которого задано изначально, при создании функции.
Например:
def space(planet_name, center="Star"):
    print planet_name, "is orbiting a", center

# Можно вызвать функцию space так:
space("Mars")
# В результате получим: Mars is orbiting a Star

# Можно вызвать функцию space иначе:
space("Mars", "Black Hole")
# В результате получим: Mars is orbiting a Black Hole
Аргументы произвольной длины
Иногда возникает ситуация, когда вы заранее не знаете, какое количество аргументов будет необходимо принять функции. В этом случае следует использовать аргументы произвольной длины. Они задаются произвольным именем переменной, перед которой ставится звездочка (*).
Например:
def unknown(*args):
    for argument in args:
        print argument

unknown("hello","world") # напечатает оба слова, каждое с новой строки
unknown(1,2,3,4,5) # напечатает все числа, каждое с новой строки
unknown() # ничего не выведет
Ключевое слово 
return 
Выражение return прекращает выполнение функции и возвращает указанное после выражения значение. Выражение return без аргументов это то же самое, что и выражение return None. Соответственно, теперь становится возможным, например, присваивать результат выполнения функции какой либо переменной.
Например:
def bigger(a,b):
    if a > b:
        return a # Если a больше чем b, то возвращаем a и прекращаем выполнение функции
    return b # Незачем использовать else.  Если мы дошли до этой строки, то b, точно не меньше чем a

# присваиваем результат функции bigger переменной num
num = bigger(23,42)
Некоторые переменные скрипта могут быть недоступны некоторым областям программы. Все зависит от того, где вы объявили эти переменные.
В Python две базовых области видимости переменных:
Глобальные переменные
Локальные переменные
Переменные объявленные внутри тела функции имеют локальную область видимости, те что объявлены вне какой-либо функции имеют глобальную область видимости.
Это означает, что доступ к локальным переменным имеют только те функции, в которых они были объявлены, в то время как доступ к глобальным переменным можно получить по всей программе в любой функции.
Например:
# глобальная переменная age
age = 44

def info():
    print age # Печатаем глобальную переменную age

def local_info():
    age = 22 # создаем локальную переменную age 
    print age

info() # напечатает 44
local_info() # напечатает 22
Важно помнить, что для того чтобы получить доступ к глобальной переменной, достаточно лишь указать ее имя. Однако, если перед нами стоит задача изменить глобальную переменную внутри функции — необходимо использовать ключевое слово global.
Например:
# глобальная переменная age
age = 13

# функция изменяющая глобальную переменную
def get_older():
    global age
    age += 1

print age # напечатает 13
get_older() # увеличиваем age на 1
print age # напечатает 14
Рекурсия
Рекурсией в программировании называется ситуация, в которой функция вызывает саму себя. Классическим примером рекурсии может послужить функция вычисления факториала числа.
Напомним, что факториалом числа, например, 5 является произведение всех натуральных (целых) чисел от 1 до 5. То есть, 1 * 2 * 3 * 4 * 5
Рекурсивная функция вычисления факториала на языке Python будет выглядеть так:
def fact(num):
    if num == 0: 
        return 1 # По договоренности факториал нуля равен единице
    else:
        return num * fact(num - 1) # возвращаем результат произведения num и результата возвращенного функцией fact(num - 1)
Однако следует помнить, что использование рекурсии часто может быть неоправданным. Дело в том, что в момент вызова функции в оперативной памяти компьютера резервируется определенное количество памяти, соответственно чем больше функций одновременно мы запускаем — тем больше памяти потребуется, что может привести к переполнению стека (stack overflow) и программа завершится аварийно, не так как предполагалось. Учитывая это, там где это возможно, вместо рекурсии лучше применять циклы.
Рецепт создания функции в Python
Существует следующий алгоритм — рекомендация по созданию функции в Python. Например, мы создаем функцию вычисления площади прямоугольника.
Начинать следует с примеров того, что делает функция, и подобрать подходящее название. В нашем случае это будет выглядеть так:
# На данном этапе мы еще не указываем имена переменных
def rectangle_area_finder( ):
    """
    >>> rectangle_area_finder(3, 5)
    15
    >>> rectangle_area_finder(17.2, 6)
    103.2
    """

Указать типы данных, которые принимает функция и тип данных, который она возвращает
# функция принимает два числа, а возвращает одно
def rectangle_area_finder( ):
    """
    (num, num) -> num    

    >>> rectangle_area_finder(3, 5)
    15
    >>> rectangle_area_finder(17. 2, 6)
    103.2
    """

Подобрать подходящие названия для переменных
# Поскольку это математическая функция нам вполне подойдут имена a и b
def rectangle_area_finder(a, b):
    """
    (num, num) -> num
    
    >>> rectangle_area_finder(3, 5)
    15
    >>> rectangle_area_finder(17.2, 6)
    103.2
    """

Написать краткое, но содержательное описание функции
def rectangle_area_finder(a, b):
    """
    (num, num) -> num

    Returns an area of a rectangle with given sides a and b.    

    >>> rectangle_area_finder(3, 5)
    15
    >>> rectangle_area_finder(17.2, 6)
    103.2
    """

Написать собственно тело функции
def rectangle_area_finder(a, b):
    """
    (num, num) -> num

    Returns an area of a rectangle with given sides a and b.     

    >>> rectangle_area_finder(3, 5)
    15
    >>> rectangle_area_finder(17.2, 6)
    103.2
    """
    return a * b

Функция готова! Осталось вызвать ее с указанными в примерах аргументами
Как видно, при вызове команды help() с именем нашей функции в качестве аргумента мы получаем написанную нами документацию.
Сопровождайте ваши функции качественной документацией и программисты, которые будут работать с вашим кодом после вас будут вам благодарны.
Python. Урок 10. Функции в Python
Урок посвящен созданию функций в Python и работе с ними (передача аргументов, возврат значения и т.п.). Также рассмотрены lambda-функций, их особенности и использование.
По своей сути функции в Python практически ничем не отличаются от функций из других языков программирования. Функцией называют именованный фрагмент программного кода, к которому можно обратиться из другого места вашей программы (но есть lambda-функции, у которых нет имени, о них будет рассказано в конце урока). Как правило, функции создаются для работы с данными, которые передаются ей в качестве аргументов, также функция может формировать некоторое возвращаемое значение. 
Для создания функции используется ключевое слово def, после которого указывается имя и список аргументов в круглых скобках. Тело функции выделяется также как тело условия (или цикла): четырьмя пробелами. Таким образом самая простая функция, которая ничего не делает, будет выглядеть так.
def fun():
    pass
Возврат значения функцией осуществляется с помощью ключевого слова return, после которого указывается возвращаемое значение. Пример функции возвращающей единицу представлен ниже.
>>> def fun():
    return 1
>>> fun()
1
Во многих случаях функции используют для обработки данных. Эти данные могут быть глобальными, либо передаваться в функцию через аргументы. Список аргументов определяется на этапе реализации и указывается в круглых скобках после имени функции.  Например операцию сложения двух аргументов можно реализовать вот так.
>>> def summa(a, b):
    return a + b
>>> summa(3, 4)
7
Рассмотрим еще два примера использования функции: вычисление числа Фибоначчи с использованием рекурсии и вычисление факториала с использованием цикла.
Вычисление числа Фибоначчи.
>>> def fibb(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fibb(n-1) + fibb(n-2)
>>> print(fibb(10))
55
Вычисление факториала.
>>> def factorial(n):
    prod = 1
    for i in range(1, n+1):
        prod *= i
    return prod

>>> print(factorial(5))
120
Функцию можно присвоить переменной и использовать ее, если необходимо сократить имя. В качестве примера можно привести вариант использования функции вычисления факториала из пакета math.
>>> import math
>>> f = math.factorial
>>> print(f(5))
120
Lambda-функция – это безымянная функция с произвольным числом аргументов и вычисляющая одно выражение. Тело такой функции не может содержать более одной инструкции (или выражения). Данную функцию можно использовать в рамках каких-либо конвейерных вычислений (например внутри filter(), map() и reduce()) либо самостоятельно, в тех местах, где требуется произвести какие вычисление, которые удобно “завернуть” в функцию.
 >>> (lambda x: x**2)(5)
25
Lambda-функцию можно присвоить какой-либо переменной и в дальнейшем использовать ее в качестве имени функции.
>>> sqrt = lambda x: x**0.5
>>> sqrt(25)
5.0
Списки можно обрабатывать lambda-функциями внутри таких функций как map(), filter(), reduce(), о них мы ещё поговорим, а пока рассмотрим пример с map().  Функция map принимает два аргумента, первый – это функция, которая будет применена к каждому элементу списка, а второй – это список, который нужно обработать.
>>> l = [1, 2, 3, 4, 5, 6, 7]
>>> list(map(lambda x: x**3, l))
[1, 8, 27, 64, 125, 216, 343]
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
<<< Python. Урок 9. Словари (dict)   Python. Урок 11. Работа с исключениями>>>
Функции в Python | Кодкамп
Введение
Примеры
Определение и вызов простых функций
Использование def утверждения является наиболее распространенным способом определить функцию в Python. Это утверждение так называемое соединение заявление одного пункта со следующим синтаксисом:
def function_name(parameters):
    statement(s)

 
function_name известна как идентификатор функции. Так как определение функции является исполняемым утверждение его исполнение связывает имя функции к функции объекта , который может быть назван позже с использованием идентификатора.
parameters необязательного список идентификаторов , которые получают привязанные к значениям в качестве аргументов при вызове функции. Функция может иметь произвольное количество аргументов, разделенных запятыми.
statement(s) — также известное как тело функции — это непустое последовательность операторов , выполняемых при каждом вызове функции. Это означает , что тело функции не может быть пустым, так же как и любой отступом блок .
Вот пример простого определения функции, целью которой является для печати Hello каждый раз , когда это называется:
def greet():
    print("Hello")

 
Теперь давайте называть определенные greet() функции:
greet()
# Out: Hello

 
Это еще один пример определения функции, которая принимает один единственный аргумент и отображает переданное значение каждый раз, когда вызывается функция:
def greet_two(greeting):
    print(greeting)

 
После того, что greet_two() функция должна быть вызвана с аргументом:
greet_two("Howdy")
# Out: Howdy

 
Также вы можете задать значение по умолчанию для этого аргумента функции:
 def greet_two(greeting="Howdy"):
    print(greeting)
 
Теперь вы можете вызывать функцию без указания значения:
 greet_two()
# Out: Howdy 

 
Вы заметите, что в отличие от многих других языков, вам не нужно явно объявлять тип возвращаемого значения функции. Функции Python могут возвращать значения любого типа с помощью return ключевого слова. Одна функция может возвращать любое количество разных типов!
def many_types(x):
    if x < 0:
        return "Hello!"
    else:
        return 0

print(many_types(1))
print(many_types(-1))

# Output:
0
Hello!

 
Пока это правильно обрабатывается вызывающей стороной, это совершенно правильный код Python.
Функция , которая достигает конца исполнения без оператора возврата всегда будет возвращать None :
def do_nothing():
    pass

print(do_nothing())
# Out: None

 
Как упоминалось ранее, определение функции должно иметь тело функции, непустую последовательность операторов. Поэтому pass используется оператор в теле функции, которая является нулевой операции — когда он выполняется, ничего не происходит. Он делает то, что значит, он пропускает. Это полезно в качестве заполнителя, когда синтаксически требуется оператор, но не нужно выполнять код.
Возвращение значений из функций
Функции могут return значение , которое можно использовать непосредственно:
def give_me_five():
    return 5

print(give_me_five())  # Print the returned value
# Out: 5

 
или сохраните значение для последующего использования:
num = give_me_five()
print(num)             # Print the saved returned value
# Out: 5

 
или используйте значение для любых операций:
print(give_me_five() + 10)
# Out: 15

 
Если return встречается в функции функция будет немедленно вышла и последующие операции не будут оцениваться:
def give_me_another_five():
    return 5
    print('This statement will not be printed. Ever.')

print(give_me_another_five())
# Out: 5

 
Вы также можете return несколько значений (в виде кортежа):
def give_me_two_fives():
    return 5, 5  # Returns two 5

first, second = give_me_two_fives()
print(first)
# Out: 5
print(second)
# Out: 5

 
Функция, без return заявления неявно возвращает None . Точно так же функция с return утверждением, но не возвращает значение или переменная возвращает None .
Определение функции с аргументами
Аргументы определены в скобках после имени функции:
 def divide(dividend, divisor):  # The names of the function and its arguments
    # The arguments are available by name in the body of the function
    print(dividend / divisor)

 
Имя функции и список ее аргументов называются сигнатура функции. Каждый именованный аргумент фактически является локальной переменной функции.
При вызове функции укажите значения аргументов, перечислив их в порядке
divide(10, 2)
# output: 5

 
или укажите их в любом порядке, используя имена из определения функции:
divide(divisor=2, dividend=10)
# output: 5 
Определение функции с необязательными аргументами
Дополнительные аргументы могут быть определены путем назначения ( с использованием = ) значение по умолчанию имя-аргумента:
def make(action='nothing'):
    return action

 
Вызов этой функции возможен тремя различными способами:
make("fun")
# Out: fun

make(action="sleep")
# Out: sleep

# The argument is optional so the function will use the default value if the argument is 
# not passed in. 
make()   
# Out: nothing

 
Изменяемые типы ( list , dict , set и т.д.) , следует относиться с осторожностью , когда дается как атрибут по умолчанию. Любая мутация аргумента по умолчанию изменит его навсегда. См Определение функции с дополнительными изменяемыми аргументами .
Определение функции с несколькими аргументами
Можно дать функции столько аргументов, сколько нужно, единственные фиксированные правила — это то, что каждое имя аргумента должно быть уникальным и что необязательные аргументы должны быть после не необязательных:
def func(value1, value2, optionalvalue=10):
    return '{0} {1} {2}'.format(value1, value2, optionalvalue1)

 
При вызове функции вы можете указать каждое ключевое слово без имени, но тогда порядок имеет значение:
print(func(1, 'a', 100))
# Out: 1 a 100

print(func('abc', 14))
# abc 14 10

 
Или совмещать указание аргументов с именем и без. Тогда те, у кого есть имя, должны следовать за теми, у кого нет, но порядок тех, у кого есть имя, не имеет значения:
 print(func('This', optionalvalue='StackOverflow Documentation', value2='is'))
# Out: This is StackOverflow Documentation 
Определение функции с произвольным числом аргументов
Определение функции , способную принимать произвольное количество аргументов может быть сделано с помощью префиксов один из аргументов с *
def func(*args):
    # args will be a tuple containing all values that are passed in
    for i in args:
        print(i)

func(1, 2, 3)  # Calling it with 3 arguments
# Out: 1
#      2
#      3

list_of_arg_values = [1, 2, 3]
func(*list_of_arg_values)  # Calling it with list of values, * expands the list
# Out: 1
#      2
#      3 

func()  # Calling it without arguments
# No Output 

 
Вы не можете предоставить по умолчанию для args , например func(*args=[1, 2, 3]) поднимет синтаксическую ошибку (даже не компилировать).
Вы не можете обеспечить их по имени при вызове функции, например func(*args=[1, 2, 3]) поднимет TypeError .
Но если у вас уже есть свои аргументы в массиве (или любой другой Iterable ), вы можете вызвать вашу функцию следующим образом: func(*my_stuff) .
Эти аргументы ( *args ) можно обращаться по индексу, например , args[0] возвращает первый аргумент
Вы можете принимать произвольное число аргументов с именем, определяя аргумент в определении с двумя * перед ним:
def func(**kwargs):
    # kwargs will be a dictionary containing the names as keys and the values as values
    for name, value in kwargs.items():
        print(name, value)

func(value1=1, value2=2, value3=3)   # Calling it with 3 arguments
# Out: value1 1
#      value2 2
#      value3 3

func()                               # Calling it without arguments
# No Out put

my_dict = {'foo': 1, 'bar': 2}
func(**my_dict)                      # Calling it with a dictionary
# Out: foo 1
#      bar 2

 
Вы не можете предоставить это без имен, например func(1, 2, 3) поднимет TypeError .
kwargs это простой родной словарь питона. Например, args['value1'] даст значение аргумента value1 . Обязательно проверьте заранее , что есть такой аргумент или KeyError будет поднят.
Вы можете смешивать их с другими необязательными и обязательными аргументами, но порядок внутри определения имеет значение.
Позиционные / ключевые аргументы приходят в первую очередь. (Обязательные аргументы).   Тогда приходит произвольные *arg аргументы. (Необязательный).   Тогда ключевые слова только аргументы приходят дальше. (Необходимые).   Наконец произвольные ключевое слово **kwargs приходят. (Необязательный).
 #       |-positional-|-optional-|---keyword-only--|-optional-|
def func(arg1, arg2=10 , *args, kwarg1, kwarg2=2, **kwargs):
     pass

 
arg1 должен быть задан, в противном случае TypeError поднимается. Это может быть задано как позиционный ( func(10) ) или ключевым словом аргумента ( func(arg1=10) ).
kwarg1 также должен быть предоставлен, но она может быть обеспечена только в качестве ключевого слова-аргумента: func(kwarg1=10) .
arg2 и kwarg2 не являются обязательными. Если значение должно быть изменено тем же правилам , как и для arg1 (либо позиционной или ключевое слово) и kwarg1 (только ключевое слово) применяются.
*args уловы дополнительные позиционные параметры. Но обратите внимание, что arg1 и arg2 должны быть предоставлены в качестве позиционных аргументов передать аргументы *args : func(1, 1, 1, 1) .
**kwargs перехватывает все дополнительные параметры ключевых слов. В этом случае любой параметр , который не arg1 , arg2 , kwarg1 или kwarg2 . Например: func(kwarg3=10) .
В Python 3, вы можете использовать * в покое , чтобы указать , что все последующие аргументы должны быть указаны в качестве ключевых слов. Для экземпляра math.isclose функции в Python 3.5 и выше , определяется с использованием def math.isclose (a, b, *, rel_tol=1e-09, abs_tol=0.0) , что означает , что первые два аргумента могут быть поставлены позиционно , но по желанию третий и четвертый параметры могут быть предоставлены только как ключевые аргументы.
Python 2.x не поддерживает параметры только для ключевых слов. Такое поведение можно эмулировать с kwargs :
def func(arg1, arg2=10, **kwargs):
    try:
        kwarg1 = kwargs.pop("kwarg1")
    except KeyError:
        raise TypeError("missing required keyword-only argument: 'kwarg1'")

    kwarg2 = kwargs.pop("kwarg2", 2)
    # function body ...

 
Примечание по именованию
Условность наименования необязательных позиционных аргументов args и необязательных аргументы ключевых слов kwargs просто условность вы можете использовать любые имена вам нравится , но это полезно следовать соглашению , чтобы другие знали , что вы делаете, или даже сам потом так пожалуйста.
Обратите внимание на уникальность
Любая функция может быть определена ни с одной или *args и ни один или один **kwargs , но не с более чем одним из каждых. Также *args должен быть последним аргументом позиционного и **kwargs должен быть последним параметром. Попытка использовать более одного либо приведет к исключению ошибок синтаксиса.
Замечание о функциях вложения с необязательными аргументами
Можно гнездовые такие функции и обычная условность, чтобы удалить элементы , что код уже обрабатываемые , но если вы передаете вниз параметры , которые нужно передать дополнительные позиционные аргументы с * префиксом и необязательной ключевыми словами арг с ** приставкой , иначе аргументы будут передаваться как список или кортеж, а kwargs — как один словарь. например:
def fn(**kwargs):
    print(kwargs)
    f1(**kwargs)

def f1(**kwargs):
    print(len(kwargs))

fn(a=1, b=2)
# Out:
# {'a': 1, 'b': 2}
# 2 
Определение функции с необязательными изменяемыми аргументами
Существует проблема при использовании дополнительных аргументов с изменяемым типом умолчанию ( как описано в Определение функции с необязательными аргументами ), что потенциально может привести к непредсказуемому поведению.
объяснение
Эта проблема возникает из — за аргументов функции по умолчанию инициализируются один раз, в тот момент , когда функция определена, а не (как и многие другие языки) , когда функция вызывается. Значения по умолчанию сохраняется в функции объект __defaults__ переменного члена.
def f(a, b=42, c=[]):
    pass

print(f.__defaults__)
# Out: (42, [])

 
Для неизменяемых типов (см передачи аргументов и переменчивости ) это не проблема , потому что нет никакого способа , чтобы мутировать переменные; это может только быть переназначено, оставляя оригинальное значение неизменным. Следовательно, последующие гарантированно будут иметь одинаковое значение по умолчанию. Однако, для изменяемого типа, исходное значение может мутировать, делая звонки на его различные функции — членов. Следовательно, последовательные вызовы функции не гарантируют начальное значение по умолчанию.
def append(elem, to=[]):
    to.append(elem)      # This call to append() mutates the default variable "to"
    return to

append(1)
# Out: [1]

append(2)  # Appends it to the internally stored list
# Out: [1, 2]

append(3, [])  # Using a new created list gives the expected result
# Out: [3]

# Calling it again without argument will append to the internally stored list again
append(4)   
# Out: [1, 2, 4]

 
Примечание: Некоторые Иды как PyCharm будет выдавать предупреждение , когда изменяемый тип задан как атрибут по умолчанию.
Решение
Если вы хотите , чтобы убедиться , что аргумент по умолчанию всегда один указывается в определении функции, то решение всегда использовать неизменный тип как ваш аргумент по умолчанию.
Общая идиома , чтобы достичь этого , когда изменяемый типа необходим по умолчанию, является не использовать None (неизменный) в качестве аргумента по умолчанию , а затем присвоить фактическое значение по умолчанию для переменного аргумента , если оно равно None .
def append(elem, to=None):
    if to is None:
        to = []

    to.append(elem)
    return to

 
Лямбда (встроенные / анонимные) функции
lambda ключевое слово создает функцию инлайн, содержащую одно выражение. Значение этого выражения — это то, что функция возвращает при вызове.
Рассмотрим функцию:
def greeting():
    return "Hello"

 
который, когда называется как:
print(greeting())

 
печатает:
Hello


 
Это можно записать в виде лямбда-функции следующим образом:
greet_me = lambda: "Hello"

 
Это создает встраиваемую функцию с именем greet_me , который возвращает Hello . Обратите внимание , что вы не пишете return при создании функции с лямбда. Значение после : автоматически возвращается.
После присвоения переменной она может использоваться как обычная функция:
print(greet_me())

 
печатает:
Hello

 
lambda — s может принимать аргументы, тоже:
strip_and_upper_case = lambda s: s. strip().upper()

strip_and_upper_case("  Hello   ")

 
возвращает строку:
HELLO

 
Они также могут принимать произвольное количество аргументов / ключевых слов, как обычные функции.
greeting = lambda x, *args, **kwargs: print(x, args, kwargs)
greeting('hello', 'world', world='world')

 
печатает:
hello ('world',) {'world': 'world'}

 
lambda — ы обычно используются для коротких функций, которые удобно определить в точке , где они называются ( как правило , с sorted , filter и map ).
Например, эта строка сортирует список строк, игнорируя их регистр и игнорируя пробелы в начале и в конце:
sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip().upper())
# Out:
# ['    bAR', 'BaZ    ', ' foo ']

 
Список сортировки просто игнорируя пробелы:
sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s. strip())
# Out:
# ['BaZ    ', '    bAR', ' foo ']

 
Примеры с map :
sorted( map( lambda s: s.strip().upper(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BAR', 'BAZ', 'FOO']

sorted( map( lambda s: s.strip(), [" foo ", "    bAR", "BaZ    "]))
# Out:
# ['BaZ', 'bAR', 'foo']


 
Примеры с числовыми списками:
my_list = [3, -4, -2, 5, 1, 7]
sorted( my_list, key=lambda x: abs(x))
# Out:
# [1, -2, 3, -4, 5, 7]

list( filter( lambda x: x>0, my_list))
# Out:
# [3, 5, 1, 7]

list( map( lambda x: abs(x), my_list))
# Out:
[3, 4, 2, 5, 1, 7]
 
Другие функции (с / без аргументов) можно вызывать внутри лямбда-функции.
def foo(msg):
    print(msg)

greet = lambda x = "hello world": foo(x)
greet()

 
печатает:
hello world

 
Это полезно , потому что lambda может содержать только одно выражение и с помощью дочерней функции можно запустить несколько операторов.
НОТА
Следует иметь в виду , что PEP-8 (официальный гид по стилю Python) не рекомендуется назначать лямбды переменным (как мы это делали в первых двух примерах):
Передача аргумента и изменчивость
Сначала немного терминологии:
аргумент (фактический параметр): фактическая переменная передается в функцию;
Параметр (формальный параметр): принимающая переменная, которая используется в функции.
В Python, аргументы передаются по заданию (в отличие от других языков, где аргументы могут передаваться по значению / задания / указателя).
Мутирование параметра приведет к изменению аргумента (если тип аргумента является изменяемым).
def foo(x):        # here x is the parameter
    x[0] = 9       # This mutates the list labelled by both x and y
    print(x)

y = [4, 5, 6]
foo(y)             # call foo with y as argument
# Out: [9, 5, 6]   # list labelled by x has been mutated
print(y)           
# Out: [9, 5, 6]   # list labelled by y has been mutated too 
Переназначение параметра не переназначит аргумент.
def foo(x):        # here x is the parameter, when we call foo(y) we assign y to x
    x[0] = 9       # This mutates the list labelled by both x and y
    x = [1, 2, 3]  # x is now labeling a different list (y is unaffected)
    x[2] = 8       # This mutates x's list, not y's list

y = [4, 5, 6]      # y is the argument, x is the parameter
foo(y)             # Pretend that we wrote "x = y", then go to line 1
y
# Out: [9, 5, 6] 
В Python, мы на самом деле не присваивать значения переменным, вместо того, чтобы мы связываем (то есть переуступать, присоединять) переменные (рассматриваемые как имена) к объектам.
Неизменные: Целые, строки, кортежи, и так далее. Все операции делают копии.
Mutable: списки, словари, наборы, и так далее. Операции могут или не могут мутировать.
x = [3, 1, 9]
y = x
x.append(5)    # Mutates the list labelled by x and y, both x and y are bound to [3, 1, 9]
x. sort()       # Mutates the list labelled by x and y (in-place sorting)
x = x + [4]    # Does not mutate the list (makes a copy for x only, not y)
z = x          # z is x ([1, 3, 9, 4])
x += [6]       # Mutates the list labelled by both x and z (uses the extend function).
x = sorted(x)  # Does not mutate the list (makes a copy for x only).
x
# Out: [1, 3, 4, 5, 6, 9]
y
# Out: [1, 3, 5, 9]
z
# Out: [1, 3, 5, 9, 4, 6] 
Return
Замыкания в Python создаются вызовами функций. Здесь вызов makeInc создает привязку для x , ссылка внутри функции inc . Каждый вызов makeInc создает новый экземпляр этой функции, но каждый экземпляр имеет ссылку на другую связыванию x .
 def makeInc(x):
  def inc(y):
     # x is "attached" in the definition of inc
     return y + x

  return inc

incOne = makeInc(1)
incFive = makeInc(5)

incOne(5) # returns 6
incFive(5) # returns 10

 
Обратите внимание, что в то время как при обычном замыкании вложенная функция полностью наследует все переменные из окружающей ее среды, в этой конструкции вложенная функция имеет доступ только на чтение к унаследованным переменным, но не может назначать их
 def makeInc(x):
  def inc(y):
     # incrementing x is not allowed
     x += y  
     return x

  return inc

incOne = makeInc(1)
incOne(5) # UnboundLocalError: local variable 'x' referenced before assignment

 
Python 3 предлагает nonlocal заявление ( https://codecamp. ru/documentation/python/263/variable-scope-and-binding/5712/nonlocal-variables#t=201608272008282346874 ) для реализации полного закрытия с вложенными функциями.
def makeInc (x): def inc (y): нелокальный x # теперь можно присвоить значение x x + = y вернуть x return inc incOne = makeInc (1) incOne (5) # возвращает 6
Рекурсивные функции
Рекурсивная функция — это функция, которая вызывает себя в своем определении. Например, математическая функция, факториала, определяется factorial(n) = n*(n-1)*(n-2)*...*3*2*1 . может быть запрограммирован как
def factorial(n):
    #n here should be an integer
    if n == 0:
        return 1
    else:
        return n*factorial(n-1)
 
выходы здесь:
factorial(0)
#out 1
factorial(1)
#out 1
factorial(2)
#out 2
factorial(3)
#out 6

 
как и ожидалось. Обратите внимание , что эта функция является рекурсивной , потому что второй return factorial(n-1) , где функция называет себя в своем определении.
Некоторые рекурсивные функции могут быть реализованы с помощью лямбда , факториала с помощью лямбда — бы что — то вроде этого:
factorial = lambda n: 1 if n == 0 else n*factorial(n-1)

 
Функция выводит то же, что и выше.
Предел рекурсии
Существует предел глубины возможной рекурсии, который зависит от реализации Python. Когда предел достигнут, возникает исключение RuntimeError:
def cursing(depth):
  try:
    cursing(depth + 1) # actually, re-cursing
  except RuntimeError as RE:
    print('I recursed {} times!'.format(depth))

cursing(0)
# Out: I recursed 1083 times! 
Можно изменить рекурсии предел глубины, используя sys.setrecursionlimit(limit) и проверить этот предел sys.getrecursionlimit() .
sys.setrecursionlimit(2000)
cursing(0)
# Out: I recursed 1997 times! 
Из Python 3.5, исключение составляет RecursionError , который является производным от RuntimeError .
Вложенные функции
Функции в Python являются первоклассными объектами. Они могут быть определены в любой области
 def fibonacci(n):
    def step(a,b):
        return b, a+b
    a, b = 0, 1
    for i in range(n):
        a, b = step(a, b)
    return a

 
Функции захвата их охватывающей области видимости могут передаваться как любой другой вид объекта
def make_adder(n):
    def adder(x):
        return n + x
    return adder
add5 = make_adder(5)
add6 = make_adder(6)
add5(10)
#Out: 15
add6(10)
#Out: 16

def repeatedly_apply(func, n, x):
    for i in range(n):
        x = func(x)
    return x

repeatedly_apply(add5, 5, 1)
#Out: 26 
Повторяемая и распаковка словаря
Функции позволяют указывать следующие типы параметров: позиционные, именованные, переменные позиционные, аргументы ключевых слов (kwargs). Вот четкое и краткое использование каждого типа.
def unpacking(a, b, c=45, d=60, *args, **kwargs):
    print(a, b, c, d, args, kwargs)

>>> unpacking(1, 2)
1 2 45 60 () {}
>>> unpacking(1, 2, 3, 4)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, c=3)
1 2 3 4 () {}


>>> pair = (3,)
>>> unpacking(1, 2, *pair, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, *pair, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, c=3, *pair)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

>>> args_list = [3]
>>> unpacking(1, 2, *args_list, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, *args_list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, *args_list, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'


>>> pair = (3, 4)
>>> unpacking(1, 2, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *pair)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *pair)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *pair, d=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'



>>> args_list = [3, 4]
>>> unpacking(1, 2, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *args_list)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *args_list)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *args_list, d=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'


>>> arg_dict = {'c':3, 'd':4}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'d':4, 'c':3}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'c':3, 'd':4, 'not_a_parameter': 75}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {'not_a_parameter': 75}


>>> unpacking(1, 2, *pair, **arg_dict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, 3, 4, **arg_dict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'

# Positional arguments take priority over any other form of argument passing
>>> unpacking(1, 2, **arg_dict, c=3)
1 2 3 4 () {'not_a_parameter': 75}
>>> unpacking(1, 2, 3, **arg_dict, c=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c' 
Принудительное использование именованных параметров
Все параметры, указанные после первой звездочки в сигнатуре функции, предназначены только для ключевых слов.
def f(*a, b):
    pass

f(1, 2, 3)
# TypeError: f() missing 1 required keyword-only argument: 'b'


 
В Python 3 можно поставить одну звездочку в сигнатуре функции, чтобы гарантировать, что оставшиеся аргументы могут быть переданы только с помощью аргументов ключевого слова.
def f(a, b, *, c):
    pass

f(1, 2, 3)
# TypeError: f() takes 2 positional arguments but 3 were given
f(1, 2, c=3)
# No error 
Рекурсивная лямбда с использованием присвоенной переменной
Синтаксис
Параметры
Примечания
Объекты функций
 — документация Python 3.9.5 
 Есть несколько функций, специфичных для функций Python.
  PyFunctionObject 
 Структура C, используемая для функций.
 PyTypeObject  PyFunction_Type 
 Это экземпляр  PyTypeObject  и представляет функцию Python
тип. Программистам Python предоставляется  типов.
 int  PyFunction_Check  (PyObject  * или )
 Вернуть истину, если  o  является функциональным объектом (имеет тип  PyFunction_Type ).
Параметр не должен быть  NULL . Эта функция всегда успешна.
 PyObject *  PyFunction_New  (PyObject  * код , PyObject  * globals )
  Возвращаемое значение: Новая ссылка. 
 Вернуть новый объект функции, связанный с объектом кода , код . глобальные  должен быть словарем с глобальными переменными, доступными функции.
 Строка документации и имя функции извлекаются из объекта кода.  __модуль__  извлекается из  глобальных файлов . Значения аргументов по умолчанию, аннотации и закрытие:
установлен в  NULL .  __qualname__  устанавливается на то же значение, что и имя функции.
 PyObject *  PyFunction_NewWithQualName  (PyObject  * код , PyObject  * globals , PyObject  * qualname )
  Возвращаемое значение: Новая ссылка.
 То же, что  PyFunction_New () , но также позволяет устанавливать функциональные объекты  __qualname__  атрибут.  qualname  должно быть объектом Unicode или  NULL ;
если  NULL , атрибут  __qualname__  устанавливается на то же значение, что и его  __name__  атрибут.
 PyObject *  PyFunction_GetCode  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть объект кода, связанный с объектом функции  op .
 PyObject *  PyFunction_GetGlobals  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть словарь глобальных переменных, связанный с функциональным объектом  op .
 PyObject *  PyFunction_GetModule  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть атрибут  __module__  функционального объекта  op .Это обычно
строка, содержащая имя модуля, но может быть установлена ​​на любой другой объект с помощью
Код Python.
 PyObject *  PyFunction_GetDefaults  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть значения аргумента по умолчанию для функционального объекта  op . Это может быть
кортеж аргументов или  NULL .
 int  PyFunction_SetDefaults  (PyObject  * op , PyObject  * по умолчанию )
 Установите значения аргумента по умолчанию для функционального объекта  op . значения по умолчанию  должны быть  Py_None  или кортеж.
 Вызывает  SystemError  и возвращает -1  в случае сбоя.
 PyObject *  PyFunction_GetClosure  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть замыкание, связанное с функциональным объектом  op . Это может быть  NULL  или кортеж ячеек.
 int  PyFunction_SetClosure  (PyObject  * op , PyObject  * закрытие )
 Установите закрытие, связанное с функциональным объектом  op . закрытие  должно быть  Py_None  или кортеж объектов ячеек.
 Вызывает  SystemError  и возвращает -1  в случае сбоя.
 PyObject *  PyFunction_GetAnnotations  (PyObject  * op )
  Возвращаемое значение: Заимствованная ссылка. 
 Вернуть аннотации функционального объекта  op . Это может быть
изменяемый словарь или  NULL .
 int  PyFunction_SetAnnotations  (PyObject  * op , PyObject  * аннотации )
 Установите аннотации для функционального объекта  op . аннотации  должен быть словарь или  Py_None .
 Вызывает  SystemError  и возвращает -1  в случае сбоя.
 функций Python (с примерами) 
 Python включает множество встроенных функций. Эти функции выполняют заранее определенную задачу и могут быть вызваны в любой программе в соответствии с требованиями.
 Однако, если вы не найдете подходящей встроенной функции для вашей цели, вы можете определить ее.Теперь мы увидим, как определять и использовать функцию в программе Python.
 Определение функции 
 Функция - это многократно используемый блок программных операторов, предназначенный для выполнения определенной задачи. Для определения функции Python предоставляет ключевое слово  def . Ниже приводится синтаксис определения функции.
 def имя_функции (параметры):
    "" "строка документации" ""
    заявление1
    заявление2
    ...
    ...
    возврат [выражение]
 
 За ключевым словом  def  следует подходящий идентификатор в качестве имени функции и круглые скобки. Один или несколько параметров могут быть необязательно упомянуты в круглых скобках. Символ :  после круглых скобок начинает блок с отступом.
 Первым оператором в теле функции может быть строка, которая называется строкой документации  .Он объясняет функциональность функции / класса.
 Строка документации не является обязательной.
 Тело функции содержит один или несколько операторов, выполняющих некоторые действия. Он также может использовать ключевое слово pass.
 Необязательно, последний оператор в функциональном блоке - это оператор возврата. Он отправляет управление выполнением обратно в среду.
 Если выражение добавляется перед return, его значение также возвращается в вызывающий код.
 В следующем примере определяется функция  greet () .
  def greet ():
    "" "Эта функция отображает" Hello World! "" ""
    print ('Привет, мир!')
  
 Выше мы определили функцию  greet () . Первый оператор - это строка документации, в которой упоминается, что делает эта функция. Второй подобный метод - это метод печати, который выводит указанную строку на консоль.Обратите внимание, что в нем нет оператора возврата.
 Чтобы вызвать определенную функцию, просто используйте ее имя как оператор в любом месте кода.
 Например, указанная выше функция может быть вызвана с использованием круглых скобок  greet () .
 По умолчанию все функции возвращают  Нет , если оператор return не существует.
 Функция help () отображает строку документации, как показано ниже.
  >>> помощь (привет)
Справка по функции приветствия в модуле __main__:

    приветствовать()
        Эта функция отображает "Hello World!"  
 Параметры функции 
 Можно определить функцию для получения одного или нескольких параметров (также называемых аргументами) и использования их для обработки внутри функционального блока.Параметрам / аргументам можно дать подходящие формальные имена. Функция  greet ()  теперь определена для получения строкового параметра с именем  name . Внутри функции оператор  print ()  модифицируется для отображения приветственного сообщения, адресованного полученному параметру.
  def greet (имя):
    print ('Привет', имя)

greet ('Steve') # вызываем функцию с аргументом
приветствовать (123)
  
 Имена аргументов, используемых в определении функции, называются формальными аргументами / параметрами.Объекты, фактически используемые при вызове функции, называются фактическими аргументами / параметрами.
 Параметры функции могут иметь аннотацию для указания типа параметра с использованием синтаксиса  параметр: тип . Например, следующее аннотирует строку типа параметра.
  def приветствие (name: str):
    print ('Привет', имя)

greet ('Steve') # вызываем функцию со строковым аргументом
greet (123) # вызвать ошибку для аргумента int
  
 Несколько параметров 
 Функция может иметь несколько параметров.Следующая функция принимает три аргумента.
  def greet (имя1, имя2, имя3):
    print ('Привет', имя1, ',', имя2, 'и', имя3)

greet ('Steve', 'Bill', 'Yash') # вызываем функцию со строковым аргументом
  
  Привет, Стив, Билл и Яш
  
 Неизвестное количество аргументов 
 Функция в Python может иметь неизвестное количество аргументов, если перед параметром поставить  * , если вы не знаете количество аргументов, которые пользователь собирается передать.
  def привет (* имена):
    print ('Привет', имена [0], ',', имена [1], ',', имена [3])

привет (Стив, Билл, Яш)
  
  Привет, Стив, Билл и Яш
  
 Следующая функция работает с любым количеством аргументов.
  def привет (* имена):
я = 0
print ('Привет', конец = '')
а len (имена)> i:
печать (имена [я], конец = ',')
я + = 1

привет (Стив, Билл, Яш)
привет ('Стив', 'Билл', 'Яш', 'Капил', 'Джон', 'Амир')
  
  Привет, Стив, Билл, Яш,
Привет, Стив, Билл, Яш, Капил, Джон, Амир
  
 Функция с аргументами ключевого слова 
 Чтобы вызвать функцию с аргументами, необходимо предоставить такое же количество фактических аргументов.Однако функция может быть вызвана путем передачи значений параметров с использованием имен параметров в любом порядке.
 Например, следующие значения передаются с использованием имен параметров.
  def greet (имя, фамилия):
    print ('Привет', имя, фамилия)

greet (lastname = 'Jobs', firstname = 'Steve') # передача параметров в любом порядке с использованием аргумента ключевого слова
  
 Аргумент ключевого слова ** kwarg 
 Функция может иметь один параметр с префиксом  ** .Этот тип параметра инициализируется новым упорядоченным отображением, получая любые лишние аргументы ключевого слова, по умолчанию новое пустое отображение того же типа.
  def привет (** человек):
print ('Привет', человек ['имя'], человек ['фамилия'])

приветствую (firstname = 'Steve', lastname = 'Jobs')
приветствую (lastname = 'Jobs', firstname = 'Steve')
привет (firstname = 'Bill', lastname = 'Gates', возраст = 55)
greet (firstname = 'Bill') # вызывает KeyError
  
  Привет, Стив Джобс
Привет, Стив Джобс
Привет Билл Гейтс
  
 При использовании параметра  **  порядок аргументов не имеет значения.Однако названия аргументов должны быть такими же.
 Получите доступ к значению аргументов ключевого слова, используя  paramter_name ['keyword_argument'] .
 Если функция обращается к аргументу ключевого слова, но вызывающий код не передает этот аргумент ключевого слова, то она вызовет исключение  KeyError , как показано ниже.
  def привет (** человек):
print ('Привет', человек ['имя'], человек ['фамилия'])

greet (firstname = 'Bill') # вызывает ошибку KeyError, необходимо предоставить аргумент 'lastname'
  
  Traceback (последний звонок последний):
  Файл "", строка 1, в 
    приветствовать (firstname = 'Bill')
  Файл "", строка 2, в приветствии
    print ('Привет', человек ['имя'], человек ['фамилия'])
KeyError: "фамилия"
  
 Параметр со значением по умолчанию 
 При определении функции ее параметрам могут быть присвоены значения по умолчанию.Это значение по умолчанию заменяется, если при вызове функции передается соответствующий фактический аргумент.
 Однако, если фактический аргумент не указан, внутри функции будет использоваться значение по умолчанию.
 Следующая функция  greet ()  определяется параметром  name , имеющим значение по умолчанию  «Гость» .
 Он будет заменен, только если будет передан какой-либо фактический аргумент.
  def greet (name = 'Гость'):
    print ('Привет', имя)

приветствовать()
привет ('Стив')
  
 Функция с возвращаемым значением 
 В большинстве случаев нам нужен результат функции, который будет использоваться в дальнейших процессах. Следовательно, когда функция возвращается, она также должна возвращать значение.
 Пользовательскую функцию можно также заставить возвращать значение в вызывающую среду, поместив выражение перед оператором return.
 В этом случае возвращаемое значение должно быть присвоено некоторой переменной.
  def sum (a, b):
    вернуть a + b
  
 Вышеупомянутая функция может быть вызвана и ей присвоено значение, как показано ниже.
  итого = сумма (10, 20)
печать (всего)
итого = сумма (5, сумма (10, 20))
печать (всего)
  
 Вызов, отступ, аргументы и возвращаемые значения 
 Что такое функция в Python? 
 Функция  в Python  - это фрагмент кода, который запускается при обращении к нему. Он используется для использования кода более чем в одном месте программы. Его также называют методом или процедурой.Python предоставляет множество встроенных функций, таких как print (), input (), compile (), exec () и т. Д., Но также дает свободу создавать свои собственные функции.
 В этом руководстве мы узнаем
 Как определить и вызвать функцию в Python 
 Функция в Python определяется оператором  «def» , за которым следует имя функции и круглые скобки (())
 Пример:
 Давайте определим функцию с помощью команды «def func1 ():» и вызовем эту функцию.Результатом функции будет  «Я изучаю функцию Python». 
 Функция  print func1 ()  вызывает нашу def func1 (): и выводит команду « Я изучаю функцию Python None. »
 В Python есть набор правил для определения функции.
 Любые аргументы или входные параметры должны быть помещены в эти круглые скобки
 Первый оператор функции может быть необязательным оператором - строкой документации или строкой документации функции
 Код внутри каждой функции начинается с двоеточия (:) и должен быть с отступом (пробел)
 Оператор return (выражение) завершает функцию, опционально передавая значение вызывающей стороне.Оператор return без аргументов аналогичен return None.
 Значение отступа (пробела) в Python 
 Прежде чем мы познакомимся с функциями Python, важно понять правило отступа для объявления функций Python, и эти правила применимы к другим элементам Python, а также к объявлению условий, петли или переменные.
 Python следует определенному стилю отступов для определения кода, поскольку функции  Python не имеют явного начала или конца, например фигурных скобок, чтобы указать начало и конец функции, они должны полагаться на этот отступ .Вот простой пример с командой «печать». Когда мы пишем функцию «print» прямо под def func 1 (): она покажет «ошибку отступа : ожидается блок с отступом ».
 Теперь, когда вы добавляете отступ (пробел) перед функцией "print", она должна печататься должным образом.
  Для успешной работы кода достаточно хотя бы одного отступа. Но лучше всего оставить 3-4 отступа для вызова функции .
 Также необходимо, чтобы при объявлении отступа вы  сохранили тот же отступ для остальной части кода .Например, на снимке экрана ниже, когда мы вызываем другой оператор «все еще в функции func1» и когда он не объявлен сразу под первым оператором печати, он будет отображать ошибку отступа  «Undent не соответствует никакому другому уровню отступа». 
 Теперь, когда мы применяем одинаковый отступ для обоих операторов и выравниваем их в одной строке, это дает ожидаемый результат.
 Как функция возвращает значение? 
 Команда возврата в Python указывает, какое значение вернуть вызывающей функции.
 Давайте разберемся с этим на следующем примере.
  Шаг 1)  Здесь - мы видим, когда функция не «возвращает». Например, нам нужен квадрат 4, и он должен дать ответ «16» при выполнении кода. Что он дает, когда мы просто используем код «print x * x», но когда вы вызываете функцию «print square», в качестве вывода выдает «None». Это связано с тем, что при вызове функции рекурсия не происходит и выпадает из конца функции. Python возвращает «Нет» в случае сбоя в конце функции.
  Шаг 2)  Для большей ясности мы заменяем команду печати командой присваивания. Проверим вывод.
 Когда вы запускаете команду «print square (4)», она фактически возвращает значение объекта, поскольку у нас нет какой-либо конкретной функции для выполнения здесь, она возвращает «None».
  Шаг 3)  Теперь мы увидим, как получить вывод с помощью команды «return». Когда вы используете функцию «return» и выполняете код, он выдаст на выходе «16."
  Шаг 4)  Функции в Python сами по себе являются объектом, и у объекта есть какое-то значение. Здесь мы увидим, как Python обрабатывает объект. Когда вы запускаете команду« print square », она возвращает значение объекта. Поскольку мы не передали никаких аргументов, у нас нет какой-либо конкретной функции, которую можно было бы запустить здесь, она возвращает значение по умолчанию (0x021B2D30), которое является местоположением объекта.  В практической программе Python вам, вероятно, никогда не понадобится сделайте это .. 
 Аргументы в функциях 
 Аргумент - это значение, которое передается функции при ее вызове.
 Другими словами, на вызывающей стороне это аргумент, а на стороне функции - параметр.
 Давайте посмотрим, как работает Python Args -
  Шаг 1)  Аргументы объявлены в определении функции. При вызове функции вы можете передать значения для этих аргументов, как показано ниже.
  Шаг 2)  Чтобы объявить значение аргумента по умолчанию, присвойте ему значение при определении функции.
 Пример: x не имеет значений по умолчанию. Значения по умолчанию y = 0.Когда мы предоставляем только один аргумент при вызове функции умножения, Python присваивает предоставленное значение x, сохраняя значение y = 0. Следовательно, умножение x * y = 0
  Шаг 3)  На этот раз мы изменим значение на y = 2 вместо значения по умолчанию y = 0, и он вернет результат как (4x2) = 8.
  Шаг 4)  Вы также можете изменить порядок, в котором аргументы могут быть переданы в Python. Здесь мы изменили порядок значений x и y на x = 4 и y = 2.
  Шаг 5)  Несколько аргументов также могут передаваться в виде массива. В этом примере мы вызываем несколько аргументов (1,2,3,4,5), вызывая функцию (* args).
 Пример: мы объявили несколько аргументов как число (1,2,3,4,5), когда вызываем функцию (* args); вывод выводится как (1,2,3,4,5)
  Советы :
 В Python 2.7. Перегрузка функции   не поддерживается в Python. Перегрузка функций - это возможность создавать несколько методов с одним и тем же именем с разной реализацией.Перегрузка функций полностью поддерживается в Python 3
 Существует большая путаница между методами и функциями. Методы в Python связаны с экземплярами объектов, а функции - нет. Когда Python вызывает метод, он связывает первый параметр этого вызова с соответствующей ссылкой на объект. Проще говоря, автономная функция в Python - это «функция», тогда как функция, которая является атрибутом класса или экземпляра, является «методом».
 Вот полный код Python 3 
# определить функцию
def func1 ():
   print («Я изучаю функцию Python»)
   print ("все еще в функции")
   
func1 ()

def квадрат (x):
  вернуть х * х
печать (квадрат (4))

def multiply (x, y = 0):
print ("значение x =", x)
print ("значение y =", y)
    
вернуть x * y
  
print (умножить (y = 2, x = 4))
 
 Вот полный код Python 2 
# определить функцию
def func1 ():
   print "Я изучаю функцию Python"
   напечатать "все еще в func1"
   
func1 ()

def квадрат (x):
  вернуть х * х
квадрат для печати (4)

def multiply (x, y = 0):
print "значение x =", x
print "значение y =", y
    
вернуть x * y
  
напечатать умножить (y = 2, x = 4)
 
 Описание: 
 Функция в Python - это фрагмент повторно используемого кода, который используется для выполнения одного связанного действия.В этой статье мы увидим
 Функция, определенная оператором  def 
 Блок кода внутри каждой функции начинается с двоеточия (:) и должен иметь отступ (пробел)
 Любые аргументы или входные параметры должны быть помещены внутри этих круглых скобок и т. д.
 После объявления функции перед кодом должен быть оставлен хотя бы один отступ
 Во всем коде в функции def должен быть сохранен один и тот же стиль отступа
 В соответствии с передовой практикой лучше всего использовать три или четыре отступа перед оператором
 Вы можете использовать команду «return», чтобы вернуть значения в вызов функции.
 Python напечатает случайное значение, например (0x021B2D30), если аргумент не передан вызывающей функции. Пример «функции печати».
 На вызывающей стороне это аргумент, а на стороне функции это параметр
 Значение по умолчанию в аргументе - когда мы предоставляем только один аргумент при вызове функции умножения или любой другой функции, Python назначает другой аргумент по умолчанию
 Python позволяет вам также изменить порядок аргументов
 Программа на Python состоит из множества строк кода, хранящихся в файле с именем «example».ру ".
Естественно иметь способ разделить код строк на разумные части, и они называются функциями  . Почти весь код, с которым вы работаете в Python, находится внутри функции.
 Синтаксис функции Python - def 
 Предположим, у нас есть программа Python в файле example.py. Текст программы будет разделен на множество функций, каждая из которых будет отмечена в тексте программы словом  def :
 Вот пример функции Python с именем «foo».Эта функция ничего толкового не делает, просто показывает синтаксис функции.
def foo ():
    х = 1
    у = 2
    г = 3
    я = 0
 
 Части определения функции:
  def  - Функция начинается со слова  def 
  name  - def следует за именем функции, здесь  foo  
 Имя выбирается программистом, чтобы отразить, что делает функция. 
 Здесь "foo" - это просто бессмыслица из CS.
  скобка  - после имени следует пара скобок и двоеточие  ():  
 Функции и пары скобок  ()  часто идут вместе в синтаксисе Python
  body lines  - Внутри def с отступом находятся "основные" строки кода, составляющие функцию.
 Когда функция выполняется, компьютер перемещает линии ее тела сверху вниз.
 Ключевые моменты: функция начинается со слова def, имеет имя и несколько строк кода.
 Последовательность вызова функций 
 Допустим, у нас есть функция с именем "вызывающий", и строки ее тела проходят сверху вниз обычным образом:
def вызывающий ():
    х = 6
    у = х + 1
    foo () # вызываем функцию "foo"
    х = 7
...
 
 Чтобы «вызвать» функцию, нужно вызвать и запустить ее строки кода.В приведенном ниже списке прослеживается последовательность выполнения функции caller (), вызова функции foo () для выполнения ее строк и затем возврата для завершения строк caller ().
 Строка 1:  x = 6  запускается в вызывающей стороне
 Строка 2:  y = x + 1  запускается в вызывающей стороне
 Строка 3:  foo ()  запускается, вызывая эту функцию 
 - Выполнение переходит к foo (), выполняя там строки тела 
 -Обратите внимание на скобки  ()  для вызова функции 
 - Запуск foo () проходит по его строкам 
 -После завершения foo () выполнение кода вызывающего абонента возобновляется...
 Строка 4  x = 7  запускается в вызывающей стороне
 Выполнение строк в коде вызывающего абонента приостанавливается на время выполнения вызываемой функции.
Или, что эквивалентно, мы могли бы сказать, что компьютер запускает одну функцию за раз, поэтому, когда он запускает foo (), он не запускает строки caller () и наоборот.
 Вот диаграмма, показывающая последовательность вызова функции.
Выполнение начинается со строк в вызывающей функции и переходит к запуску строк в вызываемой функции. Когда вызываемая функция завершается, выполнение возобновляется с того места, где оно было остановлено в вызывающей программе.
 Бонусный факт: переменные, такие как "x" выше, являются отдельными и независимыми для каждой функции, поэтому x в вызывающей программе является полностью отдельной переменной от x в foo. См. Раздел функциональных переменных ниже для получения более подробной информации о переменных.
 Ключевой момент Вызов функции по ее имени с добавлением скобок, например  foo () 
 Вариант: Обект-ориентированное существительное. Глагол Вызов функции 
 Другой способ вызова функции - объектно-ориентированный объект, также известный как существительное.стиль глагола, например:
    bit.move ()
 
 Здесь  бит  - это какие-то данные Python, а  .move ()  - это функция, запускаемая с этими данными. По сути, это всего лишь вызов функции, но сначала перечислены данные, над которыми нужно работать, затем точка, а затем имя функции. Python смешивает обычные вызовы функций и вызовы функций ООП. Многие языки используют этот стиль «ООП», поскольку он дает хорошее представление о том, с какими данными вы хотите работать в первую очередь, а затем о том, какую операцию выполнять с этими данными.
 Параметр пройден 
 Предположим, у нас есть функция paint_window (), которая заполняет окно компьютера цветом. Нам нужен способ сообщить функции , какой цвет  использовать при ее вызове - синий, красный или что-то еще.
 Параметр   - это дополнительная информация, предоставляемая вызывающей стороной, которая настраивает выполнение вызываемой функции. Мы узнаем все детали параметров вовремя. На сегодняшний день достаточно, чтобы функция могла принимать параметр, а значение параметра «передается» как часть вызова просто путем включения желаемого значения в круглые скобки.
 Так, например, вызов функции paint_window () для закрашивания окна синим цветом может выглядеть следующим образом.
paint_window ('синий')
 
 Синтаксис  «синий»  - это строка Python, которая является способом выражения такого фрагмента текста.
 Вызов функции окрашивания окна в желтый цвет будет выглядеть так:
paint_window ('желтый')

 
 Программист сказал бы, что код «вызывает функцию paint_window» и «передает« желтый »в качестве параметра».
 Можно сказать, что  paint_window  - это глагол, который мы хотим, чтобы компьютер выполнял, а  «синий»  или  «желтый»  - это модификаторы существительных, которые мы предоставляем действию.
 Параметры в скобках 
 Наличие параметров, возможно, объясняет, почему круглые скобки являются частью синтаксиса вызова функции - круглые скобки являются местом для значений параметров при вызове функции.
 Пример параметра print () 
 Это демонстрация / пример "в интерпретаторе".В Python есть функция  print () . Он делает много вещей, но одна простая вещь, которую он делает, - это принимает значение параметра и выводит его на экран. Несмотря на неприглядность, это способ увидеть вызов функции и параметры в действии. Вот несколько вызовов  print ()  в интерпретаторе с их выводом (см. Также: интерпретатор, чтобы попробовать это самостоятельно).
>>>  print ('hi')  # Вызвать print (), передав параметр 'hi'
hi # Вывод, производимый print ()
>>>  печать (23) 
23
>>>  печать (4 + 5) 
9
 
 Здесь вы видите вызов  print ()  по его имени, как обычно, и между скобками, передающими значение параметра, например  'hi'  или  23 .Функция print () принимает значение этого параметра и выводит его на экран.
 Функция может принимать несколько значений параметров, и фактически print () принимает любое количество параметров. Значения нескольких параметров перечислены в круглых скобках, разделенных запятыми, например:
>>>  print ('привет', 22) 
привет 22
>>>  print ('вот, 123,' пончики ') 
вот 123 пончика
>>>  печать (4, 8, 15, 16, 'woot') 
4 8 15 16 Вт
 
 См. Также: print
 1.Вызов функции - переменные и параметры 
 Как работают параметры вызова функций? Чаще всего вызов функции работает интуитивно, поэтому вам не нужно слишком много думать об этом. НО при нажатии вы должны знать, как это работает, чтобы не споткнуться.
 1. Переменные и параметры в каждой функции независимы, отделены от таковых в других функциях. По умолчанию «x» в одной функции не зависит от «x» в какой-либо другой функции.
 Если бы переменные в каждой функции не были независимыми, функции могли бы мешать друг другу.Предположим, что программист работает над функцией и использует «итоговую» переменную. Затем, если другая функция где-то еще в программе также случайно выбрала имя «total». Так не изменит ли запуск одной из этих функций переменную, используемую другой функцией? Было бы очень сложно удержаться прямо. Следовательно, поведение по умолчанию таково, что переменные, введенные в каждую функцию, независимы и изолированы от переменных в других функциях, даже если они имеют то же имя. Это также соответствует дизайну «черного ящика», в котором каждая функция должна быть независимой и изолированной от окружающей среды.
 2. Вызов функции: значения параметров вводятся в позиции   внутри (..) (не по имени или как-либо еще)
 Пример вызова функции 
 Допустим, у нас есть функция "foo" с двумя параметрами, которая позже вызывается функцией "вызывающий". Что напечатает пробег caller () ниже? Он очень ориентирован на детали, но, к счастью, здесь всего несколько строк.
def foo (x, y):
    х = х - у
    вернуть x + 1


def вызывающий ():
    х = 2
    у = 3
    z = foo (у, х)
    печать (x, y, z)
 
 Решение
печатная строка:
2 3 2

Значения, переданные  в  в foo (x, y), равны 3 и 2, возвращаемое значение - 1
«X» в foo () не зависит от «x» в caller ().
 
 foo () y = 13? 
 Что, если мы скажем  y = 13  вверх в foo ()? Это изменит результат? Нет.Каждая функция имеет свой собственный «y», который просто изменяет переменную «y» внутри foo ().
 Попробовать интерпретатор 
 Необычно писать def в интерпретаторе  >>> , но здесь это живой способ увидеть, что переменные независимы для каждой функции, а параметры совпадают по позиции.
>>>  # 1. define foo (), у него есть свои «x» и «y»
>>>  def foo (x, y): 
... х = х - у
... вернуть x + 1
...
>>>  
>>>  # 2.установите здесь переменную "x" отдельно от "x" выше.
>>>  # Затем вызовите foo (), что печатается?
>>>  х = 6 
>>>  y = foo (10, x) 
>>>  печать (x, y) 
???
 
 Что напечатано? Переменная x по-прежнему равна 6, поскольку она отличается от x в foo (), поэтому печатается «6 5».
 Функциональные переменные 
 По умолчанию переменные и параметры в каждой функции называются «локальными» переменными, они независимы и отделены от переменных в других функциях.«X» в одной функции не зависит от «x» в другой функции. Большинство переменных, которые вы используете в коде Python, являются локальными переменными. Существует еще один «глобальный» тип переменных, который имеет некоторые тенденции к ошибкам и который большинству программ не нужен, поэтому мы не используем глобальные переменные в CS106A. Для получения дополнительной информации см. Раздел «Глобалы».
 Присвоение каждой функции собственных переменных имеет смысл, если вы думаете обо всей программе. Если бы переменные не были независимыми, функции могли бы легко мешать друг другу.Предположим, что программист работает над функцией и использует «итоговую» переменную. Затем, если другая функция где-то еще в программе также выбрала имя «total» для переменной, теперь у нас есть проблема, когда две «total» переменные мешают друг другу. Было бы очень сложно удержаться прямо. Следовательно, поведение по умолчанию таково, что переменные, введенные в каждую функцию, независимы и изолированы от переменных в других функциях. Это также соответствует дизайну «черного ящика», пытаясь сохранить независимость каждой функции, принимая данные только через ее параметры и возвращая их вывод.
 Пример функциональной переменной 
 В следующем примере показано, что функциональные переменные независимы. Это также показывает, что параметры функций совпадают по позиции, а не по имени.
 Допустим, у нас есть функция "foo" с двумя параметрами, и она вызывается функцией "вызывающего" позже. Что напечатает пробег caller () ниже? Это очень подробный фрагмент кода, который нужно отследить, но там всего несколько строк.
def foo (x, y):
    х = х - у
    вернуть x + 1


def вызывающий ():
    х = 2
    у = 3
    z = foo (у, х)
    печать (x, y, z)
 
 Что печатает вызывающий ()?
 Решение
печатная строка:
2 3 2

Значения, переданные  в  в foo (x, y), равны 3 и 2, возвращаемое значение - 1
«X» в foo () не зависит от «x» в caller ().
 
 foo () y = 13? 
 Что, если мы скажем  y = 13  вверх в foo ()? Это изменит результат? Нет.Каждая функция имеет свой собственный «y», который просто изменяет переменную «y» внутри foo ().
 Попробовать интерпретатор 
 Необычно писать def в интерпретаторе  >>> , но здесь это интерактивный способ увидеть, как переменные и параметры работают для каждой функции. Вы можете сами ввести это в переводчик.
>>>  # 1. define foo (), у него есть свои «x» и «y»
>>>  def foo (x, y): 
... х = х - у
... вернуть x + 1
...
>>>  
>>>  # 2. Установите здесь переменную "x" отдельно от "x" выше.
>>>  # Затем вызовите foo (), что печатается?
>>>  х = 6 
>>>  y = foo (10, x) 
>>>  печать (x, y) 
???
 
 Что напечатано? Переменная x по-прежнему равна 6, поскольку она отличается от x в foo (), поэтому печатается «6 5».
 Глобальные переменные 
 Глобальные переменные - это переменные, определенные вне функции.Им легко вводить ошибки, поэтому мы не используем их в CS106A. Вот краткое введение в глобальные переменные в Python.
 Переменная создается присвоением =. Глобальная переменная создается назначением вне функции. Мы использовали это для создания констант, которые на самом деле были разновидностью глобальной переменной.
 Пример константы Python 
 Этот код создает глобальную константу  STATES , а затем функция в этом файле может  прочитать глобальную константу  без какого-либо дополнительного синтаксиса.Порядок определения константы и функции в файле не имеет значения. Такое использование константы нормально и не создает проблем.
СОСТОЯНИЯ = ['ca', 'tx', 'nj', 'me']

def foo ():
    для state_code в STATES:
        ....
 
 Пример глобальной переменной 
 Предположим, вместо этого мы хотим иметь глобальную переменную с именем  count , и когда функция increment () запускается, она увеличивает счетчик. В этой функции строка  global count  указывает, что в этой функции использование  count  не должно быть локальной переменной, а должно использовать глобальную переменную с этим именем.
count = 0 # создать глобальную переменную count


def приращение ():
    global count # заявляем, что нам нужен глобальный
    count + = 1 # доступ к глобальной переменной


def print_count ():
    print ('текущий:', количество)

 
 Если функция просто хочет прочитать глобальную информацию, но не изменять ее, то "глобальное" объявление не требуется. Python сначала ищет локальную переменную с этим именем, а если ничего не найдено, возвращается к поиску глобальной переменной с таким именем. Вот как работает приведенная выше функция print_count () - просто используя имя переменной  count , она автоматически получает глобальную.Если функции нужно  установить  как глобальную переменную, требуется «глобальное» объявление.
 Фактически, идея о том, что чтение из глобальной переменной работает без какого-либо дополнительного синтаксиса, заключается в том, как работают константы. Посмотрите на приведенный выше пример  STATES  -  STATES  - это просто глобальная переменная, и тогда функция может читать из нее.
 Попробуйте глобальные переменные в интерпретаторе 
 Вы можете попробовать версию вышеперечисленного в интерпретаторе, чтобы увидеть ее в действии.
>>>  количество = 6 
>>>  
>>>  def приращение (): 
... глобальный счет
... count + = 1
...
>>>  
>>>  счет 
6
>>>  приращение () 
>>>  счет 
7
>>> 
>>>  специальный = 17 
>>>  def foo (): 
... print ('особенное:', особенное)
...
>>>  foo () 
специальный: 17
>>> 
 
 Стиль и глобальные переменные 
 Проблема с глобальными переменными заключается в том, что они не соответствуют модели черного ящика - теперь выполнение функции определяется как ее параметрами, так и текущим состоянием всех глобальных переменных, которые использует функция.Это может значительно усложнить проектирование и отладку. Лучшая стратегия - сузить функции до использования только их параметров, и это также делает функции относительно легкими для тестирования, как мы видели с Doctests.
 Обратите внимание, что константы не создают этой проблемы проектирования. Поскольку константа не изменяется, она не мешает модели функции черного ящика.
 Авторские права 2020 Ник Парланте
 Как писать функции Python 
  Функция Python - это группа кода.Чтобы запустить код в функции, вы должны вызвать функцию. Функция может быть вызвана из любого места после определения функции. Функции могут возвращать значение с помощью оператора return. 
 Функции являются общей чертой всех языков программирования. Они позволяют разработчикам писать блоки кода, которые выполняют определенные задачи. Функция может выполняться столько раз, сколько хочет разработчик в своем коде.
 Функции позволяют разработчикам уменьшить количество повторений в своем коде, поскольку они могут выполнять один и тот же блок кода несколько раз в одной программе.
 В этом руководстве с примерами обсуждаются основы функций Python, как создавать и вызывать функцию и как работать с аргументами. К концу чтения этого руководства вы станете экспертом в написании функций на Python.
 Что такое функция Python? 
 Функция - это блок кода, который выполняется только при вызове. Функции Python возвращают значение с помощью оператора return, если он указан. Функция может быть вызвана в любом месте после объявления функции.
 Сама по себе функция ничего не делает. Но когда вам нужно использовать функцию, вы можете вызвать ее, и код внутри функции будет выполнен.
 В Python есть два типа функций: определяемые пользователем и встроенные. Встроенные функции - это такие функции, как:
  print () , который выводит оператор на консоль
 Python  len () , который вычисляет длину списка
 Python  str () , который преобразует значение в строку
 Пользовательские функции - это многократно используемые блоки кода, написанные вами, разработчиком.Эти блоки кода позволяют более эффективно организовать ваш код. Это важно, потому что чем более организован ваш код, тем проще его будет поддерживать.
 Как определить функцию Python 
 Определение функции относится к созданию функции. Это включает в себя написание блока кода, который мы можем вызывать, ссылаясь на имя нашей функции. Функция обозначается ключевым словом def, за которым следует имя функции и набор скобок.
 В этом примере мы собираемся создать простую функцию, которая печатает оператор  Сегодня понедельник!  к консоли.Для этого мы можем использовать следующий код:
 def print_monday (): print («Сегодня понедельник!») 
 Когда мы запускаем наш код, ничего не происходит. Это потому, что для того, чтобы наша функция работала, нам нужно ее вызвать. Для этого мы можем указать имя нашей функции следующим образом:
 def print_monday (): print («Сегодня понедельник!») Print_monday () 
 Наш код возвращает:
 Давайте разберем основные компоненты нашей функции:
 ключевое слово  def  используется, чтобы указать, что мы хотим создать функцию.
  print_monday  - это имя нашей функции. Он должен быть уникальным.
  ()  - это место, где будут храниться наши параметры. Поговорим об этом позже.
 :  отмечает конец заголовка нашей функции.
 Теперь наши функции могут быть настолько сложными, насколько мы хотим. Предположим, мы хотим написать программу, которая сообщает пользователю, сколько букв в его имени. Мы могли бы сделать это с помощью этого кода:
 def calculate_name_length (): name = str (input ("Как вас зовут?")) Name_length = len (name) print ("Длина вашего имени", name_length, " буквы.") calculateNameLength () 
 Если мы запустим наш код и введем имя« Элизабет », будет возвращен следующий ответ:
 Длина вашего имени - 9 букв. 
 Мы определяем функцию с именем  calculate_name_length ()  . В теле функции мы запрашиваем у пользователя его имя, а затем используем  len ()  для вычисления длины имени пользователя. Наконец, мы печатаем «Длина вашего имени составляет [длина] букв.», Где длина - длина имени пользователя до консоли.
 Параметры и аргументы функций 
 В наших первых примерах мы использовали пустые скобки с нашими функциями. Это означает, что наши функции не принимали никаких аргументов.
 Аргументы позволяют передавать в функцию информацию, которую функция может читать. Аргументы функции заключаются в круглые скобки, следующие за именем функции.
 Давайте рассмотрим базовый пример, чтобы проиллюстрировать, как работают аргументы.
 Пример параметров и аргументов Python 
 Предположим, мы хотим создать программу, которая умножает два числа.Мы могли бы сделать это с помощью этого кода:
 def multiply_numbers (number1, number2): answer = number1 * number2 print (number1, "x", number2, "=", answer) multiply_numbers (5, 10) multiply_numbers (15, 2) ) 
 Наша программа Python возвращает:
 Сначала мы определяем функцию с именем  multiply_numbers . Имена параметров в функции, которые принимает наш код: число1 и число2. Мы определяем их в скобках, где определяется список параметров.
 Затем мы объявляем переменную Python под названием «answer», которая умножает значения number1 и number2. Затем мы выводим на консоль инструкцию с выписанной полной математической суммой, за которой следует ответ на математическую задачу.
 Мы указали обязательные аргументы. Это потому, что мы не установили значения по умолчанию для каждого аргумента. Мы должны указать количество аргументов, равное количеству аргументов в списке параметров, иначе интерпретатор Python вернет ошибку.
 В конце нашей программы мы дважды вызываем нашу функцию  multiply_numbers .
 Сначала мы указываем аргументы 5 и 10. Наша программа умножает эти значения, чтобы вычислить 50. Затем наша программа выводит на консоль «5 x 10 = 50». Затем мы указываем аргументы 15 и 2, которые наша программа умножает. Затем наша программа выводит на консоль «15 x 2 = 30».
 По умолчанию порядок аргументов, которые вы передаете в функцию, соответствует порядку, в котором они обрабатываются вашей программой. Когда мы запускаем «multiply_numbers (5, 10)», значение «number1» становится 5.Значение «number2» становится 10. Мы поговорим о том, как переопределить это в разделе «аргументы ключевого слова».
 Дополнительную информацию об аргументах см. В нашем руководстве по необязательным аргументам Python.
 A Примечание: параметры и аргументы 
 Термины  параметр  и  аргумент  относятся к одному и тому же: передаче информации в функцию. Но между ними есть небольшая разница.
 Параметр - это переменная в скобках в функции.Аргумент - это значение, которое передается функции при ее вызове. Итак, в нашем последнем примере «число1» и «число2» - это параметры, а 5 и 10 - аргументы.
 Аргументы ключевого слова функции 
 Как мы уже обсуждали, порядок, в котором вы передаете аргументы, - это порядок, в котором ваша программа будет их обрабатывать. Итак, первый параметр будет присвоен первому аргументу и так далее. Однако есть способ отменить это правило.
 Вы можете использовать аргументы ключевого слова в вызове функции, что позволяет вам назначать значение аргумента на основе его имени параметра.Использование аргументов ключевых слов позволяет вам указывать значение ключевых слов в любом порядке.
 Аргументы ключевых слов работают, потому что вы будете использовать ключевые слова для сопоставления значений с параметрами вместо того, чтобы полагаться на порядок аргументов для передачи значений.
 Предположим, мы создаем программу, которая распечатывает имя и адрес электронной почты кого-то, кто подписался на список рассылки. Мы могли бы написать эту программу, используя следующий код:
 def print_info (name, email): print ("Name:", name) print ("Email:", email) print_info (email = "[email protected] ", name =" Alex Hammond ") 
 Наш код возвращает:
 Имя: Alex Hammond Электронная почта: [email protected] 
 Мы объявляем функцию, которая принимает два параметра: имя и адрес электронной почты. Мы выводим на консоль « Name:» , за которым следует значение параметра  name . Затем мы печатаем «_Email:» _ в консоль, за которым следует значение параметра  email . Мы используем Python print () для вывода этих значений на консоль.
 Затем мы вызываем нашу функцию и указываем два аргумента. Аргумент  email  становится равным  [email protected] , а аргумент  name  становится равным  Alex Hammond .
 В нашем коде мы разделили имя аргумента и его значение знаком равенства (=). Это означало, что нам больше не нужно было указывать наши аргументы в порядке появления наших параметров (имя, адрес электронной почты). Мы могли использовать любой заказ, какой захотим.
 Значения аргументов по умолчанию 
 Кроме того, вы можете указать значение аргумента по умолчанию для параметра в функции.
 Предположим, мы хотим, чтобы значение  email  было по умолчанию  [email protected] . Мы могли бы сделать это, используя следующий код:
 def print_info (name, email = "[email protected]"): print ("Name:", name) print ("Email:", email) print_info ("Alex Hammond ") 
 Наш код Python возвращает:
 Имя: Alex Hammond Электронная почта: [email protected] 
 Мы установили значение по умолчанию для параметра  email  как  default @ gmail.com . Когда мы запускаем наш код и вызываем функцию  print_info () , нам не нужно указывать значение для аргумента  email . В этом примере, когда мы выполняем  print_info () , мы указываем только один аргумент: имя пользователя.
 Возврат значений в основную программу 
 До сих пор мы обсуждали, как передать значения  в  функцию. Но функцию также можно использовать для передачи значений от  до  остальной части программы.
 Оператор  return  завершает функцию и позволяет передать значение обратно в основную программу. Если вы используете оператор  return  без аргумента, функция вернет значение  None .
 Предположим, мы хотим создать программу, которая умножает два числа. Затем, когда эти два числа были умножены, мы хотим вернуть их в нашу основную программу. Мы могли бы сделать это с помощью этого кода:
 def multiply_numbers (number1, number2): answer = number1 * number2 return answer ans = multiply_numbers (5, 6) print (ans) 
 Наш код возвращает:
 Сначала мы определяем функция называется  multiply_numbers .Эта функция принимает два параметра: число1 и число2. Когда эта функция вызывается, значения «number1» и «number2» умножаются. Затем мы используем оператор  return , чтобы передать умноженное число в основную программу.
 Мы вызываем функцию  multiply_numbers ()  и указываем два аргумента: 5 и 6. Обратите внимание, что мы также присваиваем результат функции переменной ans. Когда эта строка кода запускается, вызывается наша функция, и ее результат присваивается ans.Затем наш код выводит значение ans, которое в данном случае равно 30.
 Оператор Python  return  останавливает выполнение функции, даже если она не возвращает значение. Вот пример такого поведения в действии:
 def run_ten (): for i in range (0, 10): if i == 4: return print ("Finished") run_ten () 
 Наш код ничего не печатает в приставка. Хотя в нашем коде есть оператор print («Finished») », он не выполняется.
 Это потому, что, когда наш цикл for выполняется четыре раза (когда  i  равно 4), выполняется инструкция return.Это заставляет нашу функцию останавливать выполнение и останавливает выполнение цикла.
 После того, как наша функция остановится, код в нашей основной программе продолжит выполнение.
 Заключение 
 Функции Python - это блоки кода, которые выполняют определенное действие. Функции в программе можно вызывать сколько угодно раз. Это означает, что вы можете запускать один и тот же блок кода несколько раз, не повторяя свой код.
 Функции позволяют уменьшить количество повторений в вашем коде, тем самым облегчая чтение ваших программ как вам, так и другим кодировщикам.
 Для задачи напишите функцию, которая выводит на консоль каждое число от 1 до 10 (включая 10). Эта функция должна содержать цикл for. Когда функция будет выполнена, вы должны напечатать «Готово!» к консоли. Вызовите вашу функцию один раз в конце вашей программы.
 Результат должен быть:
 В этом руководстве обсуждались основы функций в Python, как писать и вызывать функцию, а также как работать с аргументами и параметрами. Теперь вы готовы начать писать функции на Python, как эксперт!
 Чтобы узнать о лучших курсах, книгах и учебных ресурсах Python, ознакомьтесь с нашим подробным руководством «Как выучить Python».
 Функции Python - AskPython 
 Функция - это блок кода с именем.
 Мы можем вызывать функцию по ее имени.
 Код внутри функции выполняется только при ее вызове.
 Функция может принимать данные от вызывающей программы, она вызывается как параметры функции.
 Параметры функции заключены в круглые скобки и разделены запятой. Функция может принимать любое количество аргументов.
 Функция может возвращать данные вызывающей программе.В отличие от других популярных языков программирования, в определении функций Python не указывается тип возвращаемого значения.
 Мы не можем использовать  зарезервированных ключевых слов  в качестве имени функции. Имя функции должно соответствовать правилам определения идентификаторов  Python .
 Как определить функцию в Python? 
 Мы можем определить функцию в Python, используя ключевое слово  def . Давайте посмотрим на пару примеров функции в Python.
def привет ():
    print ('Привет, мир')


def add (x, y):
    print (аргументы f: {x} и {y} ')
    вернуть x + y
 
 На основе приведенных выше примеров мы можем определить структуру функции как это.
def имя_функции (аргументы):
    # операторов кода
 
Функции Python
 Как вызвать функцию в Python? 
 Мы можем вызывать функцию по ее имени. Если функция принимает параметры, мы должны передать их при вызове функции.
Привет()
сумма = добавить (10, 5)
print (f'sum равно {sum} ')
 
 Мы вызываем определенные нами функции hello () и add (). Мы также вызываем функцию print (), которая является одной из встроенных функций в Python.
 Типы функций Python 
 В Python есть два типа функций.
 встроенные функции: функции, предоставляемые языком Python, такие как print (), len (), str () и т. Д.
 пользовательские функции: функции, определенные нами в программе Python.
 Может ли функция иметь значение параметра по умолчанию? 
 Python допускает значения по умолчанию для параметров функции. Если вызывающий абонент не передает параметр, используется значение по умолчанию.
def привет (год = 2019):
    print (f'Hello World {год} ')


hello (2020) # параметр функции передан
hello () # параметр функции не передан, поэтому будет использоваться значение по умолчанию
 
  Выход: 
Привет, мир 2020
Привет, мир 2019
 
 Можно ли иметь несколько операторов возврата внутри функции? 
 Да, функция может иметь несколько операторов возврата.Однако при достижении одного из операторов возврата выполнение функции прекращается, и значение возвращается вызывающей стороне.
def odd_even_checker (я):
    если я% 2 == 0:
        вернуть 'даже'
    еще:
        вернуть "нечетное"


печать (odd_even_checker (20))
печать (odd_even_checker (15))
 
 Может ли функция Python возвращать несколько значений одно за другим? 
 Функция Python может возвращать несколько значений одно за другим. Он реализован с использованием ключевого слова yield. Это полезно, когда вы хотите, чтобы функция возвращала большое количество значений и обрабатывала их.Мы можем разделить возвращаемые значения на несколько частей, используя оператор yield. Этот тип функции также называется функцией генератора.
def return_odd_ints (i):
    х = 1
    в то время как x <= i:
        доход x
        х + = 2


output = return_odd_ints (10)
для вывода на выходе:
    распечатать)
 
  Вывод: 
 Аргументы переменных функций Python 
 Python допускает три типа параметров в определении функции.
 Формальные аргументы: те, которые мы уже видели в примерах.
 Переменная Число аргументов, не являющихся ключевыми словами: например, def add (* args)
 Переменная Число аргументов ключевого слова или именованных аргументов: например, def add (** kwargs)
 Некоторые важные моменты относительно переменных аргументов в Python:
 Порядок аргументов должен быть формальными аргументами, * args и ** kwargs.
 Не обязательно использовать имена параметров переменных в качестве аргументов и kwargs. Однако лучше всего использовать их для лучшей читаемости кода.
 Тип args - кортеж. Таким образом, мы можем передать кортеж для отображения с переменной * args.
 Тип кваргов - дикт. Таким образом, мы можем передать словарь для сопоставления с переменной ** kwargs.
 Вот простой пример использования переменных аргументов в функции.
def add (x, y, * args, ** kwargs):
    сумма = х + у
    для аргументов:
        сумма + = а

    для k, v в kwargs.items ():
        сумма + = v
    сумма возврата


total = add (1, 2, * (3, 4), ** {"k1": 5, "k2": 6})
печать (всего) # 21
 
 Рекурсивная функция Python 
 Когда функция вызывает сама себя, она называется рекурсивной функцией.В программировании этот сценарий называется рекурсией.
 Вы должны быть очень осторожны при использовании рекурсии, потому что есть вероятность, что функция никогда не завершится и перейдет в бесконечный цикл. Вот простой пример печати ряда Фибоначчи с использованием рекурсии.
def fibonacci_numbers_at_index (количество):
    если count <= 1:
        счетчик возврата
    еще:
        вернуть fibonacci_numbers_at_index (count - 1) + fibonacci_numbers_at_index (count - 2)


count = 5
я = 1
в то время как я <= count:
    печать (fibonacci_numbers_at_index (i))
    я + = 1
 
 Хорошо знать о рекурсии, но в большинстве случаев при программировании это не нужно.Вы можете сделать то же самое, используя цикл for или while.
 Тип данных функции Python 
 Функции Python являются экземплярами класса «функция». Мы можем проверить это с помощью функции type ().
def foo ():
    проходить


печать (тип (foo))
 
  Вывод : 
 Функция Python против метода 
 Функция Python является частью файла сценария python, в котором она определена, тогда как методы определены внутри определения класса.
 Мы можем вызвать функцию напрямую, если она находится в том же модуле. Если функция определена в другом модуле, мы можем импортировать модуль, а затем напрямую вызвать функцию. Нам нужен класс или объект класса для вызова методов.
 Функция Python может обращаться ко всем глобальным переменным, тогда как методы класса Python могут обращаться к глобальным переменным, а также к атрибутам и функциям класса.
 Тип данных функций Python - «функция», тогда как тип данных методов Python - «метод».
 Давайте посмотрим на простой пример функций и методов в Python.
Данные класса:
    def foo (сам):
        print ('метод foo')


def foo ():
    print ('функция foo')


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

# вызов метода
d = Данные ()
d.foo ()

# проверка типов данных
печать (тип (foo))
печать (введите (d.foo))
 
  Выход: 
функция foo
foo метод
<класс 'функция'>
<класс 'метод'>
 
 Преимущества функций Python 
 Повторное использование кода, потому что мы можем вызывать одну и ту же функцию несколько раз
 Модульный код, поскольку мы можем определять разные функции для разных задач
 Улучшает ремонтопригодность кода
 Абстракция, поскольку вызывающий не делает необходимо знать реализацию функции
 Анонимная функция Python 
 Анонимные функции не имеют имени.Мы можем определить анонимную функцию в Python, используя ключевое слово lambda.
def квадрат (x):
    вернуть х * х


f_square = лямбда x: x * x

print (квадрат (10)) # 100
print (f_square (10)) # 100
 
 Заключение 
 Функции являются важной частью языка программирования. Функции Python определяются с помощью ключевого слова def. У нас может быть переменное количество аргументов в функции Python. Python также поддерживает анонимную функцию. Они могут возвращать одно значение или давать несколько значений одно за другим.
 функций Python - javatpoint 
 Функции - самый важный аспект приложения. Функцию можно определить как организованный блок многократно используемого кода, который можно вызывать при необходимости.
 Python позволяет разделить большую программу на основные строительные блоки, известные как функции. Функция содержит набор программных операторов, заключенных в {}. Функцию можно вызывать несколько раз, чтобы обеспечить возможность повторного использования и модульность программы Python.
 Функция помогает программисту разбить программу на более мелкие части. Он очень эффективно организует код и избегает повторения кода. По мере роста программы функция делает программу более организованной.
 Python предоставляет нам различные встроенные функции, такие как  range ()  или  print () . Хотя, пользователь может создавать свои функции, которые можно называть пользовательскими функциями.
 В основном есть два типа функций.
  Пользовательские функции  - Пользовательские функции определяются пользователем   для выполнения конкретной задачи.
  Встроенные функции  - Встроенные функции - это те функции, которые  предопределены в Python .
 В этом руководстве мы обсудим функции, определяемые пользователем.
 Преимущество функций в Python 
 Функции Python обладают следующими преимуществами.
 Используя функции, мы можем избежать повторной записи одной и той же логики / кода снова и снова в программе.
 Мы можем вызывать функции Python несколько раз в программе и в любом месте программы.
 Мы можем легко отслеживать большую программу Python, если она разделена на несколько функций.
 Возможность повторного использования - главное достижение функций Python.
 Однако вызов функции в программе Python всегда накладывает расходы.
 Создание функции 
 Python предоставляет ключевое слово  def  для определения функции. Синтаксис функции определения приведен ниже.
  Синтаксис: 
 def my_function (параметры):
 function_block
возвращаемое выражение
 Давайте разберемся с синтаксисом определения функций.
 Ключевое слово  def  вместе с именем функции используется для определения функции.
 Правило идентификатора должно следовать за именем функции.
 Функция принимает параметр (аргумент), и они могут быть необязательными.
 Функциональный блок начинается с двоеточия (:), и операторы блока должны иметь тот же отступ.
 Оператор возврата   используется для возврата значения. Функция может иметь только один возврат  
 Вызов функции 
 В Python после создания функции мы можем вызывать ее из другой функции.Перед вызовом функции должна быть определена функция; в противном случае интерпретатор Python выдает ошибку. Чтобы вызвать функцию, используйте имя функции, за которым следует круглые скобки.
 Рассмотрим следующий пример простого примера, который выводит сообщение «Hello World».
 # определение функции
def hello_world ():
 print ("привет, мир")
# вызов функции
Привет мир()
  Выход: 
 Заявление о возврате 
 Оператор return используется в конце функции и возвращает результат функции.Он завершает выполнение функции и передает результат туда, где функция вызывается. Оператор return не может использоваться вне функции.
  Синтаксис 
 вернуть [список_выражений]
 Он может содержать выражение, которое вычисляется, и значение возвращается вызывающей функции. Если оператор return не имеет выражения или не существует сам по себе в функции, он возвращает объект  None .
 Рассмотрим следующий пример:
 Пример 1 
 # Определение функции
def sum ():
 а = 10
 б = 20
 с = а + Ь
 вернуть c
# вызов функции sum () в операторе печати
print ("Сумма:", sum ())
  Выход: 
 В приведенном выше коде мы определили функцию с именем  sum, , и у нее есть оператор  c = a + b, , который вычисляет заданные значения, а результат возвращается оператором return вызывающей функции.
 Пример 2 Создание функции без оператора возврата 
 # Определение функции
def sum ():
 а = 10
 б = 20
 с = а + Ь
# вызов функции sum () в операторе печати
печать (сумма ())
  Выход: 
 В приведенном выше коде мы определили ту же функцию без оператора return, так как мы видим, что функция  sum ()  вернула объект  None  вызывающей функции.
 Аргументы в функции 
 Аргументы - это типы информации, которые могут быть переданы функции.Аргументы указаны в скобках. Мы можем передать любое количество аргументов, но они должны быть разделены запятой.
 Рассмотрим следующий пример, который содержит функцию, которая принимает строку в качестве аргумента.
 Пример 1 
 # определение функции
def func (имя):
 print ("Привет", имя)
# вызов функции
func ("Деванш")
  Выход: 
 Пример 2 
 # Функция Python для вычисления суммы двух переменных
# определение функции
def sum (a, b):
 вернуть a + b; 
# получение значений от пользователя
a = int (input ("Введите a:"))
b = int (input ("Введите b:")) 
# печать суммы a и b
print ("Sum =", sum (a, b))
  Выход: 
Введите a: 10
Введите b: 20
Сумма = 30
 
 Вызов по ссылке в Python 
 В Python вызов по ссылке означает передачу фактического значения в качестве аргумента функции.Все функции вызываются по ссылке, то есть все изменения, внесенные в ссылку внутри функции, возвращаются к исходному значению, на которое ссылается ссылка.
 Пример 1 Передача неизменяемого объекта (список) 
 # определение функции
def change_list (список1):
 list1.append (20)
 list1.append (30)
 print ("список внутри функции =", список1) 
# определение списка
список1 = [10,30,40,50] 
# вызов функции
change_list (список1)
print ("список за пределами функции =", список1)
  Выход: 
список внутри функции = [10, 30, 40, 50, 20, 30]
список вне функции = [10, 30, 40, 50, 20, 30]
 
 Пример 2 Передача изменяемого объекта (строки) 
 # определение функции
def change_string (str):
 str = str + "Как дела"
 print ("печать строки внутри функции:", str) 
string1 = "Привет, я здесь" 
# вызов функции
change_string (строка1) 
print ("печать строки вне функции:", строка1)
  Выход: 
печать строки внутри функции: Привет, я там Как ты
печать строки вне функции: Привет, я там
 
 Типы аргументов 
 Может быть несколько типов аргументов, которые могут быть переданы во время вызова функции.
 Обязательные аргументы
 Аргументы ключевого слова
 Аргументы по умолчанию
 Аргументы переменной длины
 Обязательные аргументы 
 До сих пор мы узнали о вызове функций в Python. Однако мы можем предоставить аргументы во время вызова функции. Что касается обязательных аргументов, это аргументы, которые необходимо передать во время вызова функции с точным совпадением их позиций в вызове функции и определении функции.Если какой-либо из аргументов не указан в вызове функции или положение аргументов изменено, интерпретатор Python покажет ошибку.
 Рассмотрим следующий пример.
  Пример 1 
 def func (имя):
 message = "Привет" + имя
 ответное сообщение
name = input ("Введите имя:")
печать (функция (имя))
  Выход: 
Введите имя: Джон
привет, Джон
 
  Пример 2 
 # функция simple_interest принимает три аргумента и соответственно возвращает простой процент
def simple_interest (p, t, r):
 возврат (п * т * г) / 100
p = float (input («Введите основную сумму?»))
r = float (input («Введите процентную ставку?»))
t = float (input («Введите время в годах?»))
print ("Простой интерес:", simple_interest (p, r, t))
  Выход: 
Введите основную сумму: 5000
Введите процентную ставку: 5
Введите время в годах: 3
Простой процент: 750.0
 
  Пример 3 
 # функция calculate возвращает сумму двух аргументов a и b
def вычислить (a, b):
 вернуть a + b
Calculate (10) # это вызывает ошибку, так как отсутствуют необходимые аргументы b.
  Выход: 
TypeError: calculate () отсутствует 1 обязательный позиционный аргумент: 'b'
 
 Аргументы по умолчанию 
 Python позволяет нам инициализировать аргументы в определении функции. Если значение любого из аргументов не предоставляется во время вызова функции, то этот аргумент может быть инициализирован значением, указанным в определении, даже если аргумент не указан при вызове функции.
  Пример 1 
 def printme (имя, возраст = 22):
 print ("Меня зовут", имя, "и возраст", возраст)
printme (name = "john")
  Выход: 
Меня зовут Джон, мне 22 года
 
  Пример 2 
 def printme (имя, возраст = 22):
 print ("Меня зовут", имя, "и возраст", возраст)
printme (name = "john") # переменная age не передается в функцию, однако в функции учитывается значение возраста по умолчанию
printme (age = 10, name = "David") # здесь перезаписывается значение возраста, 10 будет напечатано как возраст
  Выход: 
Меня зовут Джон, мне 22 года
Меня зовут Дэвид, мне 10 лет
 
 Аргументы переменной длины (* args) 
 В больших проектах иногда мы можем не знать количество аргументов, которые нужно передать заранее.В таких случаях Python предоставляет нам гибкость, предлагая значения, разделенные запятыми, которые внутренне обрабатываются как кортежи при вызове функции. Используя аргументы переменной длины, мы можем передавать любое количество аргументов.
 Однако при определении функции мы определяем аргумент переменной длины, используя  * args  (звездочка) как * <переменная - имя>.
 Рассмотрим следующий пример.
  Пример 
 def printme (* имена):
 print ("тип переданного аргумента", тип (имена))
 print ("печать переданных аргументов... ")
 для имени в именах:
 печать (имя)
printme («Джон», «Дэвид», «кузнец», «ник»)
  Выход: 
тип переданного аргумента - 
печать переданных аргументов ...
Джон
Дэйвид
кузнец
Ник
 
 В приведенном выше коде мы передали  * имен  в качестве аргумента переменной длины. Мы вызвали функцию и передали значения, которые внутри обрабатываются как кортежи. Кортеж - это итеративная последовательность, такая же, как и список. Чтобы распечатать заданные значения, мы повторили  * имена аргументов , используя цикл for.
 Аргументы ключевого слова (** kwargs) 
 Python позволяет нам вызывать функцию с ключевым словом arguments. Такой вызов функции позволит нам передавать аргументы в случайном порядке.
 Имя аргументов рассматривается как ключевые слова и сопоставляется при вызове и определении функции. Если такое же совпадение найдено, значения аргументов копируются в определение функции.
 Рассмотрим следующий пример.
  Пример 1 
 # функция func вызывается с именем и сообщением в качестве аргументов ключевого слова
def func (имя, сообщение):
 print ("печать сообщения с", имя, "и", сообщение) 
 #name и message копируются со значениями John и hello соответственно
 func (name = "John", message = "hello")
  Выход: 
печать сообщения с Джоном и привет
 
  Пример 2, предоставление значений в другом порядке по телефону 
 # Функция simple_interest (p, t, r) вызывается с ключевым словом arguments, порядок аргументов в этом случае не имеет значения
def simple_interest (p, t, r):
 возврат (п * т * г) / 100
print ("Простой интерес:", simple_interest (t = 10, r = 10, p = 1900))
  Выход: 
 Если мы укажем другое имя аргументов во время вызова функции, будет выдана ошибка.
 Рассмотрим следующий пример.
  Пример 3 
 # Функция simple_interest (p, t, r) вызывается с ключевым словом arguments.
def simple_interest (p, t, r):
 возврат (п * т * г) / 100  # не находит точное совпадение имени аргументов (ключевых слов)
print ("Простой процент:", simple_interest (время = 10, ставка = 10, принцип = 1900))
  Выход: 
TypeError: simple_interest () получил неожиданный аргумент ключевого слова 'время'
 
 Python позволяет нам предоставлять сочетание требуемых аргументов и аргументов ключевого слова во время вызова функции.Однако обязательный аргумент не должен указываться после аргумента ключевого слова, то есть, как только аргумент ключевого слова встречается в вызове функции, следующие аргументы также должны быть аргументами ключевого слова.
 Рассмотрим следующий пример.
  Пример 4 
 def func (имя1, сообщение, имя2):
 print ("печать сообщения с помощью", name1, ",", message, ", and", name2)
# первый аргумент не является аргументом ключевого слова
func ("Джон", message = "hello", name2 = "Дэвид")
  Выход: 
печать сообщения с Джоном, привет и Дэвидом
 
 Следующий пример вызовет ошибку из-за неправильного сочетания ключевого слова и требуемых аргументов, переданных в вызове функции.
  Пример 5 
 def func (имя1, сообщение, имя2):
 print ("печать сообщения с помощью", name1, ",", message, ", and", name2)
func ("Джон", message = "привет", "Дэвид")
  Выход: 
SyntaxError: позиционный аргумент следует за аргументом ключевого слова
 
 Python предоставляет возможность передавать несколько аргументов ключевого слова, которые могут быть представлены как  ** kwargs . Он похож на  * args , но сохраняет аргумент в формате словаря.
 Этот тип аргументов полезен, когда мы не знаем количество аргументов заранее.
 Рассмотрим следующий пример:
  Пример 6: Многие аргументы используют аргумент ключевого слова 
 def food (** kwargs):
 печать (kwargs)
еда (a = "яблоко")
еда (фрукты = "Апельсин", Vagitables = "Морковь")
  Выход: 
{'яблоко'}
{'Fruit': 'Апельсин', 'Vagitables': 'Морковь'}
 
 Объем переменных 
 Объем переменных зависит от места, где переменная объявляется.Переменная, объявленная в одной части программы, может быть недоступна для других частей.
 В Python переменные определены с двумя типами областей видимости.
 Глобальные переменные
 Локальные переменные
 Известно, что переменная, определенная вне любой функции, имеет глобальную область видимости, тогда как переменная, определенная внутри функции, имеет локальную область видимости.
 Рассмотрим следующий пример.
 Пример 1 Локальная переменная 
 def print_message ():
 message = "привет !! Я собираюсь распечатать сообщение."# сообщение переменной является локальным для самой функции
 печать (сообщение)
print_message ()
print (message) # это вызовет ошибку, поскольку локальная переменная здесь недоступна.
  Выход: 
Привет !! Я собираюсь распечатать сообщение.
  Файл "/root/PycharmProjects/PythonTest/Test1.py", строка 5, в
    печать (сообщение)
NameError: имя "сообщение" не определено
 
 Пример 2 Глобальная переменная 
 def вычислить (* args):
 сумма = 0
 для аргументов в аргументах:
 сумма = сумма + аргумент
 print ("Сумма равна", сумма)
сумма = 0
Calculate (10,20,30) # 60 будет напечатан как сумма
print ("Значение суммы вне функции:", sum) # 0 будет напечатано Вывод:
  Выход: 
Сумма 60
Значение суммы вне функции: 0
 
 .