Как получить текстовое название функции python

Функция может принимать параметры. Через параметры в функцию можно передавать данные. Банальный пример — функция print() , которая с помощью параметра принимает значение, выводимое на консоль.

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

def say_hello(name): print(f"Hello, ") say_hello("Tom") say_hello("Bob") say_hello("Alice")

Функция say_hello имеет параметр name, и при вызове функции мы можем передать этому параметру какой-либо значение. Внутри функции мы можем использовать параметр как обычную переменную, например, вывести значение этого параметра на консоль функцией print. Так, в выражении:

say_hello("Tom")

Строка «Tom» будет передаваться параметру name. В итоге при выполнении программы мы получим следующий консольный вывод:

Hello, Tom Hello, Bob Hello, Alice

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

def print_person(name, age): print(f"Name: ") print(f"Age: ") print_person("Tom", 37)

Здесь функция print_person принимает два параметра: name и age. При вызове функции:

print_person("Tom", 37)

Первое значение — «Tom» передается первому параметру, то есть параметру name . Второе значение — 37 передается второму параметру — age. И внутри функции значения параметров выводятся на консоль:

Name: Tom Age: 37

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

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

def say_hello(name="Tom"): print(f"Hello, ") say_hello() # здесь параметр name будет иметь значение "Tom" say_hello("Bob") # здесь name = "Bob"

Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть строка «Tom». Консольный вывод данной программы:

Hello, Tom Hello, Bob

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

def print_person(name, age = 18): print(f"Name: Age: ") print_person("Bob") print_person("Tom", 37)

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

При необходимости мы можем сделать все параметры необязательными:

def print_person(name = "Tom", age = 18): print(f"Name: Age: ") print_person() # Name: Tom Age: 18 print_person("Bob") # Name: Bob Age: 18 print_person("Sam", 37) # Name: Sam Age: 37

Передача значений параметрам по имени. Именованные параметры

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

def print_person(name, age): print(f"Name: Age: ") print_person(age = 22, name = "Tom")

В данном случае значения параметрам age и name передаются по имени. И несмотря на то, что параметр name идет первым в определении функции, мы можем при вызове функции написать print_person(age = 22, name = «Tom») и таким образом передать число 22 параметру age, а строку «Tom» параметру name.

Символ * позволяет установить, какие параметры будут именнованными — то есть такие параметры, которым можно передать значения только по имени. Все параметры, которые располагаются справа от символа * , получают значения только по имени :

def print_person(name, *, age, company): print(f"Name: Age: Company: ") print_person("Bob", age = 41, company ="Microsoft") # Name: Bob Age: 41 company: Microsoft

В данном случае параметры age и company являются именнованными.

Можно сделать все параметры именнованными, поставив перед списком параметров символ *:

def print_person(*, name, age, company): print(f"Name: Age: Company: ")

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

def print_person(name, /, age, company="Microsoft"): print(f"Name: Age: Company: ") print_person("Tom", company="JetBrains", age = 24) # Name: Tom Age: 24 company: JetBrains print_person("Bob", 41) # Name: Bob Age: 41 company: Microsoft

В данном случае параметр name является позиционным.

Для одной функции можно определять одновременно позиционные и именнованные параметры.

def print_person(name, /, age = 18, *, company): print(f"Name: Age: Company: ") print_person("Sam", company ="Google") # Name: Sam Age: 18 company: Google print_person("Tom", 37, company ="JetBrains") # Name: Tom Age: 37 company: JetBrains print_person("Bob", company ="Microsoft", age = 42) # Name: Bob Age: 42 company: Microsoft

В данном случае параметр name располагается слева от символа /, поэтому является позиционным и обязательным — ему можно передать значение только по позиции.

Параметр company является именнованным, так как располагается справа от символа *. Параметр age может получать значение по имени и по позиции.

Неопределенное количество параметров

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

def sum(*numbers): result = 0 for n in numbers: result += n print(f"sum = ") sum(1, 2, 3, 4, 5) # sum = 15 sum(3, 4, 5, 6) # sum = 18

В данном случае функция sum принимает один параметр — *numbers , но звездочка перед названием параметра указывает, что фактически на место этого параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору, получить каждое значение из этого набора в переменную n и произвести с ним какие-нибудь действия. Например, в данном случае вычисляется сумма переданных чисел.

3. Функции¶

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

В Python функция определяется так:

def имя(список параметров): предложения

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

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

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

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

Первые две функции, которые мы напишем, не имеют параметров.

def new_line(): print

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

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

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

print "First Line." new_line() print "Second Line."

Эта программа выводит:

First line. Second line.

Дополнительное пространство между двумя строками — это результат вызова функции new_line() . А что если нам понадобится больше свободного места между строками? В таком случае мы могли бы вызвать одну и ту же функцию несколько раз:

print "First Line." new_line() new_line() new_line() print "Second Line."

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

def three_lines(): new_line() new_line() new_line() print "First Line." three_lines() print "Second Line."

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

Стоит заметить несколько вещей в связи с этой программой:

Одну и ту же функцию можно вызывать многократно. Так обычно и происходит.
Одна функция может вызывать другую; в нашем примере three_lines вызывает new_line .

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

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

Соберем вместе фрагменты кода из этого раздела в скрипт tryme1.py :

def new_line(): print def three_lines(): new_line() new_line() new_line() print "First Line." three_lines() print "Second Line."

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

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

3.2. Поток выполнения¶

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

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

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

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

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

Но Python точно “знает”, откуда вызвана текущая выполняемая функция, так что каждый раз, когда функция завершается, программа продолжается с того места, где она была перед вызовом функции. Когда достигнут конец программы, она завершается.

В чем здесь мораль? Когда читаете программу, не читайте ее просто сверху вниз. Следуйте за потоком выполнения.

3.3. Параметры, аргументы и предложение `import` ¶

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

>>> abs(5) 5 >>> abs(-5) 5

В этом примере, аргументами функции abs являются 5 и -5.

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

>>> pow(2, 3) 8 >>> pow(7, 4) 2401

Другая встроенная функция, принимающая больше одного аргумента, — функция max .

>>> max(7, 11) 11 >>> max(4, 1, 17, 2, 12) 17 >>> max(3 * 11, 5**3, 512 - 9, 1024**0) 503

В функцию max можно передать любое число аргументов, разделенных запятыми; функция вернет максимальное из переданных ей значений. Аргументами могут быть как простые значения, так и выражения. В последнем примере функция вернула 503, поскольку 503 больше, чем 33, 125 и 1.

А вот пример определенной пользователем функции с одним параметром:

def print_twice(bruce): print bruce, bruce

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

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

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

>>> from chap03 import * >>> print_twice('Spam') Spam Spam >>> print_twice(5) 5 5 >>> print_twice(3.14159) 3.14159 3.14159

При вызове функции значение аргумента присваивается соответствующему параметру из определения функции. Все выглядит так, как будто при вызове print_twice('Spam') выполняется bruce = 'Spam' , при вызове print_twice(5) выполняется bruce = 5 , а при вызове print_twice(3.14159) выполняется bruce = 3.14159 .

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

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

>>> print_twice('Spam' * 4) SpamSpamSpamSpam SpamSpamSpamSpam

Вначале вычисляется выражение 'Spam'*4 , что дает значение 'SpamSpamSpamSpam' , а затем это значение передается в функцию print_twice как аргумент.

3.4. Композиция¶

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

>>> print_twice(abs(-7)) 7 7 >>> print_twice(max(3, 1, abs(-11), 7)) 11 11

В первом случае abs(-7) дает значение 7, которое становится аргументом для print_twice . Во втором случае у нас двухуровневая композиция, так как сначала вычисляется abs(-11) , что дает 11, затем вычисление max(3, 1, 11, 7) дает 11 и, наконец, print_twice(11) отображает результат.

В качестве аргумента можно использовать переменную:

>>> michael = 'Eric, the half a bee.' >>> print_twice(michael) Eric, the half a bee. Eric, the half a bee.

Сделаем важное замечание. Имя переменной, которое мы указываем в качестве аргумента ( michael ) не имеет никакого отношения к имени параметра ( bruce ). Абсолютно все равно, с каким именем связано значение в том месте программы, откуда оно передается в функцию; внутри функции print_twice мы зовем его bruce .

3.5. Переменные и параметры являются локальными¶

Когда вы создаете локальную переменную внутри функции, она существует только внутри функции, и её невозможно использовать снаружи. Например:

def cat_twice(part1, part2): cat = part1 + part2 print_twice(cat)

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

>>> chant1 = "Pie Jesu domine, " >>> chant2 = "Dona eis requiem." >>> cat_twice(chant1, chant2) Pie Jesu domine, Dona eis requiem. Pie Jesu domine, Dona eis requiem.

Когда завершается cat_twice , переменная cat уничтожается. Если попробовать вывести ее, то получим ошибку:

>>> print cat NameError: name 'cat' is not defined

Параметры также являются локальными. Например, снаружи функции print_twice не существует такой вещи, как bruce . Если попробовать её использовать, Python выдаст сообщение об ошибке.

3.6. Стековые диаграммы¶

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

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

Порядок размещения функций в стеке показывает поток выполнения. print_twice вызывается функцией cat_twice , а cat_twice вызывается из __main__ . Это специальное имя для функции самого верхнего уровня. Когда создается переменная вне каких-либо функций, она принадлежит __main__ .

Каждый параметр функции имеет то же значение, что и соответствующий ему аргумент. Так, значение part1 то же, что у chant1 , part2 — то же, что у chant2 и bruce — то же, что у cat .

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

Чтобы посмотреть, как это работает, создайте скрипт Python с именем tryme2.py и следующим содержанием:

def print_twice(bruce): print bruce, bruce print cat def cat_twice(part1, part2): cat = part1 + part2 print_twice(cat) chant1 = "Pie Jesu domine, " chant2 = "Dona eis requim." cat_twice(chant1, chant2)

Мы добавили предложение print cat в функцию print_twice , но переменная cat там не определена. Выполнение этого скрипта приведет к сообщению об ошибке, похожему на это:

Traceback (innermost last): File "tryme2.py", line 11, in module> cat_twice(chant1, chant2) File "tryme2.py", line 7, in cat_twice print_twice(cat) File "tryme2.py", line 3, in print_twice print cat NameError: global name 'cat' is not defined

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

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

3.7. Глоссарий¶

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

def print_thrice(thing): print thing, thing, thing n = 42 s = "And now for something completely different. "

Теперь запустим интерпретатор в той директории, где размещается tryme.py :

$ ls tryme.py $ python >>>

В tryme.py определены три имени: print_thrice , n , и s . Если попробовать использовать их, не выполнив импорт, то получим ошибку:

>>> n Traceback (most recent call last): File "", line 1, in NameError: name 'n' is not defined >>> print_thrice("ouch!") Traceback (most recent call last): File "", line 1, in NameError: name 'print_thrice' is not defined

Если, однако, импортировать всё из tryme.py , то можно будет использовать всё, что в нем определено:

>>> from tryme import * >>> n 42 >>> s 'And now for something completely different. ' >>> print_thrice("Yipee!") Yipee! Yipee! Yipee! >>>

Заметьте, что не нужно включать .py в имя скрипта в предложении import.

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

Предложение, состоящее из двух частей:

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

Составное предложение строится так:

keyword expression: statement statement .

стековая диаграмма Графическое представление стека (кипы, стопки) вызываемых функций, их переменных и параметров. тело составного предложения Вторая часть составного предложения. Тело состоит из последовательности предложений, имеющих одинаковый отступ относительно заголовка. Стандартный отступ для программ на Python составляет 4 пробела. трассировка стека Список выполняющихся функций, печатаемый при возникновении ошибки выполнения. Трассировка стека перечисляет функции в порядке, в котором они вызывались. функция Именованная последовательность предложений, которая выполняет некоторые полезные действия. Функции могут иметь или не иметь параметры, могут возвращать или не возвращать результат.

3.8. Упражнения¶

С помощью текстового редактора создайте скрипт Python с именем tryme3.py . Поместите в него функцию nine_lines , которая использует three_lines чтобы выводить девять пустых строк. Теперь добавьте функцию clear_screen , которая выводит 25 пустых строк. В последней строке вашей программы напишите вызовclear_screen .
Переместите последнюю строку в tryme3.py в начало программы, так, чтобы вызов функцииclear_screen находился перед определением функции. Запустите программу и заметьте, какое сообщение об ошибке вы получили. Можете сформулировать правило о том, как должны располагаться в программе определения функций и вызовы функций относительно друг друга?
Вернувшись к рабочей версии tryme3.py , поместите определение функции new_line после определения функции three_lines . Посмотрите, что произойдет, когда вы запустите эту программу. Теперь поместите определение new_line ниже вызова three_lines() . Объясните, как поведение программы иллюстрирует правило, сформулированное в предыдущем примере.
Напишите тело в определении функцииcat_n_times так, чтобы строка s печаталась n раз:

def cat_n_times(s, n): fill in your code here>

Сохраните эту функцию в скрипте с именем import_test.py . Находясь в той директории, в которой сохранен файл (команда ls в Unix должна показать import_test.py ), запустите интерпретатор Python в интерактивном режиме и попробуйте выполнить следующее:

>>> from import_test import * >>> cat_n_times('Spam', 7) SpamSpamSpamSpamSpamSpamSpam

Функции в Python

В предыдущих разделах мы уже часто сталкивались с встроенными функция ( int, float, print, type, len ) Каждая функция в Python предназначена для выполнения одной конкретной задачи. Использование функции упрощает написание и чтение кода.

Содержание страницы:
1. Функция в Python
2. Передача аргументов функции
2.1 Позиционные аргументы
2.2. Именованные аргументы
2.3. Значения по умолчанию
2.4. Передача произвольного набора аргументов
2.5. Позиционные аргументы с произвольным набором аргументов
2.6. Произвольный набор именнованных аргументов
3. Возвращаемое значение в функции
3.1. Возвращение простого значения
3.2. Возвращение словаря
4. Использования функции в цикле while
5. Передача списка функции на Python
6. Использование лямбда-выражений вместо функций

1. Функция в Python

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

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

>>> def square ( number ):
. «»»Вычисление квадрата числа»»»
. print(number ** 2)
.
>>> square (5)
25
>>> square (124.45)
15487.802500000002

Определение функции начинается с ключевого слова def , за которым следует имя функции — square . Имя функции, как и имена переменных рекомендуется писать с букв нижнего регистра, а в именах, состоящих из нескольких слов, составляющие должны разделяться символами подчеркивания. Далее в круглых скобках записываются параметры (аргументы) функции, разделенные запятыми. Функция square имеет только один аргумент с именем number — значение, возводимое в квадрат. В случае отсутствия параметров у функции пустые круглые скобки обязательны. В конце строки за параметрами всегда ставится двоеточие ( : ).

После двоеточия новая строка должна идти с отступом (4 пробела). Все строки с отступом образуют тело или блок функции. В «Руководстве по стилю кода Python» указано, что первой строкой блока функции должна быть doc-строка, кратко поясняющая назначение функции: «»»Вычисление квадрата числа»»» . Сам код в теле функции состоит всего из одной строки print(number ** 2).

Команда squre(5) вызывает функции square() и передает ей значение аргумента, для выполнения команды print. Функция возводит число в квадрат и выводит на экран.

2. Передача аргументов функции в Python

2.1. Позиционные аргументы

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

>>> def car (car_brend, car_model, mileage):
. «»»Выводит информацию о автомобиле»»»
. print(f»Продается с пробегом км.»)
.
>>> car (‘bmw’, ‘x5’, 51345)
Продается Bmw X5 с пробегом 51345 км.

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

2.2. Именованные аргументы

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

>>> def car (car_brend, car_model, mileage):
. «»»Выводит информацию о автомобиле»»»
. print(f»Продается с пробегом км.»)
.
>>> car (mileage = 45152, car_model = ‘x5′, car_brend=’bmw’)
Продается Bmw X5 с пробегом 45152 км.

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

2.3. Значения по умолчанию

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

>>> def car (car_model, mileage, car_brend=’bmv’):
. «»»Выводит информацию о автомобиле»»»
. print(f»Продается с пробегом км.»)
.
>>> car (‘x7’, 12345)
Продается Bmv X7 с пробегом 12345 км.

>>> car (‘m5’ , 56148)
Продается Bmv M5 с пробегом 56148 км.

Для изменения значения по умолчанию, мы можем передать именованный аргумент для изменения значения car_brend=’audi’:

>>> car (‘q7’, 35600, car_brend=’audi’)
Продается Audi Q7 с пробегом 35600 км.

Так как аргумент для параметра car_brend задан явно, Python игнорирует значение по умолчанию.

2.4. Передача произвольного набора аргументов

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

>>> def cars ( * args ):
. «»»Вывод автомобилей»»»
. print( args )
.
>>> cars (‘audi’, ‘bmv’, ‘ford’, ‘kia’)
(‘audi’, ‘bmv’, ‘ford’, ‘kia’)
>>> cars (‘porshe’)
(‘porshe’)

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

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

>>> def cars ( * args):
. «»»Вывод автомобилей в продаже»»»
. print(‘Автомобили в продаже:’)
. for arg in args:
. print(f»-«)
.
>>> cars (‘audi’, ‘bmv’, ‘ford’, ‘kia’)
Автомобили в продаже:
-Audi
-Bmv
-Ford
-Kia

2.5. Позиционные аргументы с произвольным набором аргументов

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

>>> def car (car_brend, car_model, * colors):
. «»»Выводит информацию о автомобиле»»»
. print(f»Автомобиль можно заказать в цветах:»)
. for color in colors:
. print(f»-«)
.
>>> car (‘bmw’, ‘x7’, ‘синий’, ‘зеленый’, ‘белый’, ‘черный’, ‘желтый’)
Автомобиль Bmw X7 можно заказать в цветах:
-синий
-зеленый
-белый
-черный
-желтый

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

В большинстве программ часто используется имя обобщенного параметра *args для хранения произвольного набора позиционных аргументов.

2.6. Произвольный набор именованных аргументов

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

>>> def profile (first, last, **user_info):
. «»»Возвращает словарь с данными о пользователе»»»
. user_info[‘first_name’] = first
. user_info[‘last_name’] = last
. return user_info
.
>>> profile_1 = profile (‘tomas’, ‘edisson’, location=’usa’)
>>> print(profile_1)

Функция profile ожидает получить имя и фамилию пользователя, а также позволяет передать любое количество пар «имя — значение». Две звездочки в параметре **user_info заставляют Python создать пустой словарь с именем user_info и добавить в него все полученные пары «имя — значение». В теле функции сразу добавляются имя и фамилия, а остальные пары в зависимости от переданных параметров при вызове фукции. В конце словарь возвращается с помощью команды return .

В программах часто используется имя обобщенного параметра **kwargs для хранения произвольного набора ключевых аргументов.

3. Возвращаемое значение в функции на Python

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

3.1. Возвращение простого значения

Напишем функцию, которая возвращает отформатированное имя и фамилию

>>> def form_name (last_name, first_name, middle_name):
. «»»Возвращает отформатированное полное имя»»»
. full_name = f» »
. return full_name.title()
.
>>> poet = form_name (‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)
Пушкин Александр Сергеевич

Функция form_name получает в параметрах имя, фамилию и отечество, далее объединяет эти имена и сохраняет их в переменной full_name. Завершив выполнение, функция возвращает управление в точку вызова с помощью команды return , то есть в строку кода, которая вызывала функцию.

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

>>> def form_name (last_name, first_name, middle_name=»):
. «»»Возвращает отформатированное полное имя»»»
. full_name = f» »
. return full_name.title()
.
>>> poet = form_name (‘пушкин’, ‘александр’)
>>> print(poet)
Пушкин Александр
>>> poet = form_name(‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)
Пушкин Александр Сергеевич

С необязательным аргументом мы не получим ошибку (TypeError: form_name() missing 1 required positional argument: ‘middle_name’) в случае отсутствия на входе данных по аргументу.

3.2. Возвращение словаря

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

>>> def info_person (first_name, last_name):
. «»»Возвращает словарь с данными о человеке»»»
. person =
. return person
.
>>> musician = info_person (‘Freddie’, ‘Mercury’)
>>> print(musician)

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

4. Использования функции в цикле while

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

def form_name (first_name, last_name):
«»»Возвращает отформатированное полное имя»»»
full_name = f» »
return full_name.title()

while True:
print(«\nВведите ‘x’ если хотите завершить программу»)
first_name = input(«Введите ваше имя: «)
if first_name == ‘x’:
break
last_name = input(«Введите вашу фамилию: «)
if last_name == ‘x’:
break
formatted_name = form_name (first_name, last_name)
print(f»\nДобрый день !»)

В данном примере в цикле whle запрашивается имя и фамилия и с помощью функции form_name возвращается отформатированное полное имя и записывается в переменную formatted_name. А затем уже с помощью функции print данные выводятся на экран.

5. Передача списка функции на Python

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

>>> def square (numbers):
. «»»Вычисление квадрата числа»»»
. for number in numbers:
. print(number ** 2)
.
>>> numbers = [1, 5, 6, 15, -7, 1.5]
>>> square (numbers)
1
25
36
225
49
2.25

В результате функции square мы передаем список numbers. Для возведения всех чисел в квадрат, вначале нам нужно перебрать данный список с помощью цикла for, а затем каждое число возвести в квадрат.

6. Использование лямбда-выражений вместо функций

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

>>> square = lambda x : x ** 2
>>> print(square(5))
25

В начале создается переменная square и в дальнейшем по имени переменной будет вызываться лямбда-выражение. Лямбда-выражение является анонимной функцией, то есть функцией, не имеющей имени. Лямбда-выражение начинается с ключевого слова lambda , за которым следует разделенный запятыми список параметров. В нашем примере параметр один x. Затем ставится двоеточие и само выражение x ** 2. В результате при вызове переменной square мы передаем параметр число 5, и оно возводится в квадрат.

Лямбда-выражение может иметь и несколько параметров. Например, перемножать передаваемые числа.

>>> mult = lambda x, y, z : x * y * z
>>> print(mult(2, 4, 6))
48

Таким образом любая простая функция в форме

может быть выражена в более компактной форме посредством лямбда-выражения

lambda список_параметров : выражение

Как получить название функции, которая выполняется в текущий момент в python?

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

def tester(*args, **kwargs): # тут какой-то код должен вывести названии этой функции

Плохой пример:

def tester(*args, **kwargs): print('Сейчас работает функция tester')

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

Отслеживать
задан 17 окт 2021 в 17:01
869 2 2 золотых знака 8 8 серебряных знаков 30 30 бронзовых знаков

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Можно написать декоратор и применять к функциям которые Вы хотитe логировать (выводить можно не только имя но и аргументы). Пример:

from functools import wraps def func_name_logger(f): @wraps(f) def decorator(*args, **kwargs): print(f.__name__) return f(*args, **kwargs) return decorator @func_name_logger def any_functions(): print('start work.') any_functions() # output: any_functions # start work.

Еще один вариант, модуль inspect . Пример:

import inspect LAST_FUNC = None def foo(): global LAST_FUNC frame = inspect.currentframe() LAST_FUNC = inspect.getframeinfo(frame).function foo() print(LAST_FUNC) # foo

Читать:

Как настроить телепровайдера на ios 15