как посмотреть код функции в python

Как я могу получить исходный код функции Python?

Предположим, у меня есть функция Python, как определено ниже:

Если функция из исходного файла, доступного в файловой системе, то inspect.getsource(foo) может помочь:

Если foo определяется как:

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

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

dis Ваш друг, если исходный код недоступен:

Чтобы расширить ответ Руны:

Вы можете использовать inspect модуль, чтобы получить полный исходный код для этого. Вы должны использовать getsource() метод для этого из inspect модуля. Например:

Вы можете проверить это больше вариантов по ссылке ниже. получить ваш код Python

Вот как вы можете сделать это, используя mini-lambda :

Это правильно дает

Смотрите mini-lambda документацию для деталей. Я, кстати, автор;)

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

Например, рассмотрим файл test.py :

Выполнение этого дает вам (помните абзац!):

Чтобы получить исходный код лямбда-выражения, лучше всего, на мой взгляд, повторно проанализировать весь исходный файл (используя f.__code__.co_filename ) и сопоставить лямбда-узел AST по номеру строки и ее контексту.

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

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

Источник

Учимся читать код, изучая стандартную библиотеку Python

Итак, вы уже продвинутый новичок — вы изучили основы Python и способны решать реальные задачи.

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

Наверно, вы слышали, что нужно нарабатывать понимание чтением и написанием больших объёмов кода. Это правда.

Но какой же код нужно читать?

«Просто читай то, что нравится». А если вы не знаете, что вам нравится? А если вам не нравится что-то правильное?

Или хуже того — если вам нравится что-то неправильное и из-за этого у вас выработаются вредные привычки?

В конечном итоге, для этого ведь необходимо понимание… Но именно его мы и стремимся обрести.

«На GitHub куча проектов — выберите понравившийся и изучайте, как его реализовали разработчики». Однако самые успешные проекты довольно объёмны — с чего начинать?

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

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

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

В этой статье мы рассмотрим некоторые модули стандартной библиотеки Python.

Примечание о стандартной библиотеке

В целом, стандартная библиотека Python неидеальна для изучения «хорошего» стиля.

Хотя все её модули полезны, они не особо однородны:

Мы рассмотрим как раз некоторые из них.

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

Как читать модули

Приблизительно в таком порядке:

statistics

Он был внедрён в PEP 450. Если вы незнакомы с этим предложением, то это очень любопытное чтиво:

«Большая часть документации предназначена для читателей, понимающих базовые концепции, но которые могут не знать (например), какую дисперсию им стоит использовать [. ] Однако документация избегает скучных математических подробностей».

Код относительно прост, а когда это не так, то в нём есть комментарии и ссылки на подробные объяснения или статьи. Это может быть полезным, если вы изучаете все эти концепции и вам проще читать код, чем математическиe условные обозначения.

pathlib

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

Код хорошо читается по следующим причинам:

dataclasses

Кроме того, это отличный пример метапрограммирования; этот аспект подробно рассматривается в докладке Реймонда Хеттингера Dataclasses: The code generator to end all code generators. [Слайды с доклада в HTML и PDF.] Если у вас возникли проблемы с пониманием кода, то сначала посмотрите доклад; для меня оказалось довольно полезным объяснение генерируемого кода.

Бонус: graphlib

Модуль graphlib был добавлен в Python 3.9, и на данный момент содержит только одну вещь: реализацию алгоритма топологической сортировки (вот описание того, что это такое, и почему он полезен).

Он появился не через PEP; однако у него есть issue со множеством комментариев от разных разработчиков ядра, в том числе Реймонда Хеттингера и Тима Питерса (известного своим «Дзен языка Python»).

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

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

По сравнению с обсуждением issue, сам код очень мал — меньше 250 строк, и в основном состоит из комментариев и документации.

На правах рекламы

Серверы для разработчиков и не только! Дешёвые VDS на базе новейшего «железа» для размещения проектов любой сложности, от корпоративных сетей и игровых проектов до лендингов и VPN.

Источник

Функции в Python

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

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

Синтаксис

💁‍♀️ Простой пример: Вы торгуете мёдом, и после каждой продажи вам нужно печатать чек. В нём должно быть указано: название фирмы, дата продажи, список наименований проданных товаров, их количество, цены, общая сумма, а также сакраментальная фраза «Спасибо за покупку!».

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

print(«ООО Медовый Гексагон») print(«Мёд липовый», end=» «) print(1, end=»шт «) print(1250, end=»р») print(«\nCумма», 1250, end=»р») print(«\nСпасибо за покупку!»)

А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.

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

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

# (название, количество, цена за штуку) honey_positions = [ («Мёд липовый», 3, 1250), («Мёд цветочный», 7, 1000), («Мёд гречишный», 6, 1300), («Донниковый мёд», 1, 1750), («Малиновый мёд», 10, 2000), ]

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

Да, код стал более массивным. Однако теперь для печати чека вам не придётся самостоятельно вычислять итог. Достаточно лишь изменить количество и цену товаров в списке. Существенная экономия времени! Слава функциям!

Термины и определения

Ключевое слово def в начале функции сообщает интерпретатору о том, что следующий за ним код – есть её определение. Всё вместе – это объявление функции.

# объявим функцию my_function() def my_function(): # тело функции

Аргументы часто путают с параметрами:

Ключевая особенность функций – возможность возвращать значение.

# она будет принимать два множителя, а возвращать их округленное # до целого числа произведение def int_multiple(a, b): product = a * b # возвращаем значение return int(product) print(int_multiple(341, 2.7)) > 920

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

# найдём квадратный корень из возврата функции int_multiple # во встроенную функцию sqrt() мы передали вызов int_multiple print(math.sqrt(int_multiple(44, 44))) > 44

Важность функций

Абстракция

Человек бежит, машина едет, корабль плывёт, а самолёт летит. Всё это – объекты реального мира, которые выполняют однотипные действия. В данном случае, они перемещаются во времени и пространстве. Мы можем абстрагироваться от их природы, и рассматривать эти объекты с точки зрения того, какое расстояние они преодолели, и сколько времени на это ушло.

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

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

Возможность повторного использования

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

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

Всего 10 таких сортировок, и привет, лишние 60 строк кода.

Модульность

Разбитие больших и сложных процессов на простые составляющие – важная часть, как кодинга, так и реальной жизни. В повседневности мы занимаемся этим неосознанно. Когда убираемся в квартире, мы пылесосим, моем полы и окна, очищаем поверхности от пыли и наводим блеск на всё блестящее. Всё это – составляющие одного большого процесса под названием «уборка», но каждую из них также можно разбить на более простые подпроцессы.

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

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

Без применения модульности получится сплошная последовательность инструкций:

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

Это и называется модульностью.

Пространство имен

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

💁‍♀️ Пример из жизни: в ВУЗе учатся два человека с совпадающими ФИО. Их нужно как-то различать. Если сделать пространствами имён группы этих студентов, то проблема будет решена. В рамках своей группы ФИО этих студентов будут уникальными.

Объявление и вызов функций

def hello(): print(‘Adele is cute’)

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

# код выполняется последовательно, поэтому сейчас интерпретатор # не знает о существовании функции hello hello() def hello(): print(‘Adele is cute’) > NameError: name ‘hello’ is not defined

Поэтому стоит лишь поменять объявление и вызов местами, и всё заработает:

def hello(): print(‘Adele is cute’) hello() > Adele is cute

Область видимости функций

Рассмотрим подробнее области видимости:

Локальная (L)

Локальная область видимости находится внутри def :

def L(): # переменная i_am_local является локальной внутри L() i_am_local = 5

Область объемлющих функций (E)

def e(): x = 5 def inner_e(): nonlocal x x = x + 1 return x return inner_e() print(e()) > 6

Глобальная (G)

# G num = 42 def some_function(n): res = n + num return res print(some_function(1)) > 43

Аргументы

Позиционные

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

Значения в позиционных аргументах подставляются согласно позиции имён аргументов:

Именованные

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

def trio_printer(a, b, c): print(a, b, c) trio_printer(c=4, b=5, a=6) > 6 5 4

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

Необязательные параметры (параметры по умолчанию)

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

def not_necessary_arg(x=’My’, y=’love’): print(x, y) # если не передавать в функцию никаких значений, она отработает со значениями по умолчанию not_necessary_arg() > My love # переданные значения заменяют собой значения по умолчанию not_necessary_arg(2, 1) > 2 1

Аргументы переменной длины (args, kwargs)

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

def infinity(*args): print(args) infinity(42, 12, ‘test’, [6, 5]) > (42, 12, ‘test’, [6, 5])

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

Функции в питоне могут также принимать и переменное количество именованных аргументов. В этом случае перед названием параметра ставится » ** «:

def named_infinity(**kwargs): print(kwargs) named_infinity(first=’nothing’, second=’else’, third=’matters’) >

Здесь kwargs уже заключает аргументы не в кортеж, а в словарь.

Передача по значению и по ссылке

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

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

В Python изменяемые объекты это:

Будьте внимательны при передаче изменяемых объектов. Одна из частых проблем новичков.

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

Словарь в качестве аргументов (упаковка)

Передаваемые в функцию аргументы можно упаковать в словарь при помощи оператора «**»:

def big_dict(**arguments): print(arguments) big_dict(key=’value’) >

Возвращаемые значения (return)

Что можно возвращать

Функции в Python способны возвращать любой тип объекта.

Распаковка возвращаемых значений

☝️ Обратите внимание, что количество возвращаемых значение в кортеже должно совпадать с количеством переменных при распаковке. Иначе произойдет ошибка:

Пустая функция

Иногда разработчики оставляют реализацию на потом, и чтобы объявленная функция не генерировала ошибки из-за отсутствия тела, в качестве заглушки используется ключевое слово pass :

Чистые функции и побочные эффекты

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

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

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

Lambda функции

lambda_test = lambda a, b: pow(a, b) print(lambda_test(2, 4)) > 16

Docstring

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

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

Аннотация типов

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

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

При этом интерпретатор считывает аннотации типов, но никак их не обрабатывает.

Функции vs процедуры – в чем отличие?

Для языка нет различий между функциями и процедурами. Но с точки зрения программиста – это разные сущности.

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

def proc(i, j): pow(i, j) proc(1, 200)

def func(i, j): return pow(i, j) print(func(3, 2)) > 9

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

def low_word_printer(word): print(word.lower()) return 0 s = ‘GOOD’ low_word_printer(s) > good

Возвращаемое значение не представляет собой никакой ценности, поэтому low_word_printer(s) лучше оформить, как процедуру.

Время выполнения функции

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

Вложенные функции и рекурсия

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

def outerFunc(): def firstInner(): print(‘This is first inner function’) def secondInner(): print(‘This is second inner function’) firstInner() secondInner() outerFunc() > This is first inner function > This is second inner function

Рекурсия является частным случаем вложенной функции. Это функция, которая вызывает саму себя.

Источник

Функции в Python

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

Oбъявление функции в Python выглядит так:

# Объявление функции

def hello (name):
print ( ‘Hello, ‘ + name)

# Вызовы функции

hello ( ‘Max’ )
hello ( ‘Ivan’ )
hello ( ‘Alex’ )
hello ( ‘Kate’ )

# Вывод

>> Hello, Max
>> Hello, Ivan
>> Hello, Alex
>> Hello, Kate

Оператор return возвращает значение из функции.

Представьте себе обычный калькулятор. Вы вводите первое число, операцию и второе число. Калькулятор возвращает нам результат операции над этими числами. Всё просто, не так ли? Функции точно так же умеют возвращать значение с помощью специального оператора return.

print ( f ‘s1 = ‘ )
print ( f ‘s2 = ‘ )
print ( f ‘s3 = ‘ )

>> s1 = 12
>> s2 = 208
>> s3 = 4

print ( f ‘m1 = ‘ )
print ( f ‘m2 = ‘ )
print ( f ‘m3 = ‘ )

>> m1 = 20
>> m2 = 10800
>> m3 = 3

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

# Аргумент name по умолчанию равен ‘world’

def hello ( name = ‘world’ ):
print ( ‘Hello, ‘ + name)

hello ()
hello ( ‘Ivan’ )

>> Hello, world
>> Hello, Ivan

Примеры

# Написать функцию square(), вычисляющую квадрат числа.

def square ( number ):
return number * number # Возвращаем результат работы функции обратно в программу

a = square ( 2 )
print (a)

print ( isEven ( 10 ))
print ( isEven ( 11 ))

# Напишите функцию amountList, которая возвращает сумму всех элементов списка.

def amountList ( lst ):
amount = 0
f or x in lst:
amount += x
return amount

print ( f ‘Сумма списка равна ‘ )

print ( fib ( 2 ))
print ( fib ( 3 ))
print ( fib ( 4 ))
print ( fib ( 5 ))
print ( fib ( 10 ))

print ( fact ( 2 ))
print ( fact ( 3 ))
print ( fact ( 4 ))
print ( fact ( 5 ))

Решение задач

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

# Не забудьте написать функцию circle.

print ( circle ( 4 ))
print ( circle ( 1 ))

# Не забудьте написать функцию three.

print ( three ( 4 ))
print ( three ( 3 ))

3. Максимум в списке

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

Напишите функцию, которая возвращает количество четных элементов в списке.

Напишите функцию, которая возвращает список с уникальными (неповторяющихся) элементам.

Источник

Функции в Python

Введение

Определение

Вот пример простой функции:

Для определения функции нужно всего лишь написать ключевое слово def перед ее именем, а после — поставить двоеточие. Следом идет блок инструкций.

Функция инкрементирует глобальную переменную i и возвращает None (по умолчанию).

Вызовы

Для вызова функции, которая возвращает переменную, нужно ввести:

Для вызова функции, которая ничего не возвращает:

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

Функции могут быть вложенными:

Функции — это объекты, поэтому их можно присваивать переменным.

Инструкция return

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

Возврат нескольких значений

Пока что функция возвращала только одно значение или не возвращала ничего (объект None). А как насчет нескольких значений? Этого можно добиться с помощью массива. Технически, это все еще один объект. Например:

Аргументы и параметры

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

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

x и y — это параметры, а в этой:

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

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

Выходит, что в следующем примере допущена ошибка:

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

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

А этот вызов некорректен:

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

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

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

Второй аргумент можно пропустить:

Чтобы обойти эту проблему, можно использовать словарь:

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

Еще один пример изменяемого объекта, значение которого поменялось при вызове:

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

Указание произвольного количества аргументов

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

При вызове функции нужно вводить команду следующим образом:

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

Если лишние аргументы не указаны, значением по умолчанию будет пустой кортеж.

Произвольное количество аргументов-ключевых слов

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

При вызове функции нужно писать так:

Python обрабатывает аргументы-ключевые слова следующим образом: подставляет обычные позиционные аргументы слева направо, а затем помещает другие позиционные аргументы в кортеж (*args), который можно использовать в функции (см. предыдущий раздел). В конце концов, он добавляет все лишние аргументы в словарь (**kwargs), который сможет использовать функция.

Важно, что пользователь также может использовать словарь, но перед ним нужно ставить две звездочки (**):

Порядок вывода также не определен, потому что словарь не отсортирован.

Документирование функции

Команда docstring должна быть первой инструкцией после объявления функции. Ее потом можно будет извлекать или дополнять:

Методы, функции и атрибуты, связанные с объектами функции

Если поискать доступные для функции атрибуты, то в списке окажутся следующие методы (в Python все является объектом — даже функция):

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

Есть и другие. Вот те, которые не обсуждались:

Рекурсивные функции

Другой распространенный пример — определение последовательности Фибоначчи:

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

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

Глобальная переменная

Вот уже знакомый пример с глобальной переменной:

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

Присвоение функции переменной

С существующей функцией func синтаксис максимально простой:

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

Менять название переменной также разрешается:

В этом примере a1, a2 и func имеют один и тот же id. Они ссылаются на один объект.

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

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

Анонимная функция: лямбда

С помощью type() можно проверить тип:

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

Изменяемые аргументы по умолчанию

Вместо этого нужно использовать значение «не указано» и заменить на изменяемый объект по умолчанию:

Источник