def (функция/метод) в Python
18 sep. 16 20:22 02 aug. 17 12:56
Последовательность инструкций, возвращающая некое значение.
В функцию могут быть переданы ноль и более аргументов, которые могут использоваться в теле функции.
Для возврата значения из функции используется инструкция 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
. Функция задокументирована (испольузется формат описания сигнатуры
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()
В ходе исполнения функции формируется новая символьная таблица с локальными переменными функции: все назначения переменных оказываются в ней. При обращении к переменной, сначала производится попытка отыскать её в локальной символьной таблице, далее в таблицах обрамляющих функций, далее в глобальной таблице, и, наконец, в таблице встроенных имён.
Ввиду вышесказанного ссылаться на глобальные переменные внутри функции можно, а присвоить им значение (без использования инструкции
) нельзя.
MY_GLOBAL = 1def set_global_1():
MY_GLOBAL = 2def set_global_2():
global MY_GLOBAL
MY_GLOBAL = 2print(MY_GLOBAL) # 1
set_global_1()
print(MY_GLOBAL) # 1set_global_2()
print(MY_GLOBAL) # 2
Аргументы, с которыми была вызвана функция, также оказываются в её локальной символьной таблице.
В Питоне используется передача аргументов «по значению» (значением при этом всегда является ссылка на сам объект, но не на его значение). Однако, ввиду того, что в случаях, когда передаются изменяемые объекты, вызвавший увидит все изменения, сделанные вызываемым (например, при добавлении элементов в список), возможно лучше было бы назвать данный вид передачи «
def mutate_list(a_list):
a_list.append(0)
return Truemy_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, вуа
Статьи раздела
Decorator (декоратор) | |
Generator (генератор) | Функция, возвращающая подвид итератора, генерирующий значения. |
В разделе «Callable (вызываемый)»: Аргументы вызова Параметры вызываемых объектов
Читайте нас в Twitter. Ссылка в самом низу страницы.
Python 3: функции (def) — объявление и вызов
Смотреть материал на видео
Вот мы с вами и подошли к одному из фундаментальных моментов в изучении языка Python – функциям. Что это такое? Смотрите. Например, уже знакомая вам функция
print()
выводит сообщения в консоль. Фактически же при ее вызове выполняется определенный фрагмент программы, результатом которого и является вывод информации в заданном виде. И это очень удобно. Благодаря наличию таких функций нам не нужно каждый раз писать дублирующие инструкции для выполнения типовых операций. Собственно, это главное предназначение функций – многократное выполнение определенного фрагмента программы.
Язык Python позволяет программисту создавать свои собственные функции. Для этого используется следующий синтаксис:
def <имя функции>([список аргументов]):
оператор 1
оператор 2
…
оператор
N
Здесь имя функции придумывается программистом подобно именам переменных и, так как функция – это определенное действие, то ее имя следует выбирать как глагол, например:
go, show, get, set и т.п.
Далее, идет набор операторов, которые образуют тело функции. Именно они начинают выполнятся при ее вызове.
Давайте зададим простейшую функцию, которая будет выводить «hello» в консоль:
def sayHello(): print("hello")
Смотрите, мы здесь придумали имя функции «sayHello», записали пустые круглые скобки без аргументов и через двоеточие определили тело функции в виде конструкции print(«hello»). Но это лишь определение функции. Самого вызова здесь еще нет и если запустить программу, то ничего не произойдет.
Чтобы вызвать эту функцию, нужно указать ее имя и в конце обязательно поставить круглые скобки даже если мы не передаем ей никаких аргументов:
sayHello()
Эти круглые скобки являются оператором вызова функции с указанным именем. Теперь, при запуске программы в консоли появится сообщение «hello».
Имя функции без круглых скобок – это фактически ссылка на функцию:
print( type(sayHello) )
то есть, ссылка на специальный объект, представляющий ту или иную функцию.
f = sayHello
тем самым определить ее синоним и вызвать ее уже через это второе имя:
Как мы говорили в самом начале, функции, как правило, создаются для их многократного вызова. И действительно, мы теперь, можем ее вызывать в любом месте нашей программы необходимое число раз, например, так:
sayHello() print("---------------") sayHello()
Здесь будет уже два вызова этой функции. И так далее. Причем, обратите внимание, мы вызываем функцию только после ее определения. То есть, если записать ее вызвать в самом начале программы, то возникнет ошибка, т.к. данная функция не была определена. Это вроде как:
«сначала нужно испечь пирог и только потом можно его есть.»
Также и с функциями: мы их сначала определяем и только потом можем вызывать. Поэтому определение функций обычно идет в самом начале, а потом уже их вызовы в основной программе.
Если нужно определить еще одну функцию, то мы ее можем записать после первой:
def myAbs(x): x = -x if(x<0) else x
Имена функций должны быть уникальными (также как и имена переменных), поэтому я назвал ее myAbs, т.к. функция abs уже существует. И предполагаю, что она будет вычислять модуль переданного ей числа. Соответственно, в круглых скобках обозначаю этот аргумент. Если теперь мы ее вызовем:
print( myAbs(-5) )
то увидим значение 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)
То при вызове этой функции:
val = myAbs(-5.8)
Ничего в консоль выведено не будет, т.к. вызов был завершен на операторе 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)
И теперь, можно вызвать эту функцию так:
sayHello("Hello")
или так:
sayHello("Hello", "?")
Смотрите, если формальный параметр не указан, то берется его значение по умолчанию. Если же мы его явно задаем, то берется переданное значение. Здесь нужно помнить только одно правило: формальные аргументы должны быть записаны последними в списке аргументов функции. То есть, вот такая запись:
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
И, затем, вызвать ее:
p = myPow(3, 5) print(p)
Интересной особенностью Python в определении функций является возможность переопределять уже существующие функции. Например, у нас задана вот такая функция:
def sayHello(): print("hello")
Тогда ниже мы можем ее переопределить, если укажем то же самое имя:
def sayHello(): print("------- hello --------")
Теперь, при ее вызове:
sayHello()
увидим выполнение последнего, переопределенного варианта. Если дальше ее переопределить вот так:
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
И вызвать мы ее можем так:
print( max2(2, -3) )
Затем, нам потребовалась функция, которая бы находила максимальное из трех чисел. Как ее можно реализовать? Используя идею функционального программирования, это можно сделать следующим образом:
def max3(a, b, c): return max2(a, max2(b, c))
И вызвать так:
print( max3(2, -3, 5) )
Смотрите, здесь оператор return возвращает значение, которое возвращает функция max2. Но, прежде чем она будет выполнена, вызовется другая функция max2, которая определит максимальное среди чисел b и c. То есть, прежде чем вызвать первую функцию max2 необходимо вычислить ее параметры: первый просто берется их x, а второй вычисляется вложенной функцией max2. Вот так это работает и вот что из себя представляет элемент функционального подхода к программированию.
Причем, благодаря гибкости языка Python, мы можем вызвать эту функцию и для нахождения максимальной строки:
print( max3("ab", "cd", "abc") )
так как строки могут спокойно сравниваться между собой. И вообще, любые величины, которые можно сравнивать на больше и меньше, можно подставлять в качестве аргументов функции max3 и max2.
Задания для самоподготовки
1. Задайте и вызовите функцию, которая вычисляет площадь прямоугольника.
2. Необходимо создать функцию, которая в зависимости от значения формального параметра type будет вычислять или площадь или периметр прямоугольника.
3. Написать функцию поиска максимального значения из переданного ей списка значений.
4. Написать функцию вычисления произведения значений элементов переданного ей списка.
Видео по теме
#1. Первое знакомство с Python Установка на компьютер
#2. Варианты исполнения команд. Переходим в PyCharm
#3. Переменные, оператор присваивания, функции type и id
#4. Числовые типы, арифметические операции
#5. Математические функции и работа с модулем math
#6. Функции print() и input(). Преобразование строк в числа int() и float()
#7. Логический тип bool. Операторы сравнения и операторы and, or, not
#8. Введение в строки. Базовые операции над строками
#9. Знакомство с индексами и срезами строк
#10. Основные методы строк
#11. Спецсимволы, экранирование символов, row-строки
#12. Форматирование строк: метод format и F-строки
#13. Списки — операторы и функции работы с ними
#14. Срезы списков и сравнение списков
#15. Основные методы списков
#16. Вложенные списки, многомерные списки
#17. Условный оператор if. Конструкция if-else
#18. Вложенные условия и множественный выбор. Конструкция if-elif-else
#19. Тернарный условный оператор. Вложенное тернарное условие
#20. Оператор цикла while
#21. Операторы циклов break, continue и else
#22. Оператор цикла for. Функция range()
#23. Примеры работы оператора цикла for. Функция enumerate()
#24. Итератор и итерируемые объекты. Функции iter() и next()
#25. Вложенные циклы. Примеры задач с вложенными циклами
#26. Треугольник Паскаля как пример работы вложенных циклов
#27. Генераторы списков (List comprehensions)
#28. Вложенные генераторы списков
#29. Введение в словари (dict). Базовые операции над словарями
#30. Методы словаря, перебор элементов словаря в цикле
#31. Кортежи (tuple) и их методы
#32. Множества (set) и их методы
#33. Операции над множествами, сравнение множеств
#34. Генераторы множеств и генераторы словарей
#35. Функции: первое знакомство, определение def и их вызов
#36. Оператор return в функциях. Функциональное программирование
#37. Алгоритм Евклида для нахождения НОД
#38. Именованные аргументы. Фактические и формальные параметры
#39. Функции с произвольным числом параметров *args и **kwargs
#40. Операторы * и ** для упаковки и распаковки коллекций
#41. Рекурсивные функции
#42. Анонимные (lambda) функции
#43. Области видимости переменных. Ключевые слова global и nonlocal
#44. Замыкания в Python
#45. Введение в декораторы функций
#46. Декораторы с параметрами. Сохранение свойств декорируемых функций
#47. Импорт стандартных модулей. Команды import и from
#48. Импорт собственных модулей
#49. Установка сторонних модулей (pip install). Пакетная установка
#50. Пакеты (package) в Python. Вложенные пакеты
#51. Функция open. Чтение данных из файла
#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов
#53. Запись данных в файл в текстовом и бинарном режимах
#54. Выражения генераторы
#55. Функция-генератор. Оператор yield
#56. Функция map. Примеры ее использования
#57. Функция filter для отбора значений итерируемых объектов
#58. Функция zip. Примеры использования
#59. Сортировка с помощью метода sort и функции sorted
#60. Аргумент key для сортировки коллекций по ключу
#61. Функции isinstance и type для проверки типов данных
#62. Функции all и any. Примеры их использования
#63. Расширенное представление чисел. Системы счисления
#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы
#65. Модуль random стандартной библиотеки
создать, вызвать, разные параметры и примеры аргументов
В компьютерной терминологии функция — это блок программного кода, который используется несколько раз для решения задачи. Тело функции — набор инструкций, которые поочередно исполняют в процессе вызова.
Обычно у функции есть один или несколько аргументов. Их указывают в скобках во время вызова. Они делятся на обязательные (позиционные) и со значением по ключу (именованные).
Синтаксис функций в Python
Аргументы и их виды
Функции и области видимости
Lambda-функции (анонимные)
Оператор возврата return
Оператор возврата yield
[FAQ] Частые вопросы
Главное о функциях в Python
Синтаксис функций в Python
Любые функции и методы начинаются с инструкции def (от английского define — «определять»). За def в Python идет название функции, после — набор аргументов. Двоеточие в конце открывает блок тела функции, которое располагают с новой строки.
В Python нет фигурных скобок для блока кода. Вместо них применяют отступы в четыре пробела. Новая инструкция — новая строка. Или можно отделить их точкой с запятой.Чтобы завершить функцию и вернуть из нее значение, используют ключевое слово return. Если этого не указать, то, когда тело функции достигает конца, функция завершится. Возвращается объект типа None.
Аргументы и их виды
Если надо передавать аргументы через функцию, нужно расположить их в скобках по порядку. Исключение — именованные аргументы. Такие аргументы могут идти в любом порядке, но сначала — позиционные.
🚀 Позиционные
Это обязательные аргументы. Чтобы функция работала корректно, важно размещать их в определенном порядке.
def addfunc(val1, val2):
return val1 + val2result = addfunc(3, 2)
print(result)
5addfunc() # вызов без аргументов
Traceback (most recent call last):
. ..
TypeError: addfunc() missing 2 required positional arguments: 'val1' and 'val2'addfunc(1) # вызов с одним аргументом
Traceback (most recent call last):
...
TypeError: addfunc() missing 1 required positional argument: 'val2'
Когда вызывают функцию addfunc, то передают ей два обязательных аргумента. Они будут доступны внутри тела функции и ассоциированы с переменными val1 и val2. Если этого не сделаете, получите ошибку TypeError.
Но иногда нужны более гибкие функции, которые работают с переменной длиной аргументов. Для этого есть специальная конструкция, она упаковывает переданные позиционные аргументы в переменную:
def addconcat(*args):
value = 0
for item in args:
if isinstance(item, (int, float)):
value += item
else:
print(f"{item} is not a digit")
return value
total = addconcat(1, "Hello", 2, 3, 4, "Python", 5. 0, 6.25, 7.15, 'string')
Hello is not a digit
World is not a digit
string is not a digit
print("Total:", total)
Total: 28.4
Обращаются к позиционному аргументу такого множества с помощью операции индексации:
def demo_func(*args):
try:
print(args[0])
print(args[1])
except IndexError:
pass
🚀 Именованные
Это параметры функции с предустановленным значением. Перезаписать его можно с помощью нового значения по имени атрибута:
def hey_concat(*args, name="World!"):
print("Hey there,", name)
hey_concat()
Hey there, World!
hey_concat(name="Alex")
Hey there, Alex0
Атрибуту name присвоили иное значение. Это поменяет результат склеивания строк и последующий вывод.
Именованные аргументы могут быть переменной длины. Конструкция упаковывания параметров похожа на предыдущую, но вместо множества используют словарь:
def print_kwargs(**kwargs):
print(kwargs) # отобразит словарь
print_kwargs(kone="One", ktwo=2, kthree=3. 0)
{'kone': 'One', 'ktwo': 2, 'kthree': 3.0}
Для доступа к значениям именованных аргументов внутри функции используют интерфейс словаря. Вы можете проверить наличие ключа, соответствие значения типу. А еще предусмотреть прочие проверки, прежде чем исполнять тело функции.
def kwargs_addconcat(**kwargs):
a = kwargs.get("a", None)
b = kwargs.get("b", None)
if not isinstance(a, type(b)):
raise TypeError("Ошибка! Разные типы")
if isinstance(a, str):
return f"Результат конкатенации строк\n{a + b}"
elif isinstance(a, int):
return f"Результат сложения чисел\n{a + b}"
return "Ошибка"
print(kwargs_addconcat(a=1, b=2))
Результат сложения чисел
3
print(kwargs_addconcat(a=1, b="World!"))
...
TypeError: Ошибка! Разные типы
print(kwargs_addconcat(a="Hello, ", b="World!"))
Результат конкатенации строк
Hello, World!
# Без аргументов
print(kwargs_addconcat())
Ошибка
В примере упаковываем именованные аргументы в переменную с названием kwargs. Из нее в теле функции по ключам a и b пытаемся получить значения. А если они не найдутся — объект None. Далее проверяем наличие обоих аргументов и принадлежность одному типу данных. Затем возвращаем результат выполнения в зависимости от типа переданных параметров.
Еще можно комбинировать позиционные и именованные параметры. Сначала располагают позиционные (обязательные) аргументы. Сразу за ними идет переменная, в которую записывают все остальные параметры без явного ключа. Далее — именованные аргументы с предустановленным значением (значением по умолчанию). После него располагают переменную словаря с остальными именованными параметрами.
Общая форма последовательности:
def func(a, b, *args, name="Default", **kwargs):
return None
Функции и области видимости
Область видимости разрешает конфликт имен и гарантирует, что любой объект, созданный внутри функции, не перезапишет предыдущий объект с таким же именем без явного указания.
✈️ Глобальная
Это пространство имен модуля. В него входят названия переменных, классов, функций и всех остальных объектов, созданных в конкретном файле.
var1 = 12
def global_func():
print(x)
Здесь целочисленный объект var1 и функция global_func — в глобальной области видимости.
✈️ Локальная
Внутри функций можно создавать временные переменные для вычислений. Чтобы избежать конфликта имен и случайной перезаписи, под каждую функцию выделяется свое пространство:
var1 = 2213 # глобальная переменная
# глобальная функция, использующая глобальную переменную
def func_one():
print(var1)
# глобальная функция, использующая локальную переменную
def func_two():
var1 = "Local value" # создание локальной переменной
print(var1)
# функция, изменяющая значение глобальной переменной
def func_three():
global var1
var1 = "Local to global"
В последней функции указываем, что хотим использовать глобальную переменную с помощью ключевого слова global вместе с именем нужной переменной.
func_one()
2213
func_two()
Local value
func_three() # функция меняет значение глобальной переменной
func_one() # и результат функции func_one
Local to global
✈️ Область объемлющих функций
В Python есть ключевое слово nonlocal. Например, его применяют при создании декораторов. Оно указывает, что нужно использовать переменную уровнем выше, но при этом не относящуюся к глобальной области видимости.
Так реализуют декоратор счетчика вызова функции Python с этим ключевым словом:
def count_deco(wrapper_func):
var = 0
def inner():
nonlocal var
wrapper_func()
var += 1
print(var)
return inner
@count_deco
def deco_demo():
print("A few of example text...")
for _ in range(5):
deco_demo()
A few of example text...
1
A few of example text. ..
2
A few of example text...
3
A few of example text...
4
A few of example text...
5
Lambda-функции (анонимные)
Одна из интересных особенностей Python — это анонимные (лямбда) функции. Это простое выражение, которое можно присвоить переменной и использовать повторно. Чаще применяют для фильтрации элементов множества:
list_values = [1, 3, 4, 2, 6, 7, 5, 8, 9]
filter(lambda x : x % 2 == 0, list_values)
[2, 4, 6, 8]
Оператор возврата return
Результат вычислений функции возвращают с помощью инструкции return. Возвращать можно объекты любого типа и в любом количестве через запятую.
Если функция возвращает несколько объектов, они будут запакованы в кортеж (tuple). Тогда к конкретным элементам обращаются либо по индексу, либо с помощью распаковки множества, где каждый элемент присваивают отдельной переменной. Функция, где явно не указано возвращаемое значение, по умолчанию вернет объект типа None.
def arithmetics(x, y):
return x + y, x - y, x * y, x / y, x // y
results = arithmetics(22, 3)
print(results)
(25, 19, 66, 7.333333333333333, 7)
print(results[0])
25
r1, r2, r3, r4, r5 = arithmetics(4, 4)
# результаты сложения и умножения
print(r1)
8
print(r3)
16
Оператор возврата yield
Помимо обычных есть функции-генераторы. Очевидный плюс — они в оперативной памяти не хранят все объекты, которые используют. Есть отложенное выполнение. Такая функция возобновляет работу там, где остановилась. Она генерирует значения, а не вычисляет их.
Чтобы передать аргументы генератору и вернуть значения, применяют ключевое слово yield. Когда элементы объекта-генератора заканчиваются, тот возбуждает исключение типа StopIteration:
def gen_demo(times, var):
for _ in range(times):
yield var
gen_inst = gen_demo(25, "Gen demo text")
for _ in range(26):
print(next(gen_inst))
Gen demo text
Gen demo text
Gen demo text
Gen demo text
. ..
Traceback (most recent call last):
...
StopIteration
[FAQ] Частые вопросы
Функции vs процедуры — в чём отличие?
Процедура — это единичная инструкция, функция — подпрограмма, которая выполняет действие.
Для чего нужна область видимости?
Чтобы решить конфликт имен.
Как провести распаковку множества?
Нужно присвоить его такому же количеству переменных, сколько в нём содержится объектов.
Обязательно ли наличие аргументов для функции?
Нет, но чаще у функции есть один или несколько аргументов.
Главное о функциях в Python
- У каждой функции есть своя область видимости, в которую входят все пространства имен уровнем выше.
- Если явно не задать возвращаемое значение, функция вернет объект типа None.
- Функция с одной или несколькими инструкциями yield будет генератором.
- В Python аргументы функции бывают двух видов — именованные и позиционные. Оба типа аргументов могут быть переменной длины.
Освойте профессию Python-разработчика за 10 месяцев в онлайн-университете Skypro. Вас ждет много практики в среде коммерческой разработки. Научитесь делать авторизацию, оплату, комментарии, фильтрацию и пользоваться библиотеками Python. Писать серверы для магазина, приложения или игры. Разрабатывать сложную архитектуру сервисов.
Выпуститесь с четырьмя проектами в портфолио, дипломом государственного образца, цепляющим резюме и готовностью к работе в больших компаниях. В любой момент сможете вернуться к материалам: доступ к курсу пожизненный.
Функции Python
❮ Предыдущая Далее ❯
Функция — это блок кода, который запускается только при вызове.
Вы можете передавать данные, известные как параметры, в функцию.
В результате функция может возвращать данные.
Создание функции
В Python функция определяется с помощью определения ключевое слово:
Пример
def my_function():
print(«Привет от функции»)
Вызов функции
Чтобы вызвать функцию, используйте имя функции, за которым следуют круглые скобки:
Пример
def my_function():
print(«Привет от функции»)
my_function()
Попробуйте сами »
Аргументы
Информация может передаваться в функции как аргументы.
Аргументы указываются после имени функции в круглых скобках. Вы можете добавить столько аргументов, сколько хотите, просто разделите их запятой.
В следующем примере есть функция с одним аргументом (fname). Когда функция вызывается, мы передаем имя, который используется внутри функции для печати полного имени:
Пример
def my_function( fname ):
print(fname + «Refsnes»)
my_function( «Эмиль» )
my_function( «Tobias» )
my_function( «Linus3 90 itself» 900 »
Аргументы часто сокращаются до args в документации Python.
Параметры или аргументы?
Термины параметр и аргумент могут использоваться для одного и того же: информации, которая передается в функцию.
С точки зрения функции:
Параметр — это переменная, указанная в скобках в определении функции.
Аргумент — это значение, которое передается функции при ее вызове.
Количество аргументов
По умолчанию функция должна вызываться с правильным количеством аргументов. Это означает, что если ваша функция ожидает 2 аргумента, вы должны вызвать функцию с 2-мя аргументами, не больше и не меньше.
Пример
Эта функция ожидает 2 аргумента и получает 2 аргумента:
def my_function(fname, lname):
print(fname + » » + lname)
my_function(«Emil», «Refsnes»)
Попробуйте сами »
Если вы попытаетесь вызвать функцию с 1 или 3 аргументами, вы получите ошибку:
Пример
Эта функция ожидает 2 аргумента, но получает только 1:
def my_function(fname, lname):
print(fname + » » + lname)
my_function(«Эмиль»)
Попробуйте сами »
Произвольные аргументы, *args
Если вы не знаете, сколько аргументов который будет передан в вашу функцию,
добавьте *
перед именем параметра в определении функции.
Таким образом функция получит кортеж аргументов и может получить доступ к соответствующим элементам:
Пример
Если количество аргументов неизвестно, добавьте *
перед именем параметра:
def my_function(*kids):
print(«Самый младший ребенок
is » + kids[2])
my_function(«Эмиль», «Тобиас», «Линус»)
Попробуйте сами »
Произвольные аргументы часто сокращаются до *args в документации Python.
Аргументы ключевого слова
Вы также можете отправлять аргументы с помощью ключа = значения синтаксиса.
Таким образом, порядок аргументов не имеет значения.
Пример
def my_function(child3, child2, child1):
print(«Самый младший ребенок
is » + child3)
my_function(child1 = «Emil», child2 = «Tobias», child3 = «Linus»)
Попробуйте сами »
Фраза Keyword Arguments часто сокращается до kwargs в Python документации
Произвольные аргументы ключевого слова, **kwargs
Если вы не знаете, сколько аргументов ключевого слова будет передано в вашу функцию,
добавить две звездочки: **
перед именем параметра в определении функции.
Таким образом, функция получит словарь аргументов и сможет получить доступ к соответствующим элементам:
Пример
Если количество аргументов ключевого слова неизвестно, добавьте двойной **
перед именем параметра:
def my_function(**kid):
print(«Его фамилия » + kid[«lname»])
my_function(fname = «Tobias», lname = «Refsnes»)
Попробуйте сами »
Произвольные аргументы Kword часто сокращаются до **kwargs в документации Python.
Значение параметра по умолчанию
В следующем примере показано, как использовать значение параметра по умолчанию.
Если мы вызываем функцию без аргумента, она использует значение по умолчанию:
Пример
def my_function( country = «Норвегия» ):
print(«Я из » +
страна)
my_function(«Швеция»)
my_function(«Индия»)
my_function()
my_function(«Бразилия»)
Попробуйте сами »
Передача списка в качестве аргумента
Вы можете отправлять любые данные типы аргументов функции (строка, число, список, словарь и т. д.), и это будет рассматриваться как один и тот же тип данных внутри функции.
Напр. если вы отправляете список в качестве аргумента, он все равно будет списком, когда он достигает функции:
Пример
def my_function(food):
для x в еде:
print(x)
fruit = [«яблоко», «банан», «вишня»]
my_function(fruits)
Попробуйте сами »
Возвращаемые значения
Чтобы функция возвращала значение, используйте вернуть
оператор:
Пример
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
Попробуйте сами »
Определение прохода не может быть пустым, но если у вас по какой-то причине есть определение функции
без содержимого, поместите в оператор pass
, чтобы избежать ошибки.Пример
def myfunction():
pass
Попробуйте сами »
Рекурсия
Python также поддерживает рекурсию функций, что означает, что определенная функция может вызывать сама себя.
Рекурсия является общей математической и программной концепцией. Это означает, что функция вызывает сама себя. Преимущество этого заключается в том, что вы можете перебирать данные для достижения результата.
Разработчик должен быть очень осторожен с рекурсией, поскольку может быть очень легко написать функцию, которая никогда не завершится, или функцию, которая использует избыточное количество памяти или мощности процессора. Однако при правильном написании рекурсия может быть очень эффективным и математически элегантным подходом к программированию.
В этом примере tri_recursion() — это функция, которую мы определили для вызова самой себя («recurse»). Мы используем переменную k в качестве данных, которые уменьшаются (-1) каждый раз, когда мы рекурсивно. Рекурсия заканчивается, когда условие не больше 0 (т. е. когда оно равно 0).
Новому разработчику может потребоваться некоторое время, чтобы понять, как именно это работает, лучший способ выяснить это — протестировать и изменить его.
Пример
Пример рекурсии
защита tri_recursion(k):
если (к > 0):
результат = k + tri_recursion (k — 1)
печать (результат)
еще:
результат = 0
return result
print(«\n\nРезультаты примера рекурсии»)
tri_recursion(6)
Попробуйте сами »
Проверьте себя с помощью упражнений
Упражнение:
Создайте функцию с именем my_function
.
: print("Привет из функции")
Начать упражнение
❮ Предыдущий Далее ❯
Функции Python (def): определение с примерами
В этой статье вы узнаете о функциях, о том, что такое функция, о синтаксисе, компонентах и типах функций. Кроме того, вы научитесь создавать функцию на Python.
Что такое функция в Python?
В Python функция представляет собой группу связанных операторов, выполняющих определенную задачу.
Функции помогают разбить нашу программу на более мелкие модульные фрагменты. По мере того, как наша программа становится все больше и больше, функции делают ее более организованной и управляемой.
Кроме того, он позволяет избежать повторения и делает код пригодным для повторного использования.
Синтаксис функции
def имя_функции (параметры): """строка документации""" оператор(ы)
Выше показано определение функции, состоящее из следующих компонентов.
- Ключевое слово
def
, обозначающее начало заголовка функции. - Имя функции для уникальной идентификации функции. Именование функций следует тем же правилам написания идентификаторов в Python.
- Параметры (аргументы), через которые мы передаем значения в функцию. Они являются необязательными.
- Двоеточие (:) для обозначения конца заголовка функции.
- Необязательная строка документации (docstring) для описания того, что делает функция.
- Один или несколько допустимых операторов Python, составляющих тело функции. Операторы должны иметь одинаковый уровень отступа (обычно 4 пробела).
- Необязательный оператор
return
для возврата значения из функции.
Пример функции
def приветствие(имя): """ Эта функция приветствует человек прошел как параметр """ print("Привет, " + name + ". Доброе утро!")
Как вызвать функцию в python?
После того, как мы определили функцию, мы можем вызвать ее из другой функции, программы или даже из командной строки Python. Чтобы вызвать функцию, мы просто набираем имя функции с соответствующими параметрами.
>>> приветствовать('Пол') Здравствуйте, Пол. Доброе утро!
Попробуйте запустить приведенный выше код в программе Python с определением функции, чтобы увидеть результат.
приветствие по умолчанию (имя): """ Эта функция приветствует человек прошел как параметр """ print("Здравствуйте, " + имя + ". Доброе утро!") приветствие('Пол')
Примечание : В python определение функции всегда должно присутствовать перед вызовом функции. В противном случае мы получим ошибку. Например,
# вызов функции приветствовать('Пол') # определение функции приветствие (имя): """ Эта функция приветствует человек прошел как параметр """ print("Здравствуйте, " + имя + ". Доброе утро!") # Ошибка: имя 'greet' не определено
Строки документации
Первая строка после заголовка функции называется строкой документации и является сокращением от строки документации. Он кратко используется для объяснения того, что делает функция.
Хотя документация не является обязательной, это хорошая практика программирования. Если вы не можете вспомнить, что ели на обед на прошлой неделе, всегда документируйте свой код.
В приведенном выше примере у нас есть строка документации сразу под заголовком функции. Обычно мы используем тройные кавычки, чтобы строка документации могла расширяться до нескольких строк. Эта строка доступна нам как __doc__
атрибут функции.
Например, :
Попробуйте запустить в оболочке Python следующее, чтобы увидеть результат.
>>> print(приветствие.__doc__) Эта функция приветствует человек прошел как a параметр
Чтобы узнать больше о строках документации в Python, посетите Python Docstrings.
Оператор return
Оператор return
используется для выхода из функции и возврата к тому месту, откуда она была вызвана.
Синтаксис возврата
return [список_выражений]
Этот оператор может содержать выражение, которое вычисляется и возвращается значение. Если в операторе нет выражения или сам оператор return
отсутствует внутри функции, то функция вернет объект None
.
Например:
>>> print(greet("Май")) Привет, Мэй. Доброе утро! Нет
Здесь, Нет
— это возвращаемое значение, так как Greet()
напрямую печатает имя, и оператор return
не используется.
Пример возврата
def absolute_value(num): """Эта функция возвращает абсолютное значение введенного числа""" если число >= 0: возвращаемое число еще: возврат - число печать (абсолютное_значение (2)) print(absolute_value(-4))
Вывод
2 4
Как функция работает в Python?
Работа функций в PythonОбласть действия и время жизни переменных
Область действия переменной — это часть программы, в которой распознается переменная. Параметры и переменные, определенные внутри функции, не видны снаружи функции. Следовательно, они имеют локальную область применения.
Время жизни переменной — это период, в течение которого переменная существует в памяти. Время жизни переменных внутри функции равно времени ее выполнения.
Они уничтожаются, как только мы возвращаемся из функции. Следовательно, функция не запоминает значение переменной из своих предыдущих вызовов.
Вот пример, иллюстрирующий область действия переменной внутри функции.
функция my_func(): х = 10 print("Значение внутри функции:",x) х = 20 моя_функция() print("Значение вне функции:",x)
Вывод
Значение внутри функции: 10 Значение вне функции: 20
Здесь мы видим, что значение x изначально равно 20. Хотя функция my_func()
изменила значение x на 10, это не повлияло на значение вне функции.
Это связано с тем, что переменная x внутри функции отличается (локальная по отношению к функции) от внешней. Хотя у них одинаковые имена, это две разные переменные с разными областями действия.
С другой стороны, переменные вне функции видны изнутри. Они имеют глобальный охват.
Мы можем прочитать эти значения внутри функции, но не можем изменить (записать) их. Чтобы изменить значение переменных вне функции, их необходимо объявить как глобальные переменные с помощью ключевого слова 9.0120 глобальный .
Типы функций
По сути, мы можем разделить функции на следующие два типа:
- Встроенные функции — функции, встроенные в Python.
- Пользовательские функции — функции, определяемые самими пользователями.
Аргументы функции Python (по умолчанию, ключевое слово и произвольное)
В Python можно определить функцию, которая принимает переменное количество аргументов. В этой статье вы научитесь определять такие функции, используя значения по умолчанию, ключевые слова и произвольные аргументы.
Аргументы
В разделе, посвященном пользовательским функциям, мы узнали об определении функции и ее вызове. В противном случае вызов функции приведет к ошибке. Вот пример.
приветствие по умолчанию (имя, сообщение): """Эта функция приветствует человек с предоставленным сообщением""" print("Привет", имя + ', ' + сообщение) приветствие("Моника", "Доброе утро!")
Вывод
Привет Моника, Доброе утро!
Здесь функция welcome()
имеет два параметра.
Поскольку мы вызвали эту функцию с двумя аргументами, она работает гладко, и мы не получаем никаких ошибок.
Если мы вызовем его с другим количеством аргументов, интерпретатор покажет сообщение об ошибке. Ниже приведен вызов этой функции с одним и без аргументов вместе с соответствующими сообщениями об ошибках.
>>> welcome("Моника") # только один аргумент TypeError: welcome() отсутствует 1 обязательный позиционный аргумент: 'msg'
>>> welcome() # без аргументов TypeError: Greeting() отсутствует 2 обязательных позиционных аргумента: 'name' и 'msg'
Переменные аргументы функции
До сих пор функции имели фиксированное количество аргументов. В Python есть и другие способы определения функции, которая может принимать переменное количество аргументов.
Ниже описаны три различных формы этого типа.
Аргументы Python по умолчанию
Аргументы функций могут иметь значения по умолчанию в Python.
Мы можем указать значение по умолчанию для аргумента, используя оператор присваивания (=). Вот пример.
приветствие по умолчанию (имя, msg = "Доброе утро!"): """ Эта функция приветствует человек с предоставленное сообщение. Если сообщение не предоставлено, по умолчанию "Хорошо утро!" """ print("Привет", имя + ', ' + сообщение) приветствовать("Кейт") приветствие("Брюс", "Как дела?")
Вывод
Привет Катя, Доброе утро! Привет, Брюс, как дела?
В этой функции параметр имя
не имеет значения по умолчанию и является обязательным (обязательным) во время вызова.
С другой стороны, параметр msg
имеет значение по умолчанию "Доброе утро!"
. Таким образом, это необязательно во время разговора. Если указано значение, оно перезапишет значение по умолчанию.
Любое количество аргументов в функции может иметь значение по умолчанию. Но как только у нас есть аргумент по умолчанию, все аргументы справа от него также должны иметь значения по умолчанию.
Это означает, что аргументы не по умолчанию не могут следовать за аргументами по умолчанию. Например, если бы мы определили заголовок функции выше как:
def welcome(msg = "Доброе утро!", name):
Мы получили бы ошибку вида:
SyntaxError: аргумент не по умолчанию следует за аргументом по умолчанию
Аргументы ключевого слова Python
Когда мы вызываем функцию с некоторыми значениями, эти значения присваиваются аргументам в соответствии с их положением.
Например, в приведенной выше функции приветствие()
, когда мы вызвали ее как приветствие("Брюс", "Как дела?")
, значение "Брюс"
присваивается аргументу имя и аналогично "Как дела?" с
по сообщение .
Python позволяет вызывать функции с использованием аргументов ключевого слова. Когда мы вызываем функции таким образом, порядок (положение) аргументов может быть изменен. Все последующие вызовы вышеуказанной функции действительны и дают одинаковый результат.
# 2 аргумента ключевого слова приветствие(имя = "Брюс", msg = "Как дела?") # 2 аргумента ключевого слова (не по порядку) приветствие(msg = "Как дела?", name = "Брюс") 1 позиционный, 1 ключевой аргумент приветствие("Брюс", msg = "Как дела?")
Как мы видим, мы можем смешивать позиционные аргументы с ключевыми словами во время вызова функции. Но мы должны помнить, что аргументы ключевого слова должны следовать за позиционными аргументами.
Наличие позиционного аргумента после аргументов ключевого слова приведет к ошибкам. Например, вызов функции выглядит следующим образом:
приветствие(name="Брюс","Как дела?")
Приведет к ошибке:
SyntaxError: не ключевое слово arg после ключевого слова arg
Произвольные аргументы Python
Иногда мы не знаем заранее количество аргументов, которые будут переданы в функцию.