Вывести название функции python

Функции в Python

Введение

Определение

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

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

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

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

Вызовы

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

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

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

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

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

Инструкция return

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Если изучить ее, обнаружатся два скрытых метода (которые начинаются с двух знаков нижнего подчеркивания), среди которых есть __doc__ . Он нужен для настройки документации функции. Документация в Python называется docstring и может быть объединена с функцией следующим образом:

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

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

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

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

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

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

Рекурсия — это не особенность Python. Это общепринятая и часто используемая техника в Computer Science, когда функция вызывает сама себя. Самый известный пример — вычисление факториала n! = n * n — 1 * n -2 * … 2 *1. Зная, что 0! = 1, факториал можно записать следующим образом:

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

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

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

Если рекурсия содержит баги (например, длится бесконечно), функции может не хватить памяти. Задать максимальное значение рекурсий можно с помощью модуля sys .

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

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

Здесь функция увеличивает на 1 значение глобальной переменной i . Это способ изменять глобальную переменную, определенную вне функции. Без него функция не будет знать, что такое переменная i . Ключевое слово global можно вводить в любом месте, но переменную разрешается использовать только после ее объявления.

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

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

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

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

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

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

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

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

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

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

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

Лямбда-функция — это короткая однострочная функция, которой даже не нужно имя давать. Такие выражения содержат лишь одну инструкцию, поэтому, например, if , for и while использовать нельзя. Их также можно присваивать переменным:

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

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

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

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

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

Источник

Как вызвать функцию в Python?

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

Основные особенности функций в Python:

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

Правила создания функций:

1. Для объявления функции в Python используется ключевое слово def .
2. Название функции должно начинаться с символа латинского алфавита в любом регистре или нижнего подчеркивания.
3. В каждой функции есть двоеточие и отступ, после которого записывается сам код программы.
4. Зарезервированные ключевые слова не могут использоваться в качестве названия функции.
5. Функция может содержать несколько параметров или не иметь их совсем.

Создание функции в Python

Для создания нужно написать ключевое слово def . Синтаксис следующий:

Создадим и вызовем реальную функцию в Python:

Источник

Функции и их аргументы

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

Именные функции, инструкция def

Функция в python — объект, принимающий аргументы и возвращающий значение. Обычно функция определяется с помощью инструкции def.

Определим простейшую функцию:

Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y.

Теперь мы ее можем вызвать:

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

Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:

Аргументы функции

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

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

Как видно из примера, args — это кортеж из всех переданных аргументов функции, и с переменной можно работать также, как и с кортежем.

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

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

Анонимные функции, инструкция lambda

Анонимные функции могут содержать лишь одно выражение, но и выполняются они быстрее. Анонимные функции создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией def func():

lambda функции, в отличие от обычной, не требуется инструкция return, а в остальном, ведет себя точно так же:

Источник

Функции в 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 = <'first': first_name, 'last': last_name>
. 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

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

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

Источник