Функция def python: def (функция/метод) в Python

Содержание

def (функция/метод) в Python

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

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

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

Функции без инструкции return (равно как и с нею, но без указания аргумента) всё равно возвращают результат — None.

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

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

Первой инструкцией в теле может быть литерал строки, который будет являться документацией для данной функции (строка документации — «docstring»). Некоторые утилиты и среды разработки используют такие строки для формирования интерактивной справки. Документировать код считается хорошим тоном.

def do_work(work, reverse=False):
"""Выполняет работу.
В случае удачного выполнения, возвращает True, 
иначе - False.
:param list work: Список для работы.
:param bool reverse: Флаг. Следует ли сделать 
работу в обратном порядке
:rtype: bool
"""

В примере выше объявляется функция do_work, с формальными параметрами work и reverse. Функция задокументирована (испольузется формат описания сигнатуры reStructuredText). Кроме строки документации тело функции не содержит инструкций, тем не менее функция возвращает None.

Определение функции описывает пользовательский «объект функции» и является исполняемой инструкцией. В ходе исполнения происходит связывание имени функции в текущем локальном пространстве имён (локальной символьной таблице) с «объектом функции» — обёрткой вокруг исполняемого кода функции. Объект функции содержит ссылку на текущее глобальное пространство имён, которое будет использовано при вызове функции. Объект функции может быть в последующем связан и с другим именем (это можно использовать для переименования функций и создания псевдонимов).

Само определение функции не вызывает исполнения кода из тела функции. Код исполняется только при вызове функции.

    def print_yes():
print('yes')
print_yes()  # yes
print_yes_alias = print_yes
print_yes_alias()  # yes

Более того, ничто не мешает использовать «объект функции» как любой другой объект (например: передавать в функцию, использовать в качестве значения в словаре и т.п.).

    def print_yes():
print('yes')
def print_no():
print('no')
my_functions = [print_yes, print_no]
for function in my_functions:
# Переменная function будет содержать объект 
# функции. Его-то мы и вызываем в следующей строке.
function()

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

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

    MY_GLOBAL = 1
def set_global_1():
MY_GLOBAL = 2
def set_global_2():
global MY_GLOBAL
MY_GLOBAL = 2
print(MY_GLOBAL)  # 1
set_global_1()
print(MY_GLOBAL)  # 1
set_global_2()
print(MY_GLOBAL)  # 2

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

В Питоне используется передача аргументов «по значению» (значением при этом всегда является ссылка на сам объект, но не на его значение). Однако, ввиду того, что в случаях, когда передаются изменяемые объекты, вызвавший увидит все изменения, сделанные вызываемым (например, при добавлении элементов в список), возможно лучше было бы назвать данный вид передачи «передачей по ссылке на объект».

    def mutate_list(a_list):
a_list.append(0)
return True
my_list = [1]
print(my_list)  # [1]
mutate_list(my_list)  # True
print(my_list)  # [1, 0]

Когда функция вызывает другую функцию, для вызова создаётся новая локальная символьная таблица.

Вложенные определения

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

    def outer_func():
# Определение функции внутри другой 
# функции.
def inner_func():
return 'some'
return inner_func()
print(outer_func())  # some
def get_my_class():
# Определение класса внутри определения
# функции.
class MyClass:
my_attr = 1
return MyClass
my_class = get_my_class()
print(my_class.my_attr)  # 1

Синонимы поиска: def (функция/метод), function, define, return, функции, procedure, вуа

#12 – Функции (def, lambda)

В Питоне есть множество встроенных функций. Мы со многими из них уже знакомились и теперь настало время изучить разработку своих собственных функций в Python. За урок мы научимся создавать функции и познакомимся с lambda выражениями.

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

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

Точно такая же ситуация обстоит с переменным. В классах переменные называются полями, а вне классов — переменными.

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

def some_test(): # Функция без параметров
	x = 23
	return x # Функция возвращает что-либо

def some_test_2(a, b, c): # Функция с 3 параметрами
	return a * b * c # Функция возвращает результат умножение чисел

def print_something(word, prefix): # Функция с 2 параметрами
	print (prefix, "-", word)
	pass # Функция ничего не возвращает

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

Функции могут возвращать другие функции, тем самым вызывая их. Чтобы обратиться к функции необходимо прописать её названи и передать параметры, если таковы имеются:

res = some_test_2 (2, 67, 12)

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

Анонимные функции

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

Пример создания «lambda» функции:

multiple = lambda a, b: a * b
multiple(7, 12)

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

Python def function: как вы указываете конец функции?

Я просто изучаю python и запутываюсь, когда «def» функции заканчивается?

Я вижу примеры кода, такие как:

def myfunc(a=4,b=6):
    sum = a + b
    return sum

myfunc()

Я знаю, что это не заканчивается из-за возврата (потому что я видел операторы if… if FOO than return BAR, else return FOOBAR). Откуда Python знает, что это не рекурсивная функция, которая сама себя вызывает? Когда функция запускается, она просто продолжает проходить через программу, пока не найдет возврат? Это привело бы к некоторым интересным ошибкам.

Спасибо

python

syntax

Поделиться

Источник


Dan    

15 октября 2009 в 16:32

8 ответов

  • какой метод получает контроль, когда вы выполняете поиск и не указываете android:launchMode= » singleTop»

    Я вызываю стандартный поиск, причем действие, вызывающее поиск, совпадает с действием, обрабатывающим поиск (‘searchable activity’). Если я включаю android:launchMode=singleTop в определение действия, поиск вызывает метод onNewIntent действия, и я выбираю указанный Парм поиска: нет проблем. Если…

  • def function python-помогите мне с синтаксисом

    Я новичок python, сейчас изучаю основы. Я пробовал следующие функции определение. Но это указывает на ошибку. Может ли кто-нибудь сказать мне, где я делаю ошибки в синтаксисе? (Я написал его с соответствующим отступом. но окно Stakoverflow не указывает, как я его вставляю) # This will test the…


68

В Python whitespace имеет значение. Функция завершается, когда отступ становится меньше (меньше).

def f():
    pass # first line
    pass # second line
pass # <-- less indentation, not part of function f.

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

def f(): pass

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

def f(): pass; pass

Три формы выше показывают, как конец функции определяется синтаксически . Что касается семантики , в Python есть три способа выхода из функции:

  • Используя оператор return . Это работает так же, как и в любом другом известном вам императивном языке программирования.

  • Используя оператор yield . Это означает, что функция является генератором. Объяснение его семантики выходит за рамки этого ответа. Посмотрите, может ли кто-нибудь объяснить мне утверждение python yield?

  • Просто выполнив последнее утверждение. Если больше нет операторов и последний оператор не является оператором return , то функция существует так, как если бы последний оператор был return None . То есть без явного оператора return функция возвращает None . Эта функция возвращает None :

    def f():
    pass

    И этот тоже:

    def f():
    42

Поделиться


Stephan202    

15 октября 2009 в 16:34


36

Python чувствителен к пробелу в отношении отступа. Как только уровень отступа возвращается к уровню, на котором определена функция, функция завершается.

Поделиться


fforw    

15 октября 2009 в 16:34


9

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

def foo():
    if bar:
        print "bar"

print "baz" # ends the if and foo at the same time

Уровень отступа равен less-than-or-equal как для def, так и для if, поэтому он завершает их оба.

Строки без утверждения, независимо от отступа, не имеют значения

def foo():
    print "The line below has no indentation"

    print "Still part of foo"

Но оператор, отмечающий конец блока, должен иметь отступ на том же уровне, что и любой существующий отступ. Таким образом, следующее является ошибкой:

def foo():
    print "Still correct"
   print "Error because there is no block at this indentation"

Как правило, если вы привыкли к языку фигурных скобок, просто сделайте отступ в коде, как они, и все будет в порядке.

BTW, «standard» способ отступа только с пробелами, но, конечно, возможна только вкладка, но, пожалуйста, не смешивайте их оба.

Поделиться


RichN    

15 октября 2009 в 16:52

  • Почему Python допускает функции def внутри for loop

    Я новичок в Python, но я попробовал кое-что, и это было двусмысленно для меня. Почему Python позволяет выполнять def функции внутри цикла ? и как я могу извлечь из этого пользу ? for i in range(2): def f(): print ‘f’ f()

  • Как вы указываете реферер http в golang?

    Используя стандарт http.Client, как вы создаете веб-запрос, который указывает реферер в заголовке запроса http? Ниже вы можете видеть, что можно установить заголовки, но как вы указываете реферер? Это просто установка заголовка реферера? req, err := http.NewRequest(GET, url, nil) if err != nil {…


4

Интересно, что если вы просто набираете в интерактивном интерпретаторе python, вы должны следовать функции с пустой строкой. Это не работает:

def foo(x):
  return x+1
print "last"

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

Поделиться


GaryO    

21 марта 2013 в 00:54


2

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

когда функция запускается, она продолжает работать до тех пор, пока не завершится или пока не будет обнаружен оператор return или yield . Если функция завершается без появления операторов return или yield , то None возвращается неявно.

в учебнике есть еще много информации .

Поделиться


SilentGhost    

15 октября 2009 в 16:34


1

Он использует отступы

 def func():
     funcbody
     if cond: 
         ifbody
     outofif

 outof_func

Поделиться


OscarRyz    

15 октября 2009 в 16:35


1

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

Поделиться


Mohan Gulati    

15 октября 2009 в 17:56


0

На мой взгляд, лучше явно отметить конец функции комментарием

def func():
     # funcbody
     ## end of subroutine func ##

Дело в том, что какая-то подпрограмма очень длинная и не удобно прокручивать редактор вверх, чтобы проверить, для какой функции она закончилась. Кроме того, если вы используете Sublime, вы можете щелкнуть правой кнопкой мыши -> goto Definition, и он автоматически перейдет к объявлению подпрограммы.

Поделиться


kstn    

13 декабря 2019 в 17:50

Похожие вопросы:

Перегруженные функции в файле def C++ DLL

Я пишу C/C++ DLL и хочу экспортировать определенные функции, которые я делал раньше, используя файл .def, подобный этому LIBRARY MyLib EXPORTS Foo Bar например, с кодом, определенным следующим…

Как вы указываете порядок полей ключа осколка в pymongo? (для mongodb)

Как вы указываете порядок полей ключа осколка в pymongo? (для mongodb) В принципе, pymongo позволял вам это делать: connection.admin.command(‘shardcollection’, ‘dbname.collname’, key =…

Как вы указываете бесконечность в StackExchange.Redis?

Redis позволяет указать положительную или отрицательную бесконечность в качестве аргументов диапазона, например, в следующем примере из ZCOUNT : ZCOUNT myzset -inf +inf Как вы указываете эти…

какой метод получает контроль, когда вы выполняете поиск и не указываете android:launchMode= » singleTop»

Я вызываю стандартный поиск, причем действие, вызывающее поиск, совпадает с действием, обрабатывающим поиск (‘searchable activity’). Если я включаю android:launchMode=singleTop в определение…

def function python-помогите мне с синтаксисом

Я новичок python, сейчас изучаю основы. Я пробовал следующие функции определение. Но это указывает на ошибку. Может ли кто-нибудь сказать мне, где я делаю ошибки в синтаксисе? (Я написал его с…

Почему Python допускает функции def внутри for loop

Я новичок в Python, но я попробовал кое-что, и это было двусмысленно для меня. Почему Python позволяет выполнять def функции внутри цикла ? и как я могу извлечь из этого пользу ? for i in range(2):…

Как вы указываете реферер http в golang?

Используя стандарт http.Client, как вы создаете веб-запрос, который указывает реферер в заголовке запроса http? Ниже вы можете видеть, что можно установить заголовки, но как вы указываете реферер?…

Python функция из другой функции def

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

Как вы указываете для CPLEX использовать только один поток в pyomo?

Как вы указываете для CPLEX использовать только один поток в pyomo? CPLEX по умолчанию использует до 32 потоков, ограниченных количеством процессоров. Но как вы определяете использование pyomo…

Напишите функцию lambda как def:-function

Я пытаюсь записать lambda-функцию в def:-function, чтобы лучше понять, что происходит в примере Python-скрипта, который я получил. В какой-то функции в этом скрипте интегрирована функция lambda, и…

Python 3: функции (def) — объявление и вызов

Вот мы с вами и
подошли к одному из фундаментальных моментов в изучении языка Python – функциям. Что
это такое? Смотрите. Например, уже знакомая вам функция

print()

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

Язык Python позволяет
программисту создавать свои собственные функции. Для этого используется
следующий синтаксис:

def <имя функции>([список аргументов]):

       оператор 1

       
оператор 2


       
…


        оператор
N

Здесь имя
функции придумывается программистом подобно именам переменных и, так как
функция – это определенное действие, то ее имя следует выбирать как глагол,
например:

go,
show, get, set и т.п.

Далее, идет набор
операторов, которые образуют тело функции. Именно они начинают
выполнятся при ее вызове.

Давайте зададим
простейшую функцию, которая будет выводить «hello» в консоль: 

def sayHello():
    print("hello")

Смотрите, мы
здесь придумали имя функции «sayHello», записали пустые круглые скобки
без аргументов и через двоеточие определили тело функции в виде конструкции print(«hello»). Но это
лишь определение функции. Самого вызова здесь еще нет и если запустить программу,
то ничего не произойдет.

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

Эти круглые
скобки являются оператором вызова функции с указанным именем. Теперь, при
запуске программы в консоли появится сообщение «hello».

Имя функции без
круглых скобок – это фактически ссылка на функцию:

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

тем самым
определить ее синоним и вызвать ее уже через это второе имя:

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

sayHello()
print("---------------")
sayHello()

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

«сначала нужно испечь пирог и только потом можно его есть.»

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

Если нужно
определить еще одну функцию, то мы ее можем записать после первой: 

def myAbs(x):
    x = -x if(x<0) else x

Имена функций
должны быть уникальными (также как и имена переменных), поэтому я назвал ее myAbs, т.к. функция abs уже существует.
И предполагаю, что она будет вычислять модуль переданного ей числа. Соответственно,
в круглых скобках обозначаю этот аргумент. Если теперь мы ее вызовем:

то увидим
значение None. Это произошло
потому, что функция myAbs явно не возвращает никакого значения.
По идее, мы ожидаем возврата переменной x. Для этого
нужно записать оператор return, после которого через пробел
указываем возвращаемую величину: 

def myAbs(x):
    x = -x if(x<0) else x
    return x

Теперь, при
вызове функции, получим ожидаемое значение 5. Как это в деталях работает?
Вызывая функцию с аргументом -5, переменная x начинает
ссылаться на этот числовой объект. Далее, выполняется тело функции и идет
проверка: если x<0, то x=-x (меняем знак
числа), иначе x не меняется.
Затем, выполняется оператор return и функция myAbs возвращает
вычисленное значение x.

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

print( myAbs(15) )
a = 100
print( myAbs(a) )

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

def myAbs(x):
    x = -x if(x<0) else x
    return x
    print(x)

То при вызове
этой функции:

Ничего в консоль
выведено не будет, т.к. вызов был завершен на операторе return. А вот если
поставить print до этого
оператора: 

def myAbs(x):
    x = -x if(x<0) else x
    print(x)
    return x

то мы увидим
значение 5.8. Используя эту особенность, можно определять такие функции: 

def isPositive(x):
    if x >=0:
        return True
    else:
        return False

В данном случае
мы будем получать значения True для
неотрицательных чисел и False – для
отрицательных. И далее, ее можно использовать так: 

p = []
for a in range(-5, 11):
    if isPositive(a):
        p.append(a)
 
print(p)

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

def isPositive(x):
    return x >=0

Здесь сам
оператор >= будет возвращать значение True или False.

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

def getSquare(w, h):
    return 2*(w+h)

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

Вызовем эту
функцию: 

p = getSquare(10, 5.5)
print(p)

И увидим
результат ее работы – значение 31,0. При этом, на первое значение 10 ссылается
первый аргумент w, а на второе 5.5 – второй аргумент h. Вот так можно
определять различное число аргументов у функций.

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

myAbs()
myAbs(1, 2)
sayHello("abc")

Здесь указано
или слишком много, или слишком мало фактических параметров.

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

def sayHello(msg, end="!"):
    print(msg+end)

И теперь, можно
вызвать эту функцию так:

или так:

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

def sayHello(end="!", msg):

приведет к
синтаксической ошибке.

Теперь, давайте
добавим этой функции еще один вот такой формальный параметр: 

def sayHello(msg, end="!", sep = ": "):
    print("Message"+sep+msg+end)

И функция будет
выводить сообщение в формате: «Message»+sep+msg+end. Вызвать эту
функцию мы можем таким образом: 

sayHello("Hello", "?", " ")

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

sayHello("Hello", sep=" ")

Мы здесь вторым
аргументом явно указываем имя формального параметра и присваиваем ему желаемое
значение. В результате аргументы msg и sep будут принимать
переданные значения, а аргумент end – значение по умолчанию. Это называется
именованные параметры, когда мы указываем не просто значение, но еще и
имя параметра.

Если нам
требуется сразу вернуть несколько значений, то это можно сделать так.
Предположим наша функция будет сразу определять и периметр и площадь
прямоугольника: 

def perAndSq(w, h):
    return 2*(w+h), w*h

И, далее,
вызываем ее: 

res = perAndSq(2.3, 5)
print(res)

получаем
результат в виде кортежа из двух чисел. Или, так: 

per, sq = perAndSq(2.3, 5)
print(per, sq)

Аналогичным
образом можно возвращать и списки и словари и вообще любые типы данных.

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

def myPow(x, n):
    sx = 1
    while n > 0:
        sx *= x
        n -= 1
    return sx

И, затем,
вызвать ее:

Интересной
особенностью Python в определении
функций является возможность переопределять уже существующие функции. Например,
у нас задана вот такая функция: 

def sayHello():
    print("hello")

Тогда ниже мы
можем ее переопределить, если укажем то же самое имя: 

def sayHello():
    print("------- hello --------")

Теперь, при ее
вызове:

увидим
выполнение последнего, переопределенного варианта. Если дальше ее
переопределить вот так: 

def sayHello(msg):
    print(msg)

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

sayHello("привет мир")

Когда это может
пригодиться на практике? Например, если мы хотим определить некоторую функцию в
зависимости от условия: 

TYPE_FUNC = True
 
if TYPE_FUNC:
    def sayHello():
        print("hello")
else:
    def sayHello(msg):
        print(msg)
 
sayHello()

Здесь при
значении переменной TYPE_FUNC равной True будет определен
первый вариант функции, а иначе – второй вариант. Иногда это бывает полезно.

Элементы функционального подохда к программированию

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

def max2(a, b):
    if a > b:
        return a
    return b

И вызвать мы ее
можем так:

Затем, нам
потребовалась функция, которая бы находила максимальное из трех чисел. Как ее
можно реализовать? Используя идею функционального программирования, это можно
сделать следующим образом: 

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

И вызвать так:

Смотрите, здесь
оператор return возвращает
значение, которое возвращает функция max2. Но, прежде чем она будет
выполнена, вызовется другая функция max2, которая определит максимальное
среди чисел b и c. То есть,
прежде чем вызвать первую функцию max2 необходимо вычислить ее
параметры: первый просто берется их x, а второй вычисляется вложенной
функцией max2. Вот так это
работает и вот что из себя представляет элемент функционального подхода к
программированию.

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

print( max3("ab", "cd", "abc") )

так как строки
могут спокойно сравниваться между собой. И вообще, любые величины, которые
можно сравнивать на больше и меньше, можно подставлять в качестве аргументов
функции max3 и max2.

Задания для самоподготовки

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

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

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

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

Параметры по умолчанию | Python

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

Например, функция parent_for(), которую вы использовали в некоторых упражнениях, принимает имя ребёнка первым аргументом, а вторым — строку 'mother' или 'father'. Второй аргумент — необязательный, и если не указывать его, то автоматически по умолчанию будет использоваться 'mother'.

Эти два вызова равнозначны:

parent_for('Jon Snow')
parent_for('Jon Snow', 'mother')

Каким образом там сделаны аргументы по умолчанию? Давайте заглянем в определение этой функции:

def parent_for(child_name, parent_name='mother'):
    # какой-то код

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

Второй аргумент указан со значением в формате аргумент=какое_то_значение. Точно так же, как при создании переменной. Этот фрагмент =какое_то_значение делает аргумент необязательным, и задаёт ему значение по умолчанию.

Аргументов по умолчанию может быть любое количество, но все они должны быть в конце списка аргументов. То есть такие строчки кода синтаксически некорректны:

  • def parent_for(child_name='Jon', who):
  • def calculate(a, b=90, c):
  • def get_prices(code=4161, quantity, place):

Задание

Реализуйте функцию custom_parent_for(), которая принимает два аргумента:

  1. Строку — имя ребёнка.
  2. Строку с указанием родителя. Этот аргумент должен по умолчанию быть 'father'.

Функция должна возвращать имя соответствующего родителя.

Пример вызова:

custom_parent_for('Cersei Lannister')  # Tywin Lannister

Такой вызов вернёт имя отца.

  • Используйте готовую функцию parent_for() внутри своей функции.
  • Не нужно вызывать свою функцию custom_parent_for(), только определить её.

Функции и методы в Python: передача функции в функцию. Декоратор

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

Что надо знать о методах и функциях в Python?

Говоря о функциях в Python, нужно упомянуть два аспекта:
1) функция в Python — есть объект специального вида, который можно передавать в виде аргумента другим функциям;
2) внутри функций в Python вы можете создавать другие функции, а также вызывать их, возвращая результат посредством return.

Теперь давайте поговорим об этом подробнее.

Функция как объект в Python

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

>>> # исходный список
>>> a = [1, 2, 3, 4, 5]
>>> # функция, которая возводит в квадрат переданное ей число 
>>> sq = lambda x: x**2
>>> # проверка работы функции в Python
>>> print(sq(5))
25

>>> # получение списка квадратов
>>> b = list(map(sq, a))
>>> print(b)
[1, 4, 9, 16, 25]

В нашем примере мы передали функции map в виде первого аргумента функцию sq. Последняя будет по очереди применяться ко всем элементам нашего списка a.
Кроме того, в Python функция является специальным объектом, имеющим метод __call__(). Представьте, что мы создали следующий класс:
class DemoCall():
def __call__(self):
return "Hello!"

Объект такого класса в Python мы сможем вызывать как функцию:
>>> hello = DemoCall()
>>> hello()
'Hello!'

Функция внутри функции в Python
Функции в Python мы можем создавать, вызывать и возвращать из других функций. Кстати, на этом основана идея замыкания (closures) в Python.
Давайте создадим функцию, умножающую 2 числа:
def mul(a):
def helper(b):
return a * b
return helper

В этой функции в Python реализованы два важных свойства:
 1)  внутри функции mul() мы создаём ещё одну функцию helper();
 2)  функция mul() возвращает нам функцию helper() в качестве результата работы.
Вызов этой функции в Python:
Особенность заключается в том, что мы можем создавать на базе функции mul() собственные кастомизированные функции. Давайте создадим функцию в Python, умножающую на 3:
>>>three_mul = mul(3)
>>>three_mul(5)
15

В результате была построена функция three_mul(), умножающая на 3 любое переданное ей число.
Декоратор функции в Python
Конструктивно речь идёт о некоторой функции, в качестве аргумента которого выступает другая функция. Декоратор в Python добавляет дополнительный функционал к функции, не меняя её содержимое.
Создание
Представьте, что мы имеем пару простых функций в Python:
def first_test():
print("Test function 1")

def second_test():
print("Test function 2")

При этом мы желаем их дополнить таким образом, чтобы перед вызовом основного кода нашей функции печаталась строчка “Start function”, а в конце – строка “Stop function”.
Реализовать поставленную задачу можно несколькими методами. Во-первых, мы можем добавить необходимые строки в конец и начало каждой функции. Но вряд ли это удобно, ведь если мы пожелаем их убрать, придётся модифицировать тело функции.
Теперь поговорим о втором пути. Для начала создадим функцию:
def simple_decore(fn):
def wrapper():
print("Start function")
fn()
print("Stop function")
return wrapper

Теперь нужно обернуть функции в оболочку:
first_test_wrapped = simple_decore(first_test)
second_test_wrapped = simple_decore(second_test)

Обратите внимание, что функции first_test и second_test не поменялись.
>>> first_test()
Test function 1
>>> second_test()
Test function 2

Наши функции second_test_wrapped и first_test_wrapped обладают функционалом, который нам и нужен.
>>> first_test_wrapped()
Start function
Test function 1
Stop function
>>> first_test_wrapped()
Start function
Test function 1
Stop function

Теперь, если надо, чтобы так работали функции с именами first_test и second_test, делаем следующее:
first_test = first_test_wrapped
second_test = second_test_wrapped

Проверяем:
>>> first_test()
Start function
Test function 1
Stop function
>>> second_test()
Start function
Test function 2
Stop function

Выполненные нами действия и являются реализацией идеи декоратора.
Правда, вместо строк:
def first_test():
print("Test function 1")
first_test_wrapped = simple_decore(first_test)
first_test = first_test_wrapped 

мы можем написать иначе:
@simple_decore
def first_test():
print("Test function 1")

В нашем случае @simple_decore – это не что иное, как декоратор функции.
Передаём аргументы в функцию с помощью декоратора
Бывает, что функция требует наличие аргумента, поэтому мы можем передать его через декоратор. Давайте создадим декоратор, принимающий аргумент и выводящий информацию о декорируемой нами функции и её аргументе.
def param_transfer(fn):
def wrapper(arg):
print("Start function: " + str(fn.__name__) + "(), with param: " + str(arg))
fn(arg)
return wrapper

Чтобы продемонстрировать работу, создадим функцию, выводящую квадратный корень переданного ей числа, а в качестве декоратора, укажем созданный param_transfer:
@param_transfer
def print_sqrt(num):
print(num**0.5)

Теперь давайте выполним данную функцию с аргументом 4:
>>> print_sqrt(4)
Start function: print_sqrt(), with param: 4
2.0

Декораторы для методов класса в Python
С декоратором можно объявлять и методы классов. Давайте выполним модификацию декоратора param_transfer:
def method_decor(fn):
def wrapper(self):
print("Start method: " + str(fn.__name__))
fn(self)
return wrapper

Теперь приступим к созданию класса для представления 2-мерного вектора (математического). В классе определим метод norm(), выводящий модуль вектора.
class Vector():
def __init__(self, px = 0, py = 0):
self.px = px
self.py = py

@method_decor
def norm(self):
print((self.px**2 + self.py**2)**0.5)

Что же, осталось продемонстрировать работу нашего метода:
>>> vc = Vector(px=10, py=5)
>>> vc.norm()
Start method: norm
11.180339887498949

Возвращаем результат работы функции через декоратор
Зачастую создаваемые функции выполняют возвращение какого-либо значения. Чтобы это стало возможным осуществить через декоратор, нужно специальным образом построить нашу внутреннюю функцию:
def decor_with_return(fn):
def wrapper(*args, **kwargs):
print("Start method: " + str(fn.__name__))
return fn(*args, **kwargs)
return wrapper

Возможно применение этого декоратора и для оборачивания функций, принимающих различные аргументы и возвращающие значение:
@decor_with_return
def calc_sqrt(val):
return val**0.5

Осталось выполнить функцию calc_sqrt() с параметром 16:
>>> tmp = calc_sqrt(16)
Start method: calc_sqrt
>>> print(tmp)

Функции в Python, определение функций.
Функции в Python определяются с помощью инструкции def, которое вводит определение функции. За ним должно следовать имя функции и заключенный в скобки список формальных параметров аргументов. Операторы, которые формируют тело функции, начинаются со следующей строки и должны иметь отступ.
def func_name(param):
    pass

  • func_name — идентификатор, то есть переменная, которая при выполнении инструкции def связывается со значением в виде объекта функции.
  • param — это необязательный список формальных параметров аргументов, которые связываются со значениями, предоставляемыми при вызове функции. В простейшем случае функция может вообще не иметь параметров. Это означает, что при ее вызове она не получает никаких аргументов. В определении такой функций круглые скобки после ее имени остаются пустыми, такими же они должны оставаться при ее вызове.
Первым оператором тела функции может быть строка документации функции. Существуют инструменты, которые используют строки документации для автоматического создания интерактивной или печатной документации или для предоставления пользователю интерактивного просмотра кода. Хорошей практикой является включение строк документации в код.
Определение функции — это исполняемый оператор. Его выполнение связывает имя функции в текущем локальном пространстве имен с объектом функции (оболочка вокруг исполняемого кода функции). Этот объект функции содержит ссылку на текущее глобальное пространство имен, которое будет использоваться при вызове функции.
Определение функции не выполняет тело функции, а только вычисляет аргументы, если они присутствуют. Тело функции выполняется только при вызове.
# Определим функцию, которая печатает список чисел ряда Фибоначчи до n
>>> def fib(n):
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=' ')
...         a, b = b, a+b
...     print()
...
>>> # Вызов функции
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

При вызове функции создается область видимости для хранения локальных переменных этой функции и все созданные переменные внутри функции сохраняют свое значение только в этом пространство имен. Когда функция завершает выполнение, это пространство имен уничтожается.
Определение функции может быть заключено в одно или несколько выражений-декоратора. Выражения-декораторы оцениваются при определении функции в области, содержащей определение функции. Результатом должен быть вызываемый объект, который вызывается с объектом функции в качестве единственного аргумента. Возвращаемое значение привязывается к имени функции, а не к объекту функции. Несколько декораторов применяются вложенным образом. Например, следующий код
@f1(arg)
@f2
def func(): pass

# Примерно эквивалентен

def func(): pass
func = f1(arg)(f2(func))

Эти два выражения эквивалентны за исключением того, что исходная функция временно не привязана к имени func.
Когда один или несколько параметров имеют выражение parameter=expression, говорят, что функция имеет значения параметров по умолчанию. Для параметра со значением по умолчанию, соответствующий аргумент может быть опущен в вызове. Если параметр имеет значение по умолчанию, то все последующие параметры также должны иметь значение по умолчанию — это синтаксическое ограничение.
Значения параметров по умолчанию оцениваются слева направо при определении функции. Это означает, что эти выражение вычисляется один раз, когда функция определена, и что для каждого вызова используется одно и то же предварительно вычисленное значение. Это особенно важно понимать, когда параметр по умолчанию является изменяемым объектом, таким как список или словарь
Семантика вызова функций более подробно описана в разделе «Что происходит в момент вызова функции?». Вызов функции всегда присваивает значения всем параметрам, упомянутым в списке параметров, либо из позиционных аргументов, из ключевых аргументов, либо из значений по умолчанию. Если присутствует форма *identifier, то она инициализируется кортежем, которая получает любые избыточные позиционные параметры, по умолчанию — пустой кортеж. Если присутствует форма **identifier, то она инициализируется новым упорядоченным словарем, получающим любые избыточные ключевые аргументы, по умолчанию используется новый пустой словарь.
Параметры аргументов, следующие после * или *identifier являются параметрами только ключевых слов и могут быть переданы только в качестве ключевых аргументов (более подробно в разделе «Варианты передачи аргументов в функцию Python»).
Параметры могут иметь аннотацию типов в форме :expression после имени аргумента. Любой параметр может иметь аннотацию, даже в форме *identifier или **identifier. Функции могут иметь аннотацию возвращаемого значения в форме -> expression, которое следует после списка параметров. Эти аннотации могут быть любым допустимым выражением Python. Наличие аннотаций не меняет семантику функции. Значения аннотации доступны в виде значений словаря с ключами по именам параметров в атрибуте объекта функции __annotations__ и оцениваются при выполнении определения функции. Если используется импорт аннотаций из __future__, то аннотации сохраняются в виде строк во время выполнения, что позволяет отложить оценку. В этом случае аннотации могут оцениваться в другом порядке, чем они появляются в исходном коде.
Также возможно создавать анонимные функции (функции, не привязанные к имени) для немедленного использования в выражениях. Здесь используются лямбда-выражения, описанные в разделе «Анонимные функции (lambda-выражения) в Python». Обратите внимание, что лямбда-выражение — это просто сокращение для упрощенного определения функции. Функция, определенная в операторе def, может быть передана или присвоена другому имени, как функция, определенная лямбда-выражением. Форма def на самом деле более мощная, так как она позволяет выполнять несколько операторов и аннотаций.
Примечание для программиста: Функции Python — это объекты первого класса. Оператор def, выполняемый внутри определения функции, определяет локальную функцию, которая может быть возвращена или передана. Свободные переменные, используемые во вложенной функции, могут обращаться к локальным переменным функции, содержащей def. Подробнее смотрите в раздел Именование и привязка.
Так как функции в Python являются объектами первого класса, то значение имени функции имеет тип, который распознается интерпретатором как определяемая пользователем функция. Это значение может быть присвоено другому имени, которое затем может также использоваться как функция:
>>> fib
<function fib at 10042ed0>
>>> f = fib 
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89
>>>

Исходя из других языков, можно возразить, что fib это не функция, а процедура, поскольку она не возвращает значение. На самом деле, даже функции без оператора return возвращают значение, хотя и довольно скучное. Это значение называется None (встроенное имя). Вывод значения None обычно подавляется интерпретатором, если это единственное возвращаемое значение. Вы можете увидеть это, используя команду print():
>>> fib(0)
>>> print(fib(0))
None
>>>

Функция, которая возвращает список чисел ряда Фибоначчи, вместо того, чтобы печатать его:
>>> def fib2(n):  # возврат ряда Фибоначчи до n
...     """Возвращает список, содержащий ряд Фибоначчи до n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # вызов функции
>>> f100
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>

Этот пример, демонстрирует некоторые новые возможности Python:
  • Оператор return возвращает значение из функции. return без аргумента возвращает None. Функции, у которых return не определен, также возвращает None.
  • Оператор result.append(a) вызывает метод объекта списка result. Метод — это функция, которая «принадлежит» объекту и имеет имя obj.methodname, где obj есть некоторый объект (может быть выражение), и methodname имя метода, которое определяется типом объекта. Разные типы определяют разные методы. Методы разных типов могут иметь одно и то же имя, не вызывая двусмысленности. Можно определить свои собственные типы объектов и методы, используя классы. Метод append(), показанный в примере, определен для объектов списка. Он добавляет новый элемент в конец списка.
Определение функции
 в Python. Определение функций в Python | Садрах Пьер, доктор философии 
 В компьютерном программировании функция — это именованный раздел кода, который выполняет определенную задачу. Обычно это включает ввод некоторого ввода, манипулирование вводом и возврат вывода. В этом посте мы рассмотрим, как определять функции Python, как указывать функции, которые могут принимать произвольное количество позиционных аргументов, и как определять функции, которые могут принимать произвольное количество аргументов ключевого слова.
 Приступим!
 Для начала давайте определим функцию, которая принимает два аргумента, в данном случае два числа, и возвращает сумму:
 def sum_function (first, second): 
 return (first + second) 
 Давайте протестируем нашу функцию с числа 5 и 10:
 print ("Sum:", sum_function (5, 10)) 
 Это дает ожидаемый результат. Мы также можем использовать выражение звезды в Python для передачи произвольного количества аргументов. Например, мы можем определить новую функцию:
 def sum_arbitrary_arguments (first, * rest): 
 return (first + sum (rest)) 
 Назовем эту функцию с числами 5, 10 и 15:
 print ( «Сумма с произвольным числом аргументов:», sum_arbitrary_arguments (5, 10,15)) 
 Мы можем вызывать эту функцию с любым количеством позиционных аргументов.Давайте вызовем функцию с 5, 10, 15, 20, 25 и 30:
 print («Сумма с произвольным числом аргументов:», sum_arbitrary_arguments (5, 10,15, 20, 25, 30)) 
 Это дает правильное значение суммы. Мы также можем указать функцию с аргументами ключевого слова по умолчанию. Например, рассмотрим функцию, которая по умолчанию печатает погоду в Нью-Йорке:
 def print_weather (name, state = "New York", temp = "30 градусов Цельсия"): 
 print ("Привет {}, это {} in {} ". format (name, temp, state)) 
 Если мы вызовем функцию с» Sarah «:
 print_weather (" Sarah ") 
 Мы также можем перезаписать значения по умолчанию:
 print_weather (" Mike "," Бостон "," 28 градусов Цельсия ") 
 Мы также можем написать функцию, которая принимает произвольное количество аргументов ключевого слова, используя выражение ‘**’.Давайте сделаем это для отчетов о погоде:
 def print_weather_kwargs (** kwargs): 
 weather_report = "" 
 для аргумента в kwargs.values ​​(): 
 weather_report + = аргумент 
 return weather_report 
 Затем мы определим переменную ‘kwargs’ , для аргументов ключевого слова в качестве словаря и передайте его в нашу функцию:
 kwargs = {'temp': "30 градусов Цельсия", 'in': 'in', 'State': "New York", 'when' : 'today'} 
 print (print_weather_kwargs (** kwargs)) 
 Я остановлюсь на этом, но я рекомендую вам поиграть с кодом самостоятельно.
 ВЫВОДЫ 
 Подводя итог, в этом посте мы обсудили, как работать с функциями в python. Сначала мы определили простую функцию, которая позволяет нам найти сумму двух чисел, затем мы показали, что мы можем использовать выражение в виде звезды для определения функции, которая может принимать произвольное количество позиционных аргументов. Далее мы показали, как определить функцию с ключевыми аргументами. Наконец, мы показали, как определить функцию, которая может принимать произвольное количество аргументов ключевого слова. Надеюсь, вы нашли этот пост полезным / интересным.Код из этого поста доступен на GitHub. Спасибо за чтение!
 Python 3 Примечания: Пользовательские функции 
На этой странице: def, return, docstrings, help (), функции возврата значения и void
 Функции: основы 
Давайте откажемся от старой алгебры. Вы выучили «функции» примерно так: 
  f (x) = x  2  + 1 
 
 В Python определение функции работает следующим образом. def — ключевое слово для определения функции.За именем функции следует параметр (ы) в (). Двоеточие: означает начало тела функции, которое отмечено отступом. Внутри тела функции оператор return определяет возвращаемое значение. После завершения определения функции вызов функции с аргументом возвращает значение.
>>> def f (x):
        возврат x ** 2 + 1

>>> f (4)
17
>>>
 
Попробуем другую функцию.Ниже приведена функция, которая принимает глагол (надеюсь) и возвращает герундийную форму:
>>> def get_ing (wd):
        вернуть wd + 'ing'

>>> get_ing ('прогулка')
'ходьба'
>>>
 
 Несколько параметров, строка документации 
Ниже представлена ​​чуть более сложная функция. Он принимает два аргумента, имеет условное выражение в теле функции и начинается со строки:
>>> def same_initial (wd1, wd2):
        "" "Проверяет, начинаются ли два слова с одного и того же символа,
        и возвращает True / False.Различие в регистре игнорируется.
        если wd1 [0] .lower () == wd2 [0] .lower ():
            вернуть True
        еще:
            вернуть ложь

>>> same_initial ('яблоко', 'апельсин')
Ложь
>>> same_initial ('Энни', 'яблоко')
Правда
>>>
 
Строка «» «Проверяет, если …» «» называется « docstring «. Размещенный в самом верху тела функции, он действует как документация по функции. Эта строка распечатывается, когда вы вызываете help () для функции:
>>> справка (same_initial)
Справка по функции same_initial в модуле __main__:

same_initial (wd1, wd2)
    Проверяет, начинаются ли два слова с одного и того же символа,
    и возвращает True / False.Различие в регистре игнорируется.
>>>
 
Вот еще один пример. Эта функция возвращает список символов, общих для двух строк. (Было бы лучше, если бы не было дубликатов. Можно улучшить?)
>>> def in_both (wd1, wd2):
        «Принимает две строки, возвращает отсортированный список общих символов»
        common = []
        для c в wd1:
            если c в wd2:
                общий.добавить (с)
        вернуть отсортированный (обычный)

>>> in_both ('груша', 'яблоко')
['a', 'e', ​​'p']
>>> in_both ('лингвистика', 'экономика')
['c', 'i', 'i', 'i', 'n', 's', 's']
>>>
 
 Функции: возврат или аннулирование 
Вы можете подумать: «Погодите минутку, я не видел никакого оператора возврата в учебнике по определению функций». Вы правы — определенная Эд функция get_legal () не включала никакого оператора возврата, а только набор функций печати.В Python можно составить функцию без оператора возврата. Такие функции называются  void , и они возвращают None, специальный объект Python «ничего». Вот пример функции void:
>>> def sayhello (кто):
        print ('Привет,', кто + '!')
        print ('Какой прекрасный день.')

>>> Sayhello ('Акбар')
Привет, Акбар!
Какой прекрасный день.
>>>
 
Хорошо, тогда чем отличаются функции void и функции типа «return»? Хороший вопрос.Позвольте мне проиллюстрировать это на примерах. Вот функция get_ing (), определенная выше, и ее недействительный аналог print_ing ():
>>> def get_ing (wd):
        вернуть wd + 'ing'

>>> def print_ing (wd):
        печать (wd + 'ing')

 
Вызывая две функции, вы сначала замечаете небольшую разницу в выводе. Возвращающая функция дает вам строку (примечание »), а функция печати показывает напечатанный вывод строки — обратите внимание на отсутствие кавычек.Обратите внимание, что возвращаемое значение отображается только в интерактивной среде оболочки; в сценарии только команды печати приводят к отображению вывода.
>>> get_ing ('интерес')
'интересно'
>>> print_ing ('интерес')
интересно
>>>
 
Теперь, поскольку get_ing () возвращает значение, его можно скопировать в переменную с помощью оператора присваивания. Попробуйте сделать то же самое с print_ing (), и вы столкнетесь с непредвиденными последствиями: печать происходит после оператора присваивания, и вы не получаете ничего в качестве значения переменной, потому что эта функция, будучи недействительной, ничего не возвращает.
>>> foo = get_ing ('интерес')
>>> фу
'интересно'
>>> faa = print_ing ('интерес')
интересно
>>> фаа
>>>
 
Кроме того, функцию, возвращающую значение, можно подключить прямо к другой функции. Опять же, поскольку функции void ничего не возвращают, они не могут. Ниже get_ing (‘eat’) передается функции len () для успешного результата. С помощью len (print_ing (‘eat’)) печать происходит независимо, а затем возникает ошибка типа:
>>> len (get_ing ('есть'))
6
>>> len (print_ing ('есть'))
принимать пищу

Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    len (print_ing ('есть'))
TypeError: объект типа NoneType не имеет len ()
 
Наконец, если вам нужна печать, ее также можно выполнить с помощью функции возврата значения: просто используйте с ней оператор печати.
>>> print (get_ing ('интерес'))
интересно
>>> print_ing ('интерес')
интересно
>>>
 
Это заняло некоторое время, но я надеюсь, что теперь вы ясно видите фундаментальные различия между двумя типами функций. По правде говоря, функции возвращаемого типа гораздо более функциональны и полезны. В других языках функции типа void даже не называются функциями — вместо этого они называются процедурами.
 Как писать функции Python 
  Функция Python — это группа кода. Чтобы запустить код в функции, вы должны вызвать функцию. Функция может быть вызвана из любого места после определения функции. Функции могут возвращать значение с помощью оператора return. 
 Найди свой матч на тренировочном лагере
  •