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()
В ходе исполнения функции формируется новая символьная таблица с локальными переменными функции: все назначения переменных оказываются в ней. При обращении к переменной, сначала производится попытка отыскать её в локальной символьной таблице, далее в таблицах обрамляющих функций, далее в глобальной таблице, и, наконец, в таблице встроенных имён.
global
) нельзя.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 (вызываемый)»: Аргументы вызова Параметры вызываемых объектов
Зарегистрированные пользователи могут публиковать свои мнения относительно Книг, Видео, Статей других авторов и прочего в разделе Обсуждений.
Функции в Python для начинающих
В этой части мы изучим функции — составные инструкции, которые могут принимать данные ввода, выполнять указания и возвращать данные вывода. Функции позволяют определять и повторно использовать определенную функциональность в компактной форме.
Вызвать функцию — значит передать ей входные данные, необходимые для выполнения и возвращения результата.
Функции в Python похожи на математические функции из алгебры. Например, в алгебре функция определяется как‑то так:
f(x) = x * 2
Левая часть определяет функцию f, принимающую один параметр, x. А правая часть — это определение функции, которое использует переданный параметр x, чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.
Как в Python функция записывается следующим образом: имя_функции (параметры_через_запятую). Чтобы вызвать функцию, после ее имени нужно указать круглые скобки и поместить внутрь параметры, отделив каждый из них запятой. Для создания функций в Python выберите ее имя, определите параметры, укажите, что функция должна делать и какое значение возвращать.
def имя\_функции(параметры) : определениие _функции
Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:
def f(x): return x * 2
Ключевое слово def сообщает Python, что вы определяете функцию. После def вы указываете имя функции; оно должно отвечать тем же правилам, что и имена переменных. Согласно конвенции, в имени функции нельзя использовать заглавные буквы, а слова должны быть разделены подчеркиванием вот_так.
Как только вы присвоили своей функции имя, укажите после него круглые скобки. Внутри скобок должен содержаться один или несколько параметров.
После скобок ставится двоеточие, а новая строка начинается с отступа в четыре пробела. Любой код с отступом в четыре пробела после двоеточия является телом функции. В этом случае тело нашей функции состоит только из одной строки:
return x * 2
Ключевое слово return используется для определения значения, которое функция возвращает при вызове.
Чтобы вызвать функцию в Python, мы используем синтаксис
Ниже описан вызов функции f из предыдущего примера с параметром 2.
f(2)
Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print.
# Продолжение # предыдущего примера def f(x): return x * 2 result = f(2) print(result) # 4
Вы можете сохранить результат, возвращаемый вашей функцией, в переменной и использовать это значение в программе позднее.
def f(x): return x + 1 z = f(4) if z == 5: print("z равно 5") else: print ("z не равно 5")
У функции может быть один параметр, несколько параметров или вообще их не быть. Чтобы определить функцию, не требующую параметров, оставьте круглые скобки пустыми.
def f(): return 1 + 1 result = f() print(result) # 2
Если хотите, чтобы функция принимала больше одного параметра, отделите каждый параметр в скобках запятой.
def f(x, y, z): return x + y + z result = f(1, 2, 3) print(result) # 6
Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None.
def f(): z = 1 + 1 result = f() print (result) # None
Обязательные и необязательные параметры
Функция может принимать параметры двух типов. Те, что встречались вам до этого, называются обязательными параметрами. Когда пользователь вызывает функцию, он должен передать в нее все обязательные параметры, иначе Python сгенерирует исключение.
В Python есть и другой вид параметров — опциональные. Опциональные параметры определяются с помощью следующего синтаксиса: имя_функции(имя_параметра = значение_параметра). Как и обязательные, опциональные параметры нужно отделять запятыми. Ниже приведен пример функции, в коде которой используется опциональный параметр.
def f(x=2): return x**x print (f()) # 4 print (f(4)) # 16
Сначала функция вызывается без передачи параметра. Так как параметр необязательный, x автоматически становится равен 2, и функция возвращает 4.
Затем та же функция вызывается с параметром 4. То есть x будет равен 4 и функция вернет 16. Вы можете определить функцию, которая принимает как обязательные, так и опциональные параметры, но обязательные нужно определять в первую очередь.
def add(x, y=10): return x + y result = add(2) print(result)
дальше
Функции 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 (с примерами)
В этом руководстве мы узнаем о функциях и выражениях функций Python с помощью примеров.
Функция — это блок кода, выполняющий определенную задачу.
Предположим, вам нужно создать программу для создания круга и его раскрашивания. Вы можете создать две функции для решения этой проблемы:
- создать функцию круга
- создать функцию цвета
Разделение сложной задачи на более мелкие части делает нашу программу простой для понимания и повторного использования.
Типы функций
В программировании на Python есть два типа функций:
- Стандартные библиотечные функции — это встроенные в Python функции, доступные для использования.
- Пользовательские функции — Мы можем создавать собственные функции на основе наших требований.
Объявление функции Python
Синтаксис объявления функции:
def имя_функции(аргументы): # тело функции return
Здесь,
-
def
— ключевое слово, используемое для объявления функции -
имя_функции
— любое имя, присвоенное функции -
аргументов
— любое значение передается в функцию -
return
(необязательно) — возвращает значение из функции
Давайте посмотрим на пример,
defgreet(): print('Привет, мир!')
Здесь мы создали функцию с именем welcome()
. Он просто печатает текст Hello World!
.
Эта функция не имеет аргументов и не возвращает никаких значений. Мы узнаем об аргументах и операторах возврата позже в этом руководстве.
Вызов функции в Python
В приведенном выше примере мы объявили функцию с именем welcome()
.
по умолчанию приветствие(): print('Hello World!')
Теперь, чтобы использовать эту функцию, нам нужно ее вызвать.
Вот как мы можем вызвать функцию greet()
в Python.
# вызов функции приветствие()
Пример: функция Python
def приветствие(): print('Привет, мир!') # вызов функции приветствовать() print('Внешняя функция')
Вывод
Привет, мир! Внешняя функция
В приведенном выше примере мы создали функцию с именем welcome()
. Вот как работает программа:
Здесь
- При вызове функции управление программой переходит к определению функции.
- Все коды внутри функции выполняются.
- Управление программой переходит к следующему оператору после вызова функции.
Аргументы функции Python
Как упоминалось ранее, функция также может иметь аргументы. Аргумент — это значение, которое принимает функция. Например,
# функция с двумя аргументами определение add_numbers (число1, число2): сумма = число1 + число2 print('Сумма:',сумма) # функция без аргумента определение add_numbers(): # код
Если мы создаем функцию с аргументами, нам нужно передать соответствующие значения при их вызове. Например,
# вызов функции с двумя значениями add_numbers(5, 4) # вызов функции без значения add_numbers()
Здесь add_numbers(5, 4)
указывает, что аргументы num1
и num2
получат значения 5 и 4 соответственно.
Пример 1: аргументы функции Python
# функция с двумя аргументами определение add_numbers (число1, число2): сумма = число1 + число2 печать("Сумма: ",сумма) # вызов функции с двумя значениями add_numbers(5, 4) # Вывод: Сумма: 9
В приведенном выше примере мы создали функцию с именем add_numbers()
с аргументами: num1 и num2 .
Мы также можем вызвать функцию, указав имя аргумента как:
add_numbers(num1 = 5, num2 = 4)
В Python мы называем это аргументом ключевого слова (или именованным аргументом). Приведенный выше код эквивалентен
add_numbers(5, 4)
Оператор return в Python
Функция Python может возвращать или не возвращать значение. Если мы хотим, чтобы наша функция возвращала какое-то значение при вызове функции, мы используем оператор return
. Например,
def add_numbers(): ... return sum
Здесь мы возвращаем переменную sum
в вызов функции.
Примечание: Оператор return
также означает, что функция завершилась. Никакой код после возврата не выполняется.
Пример 2: возврат функции, тип
# определение функции определение find_square (число): результат = число * число вернуть результат # вызов функции квадрат = найти_квадрат (3) print('Квадрат:',квадрат) # Вывод: Square: 9
В приведенном выше примере мы создали функцию с именем find_square()
. Функция принимает число и возвращает квадрат числа.
Пример 3: Сложение двух чисел
# функция, которая складывает два числа определение add_numbers (число1, число2): сумма = число1 + число2 возвращаемая сумма # вызов функции с двумя значениями результат = add_numbers(5, 4) print('Сумма:', результат) # Вывод: Сумма: 9
Библиотечные функции Python
В Python стандартные библиотечные функции — это встроенные функции, которые можно использовать непосредственно в нашей программе. Например,
-
print()
— печатает строку в кавычках -
sqrt()
— возвращает квадратный корень из числа -
pow()
— возвращает степень числа
Эти библиотечные функции определены внутри модуля. И, чтобы использовать их, мы должны включить модуль в нашу программу.
Например, sqrt()
определяется внутри модуля math
.
Пример 4: библиотечная функция Python
import math # sqrt вычисляет квадратный корень квадратный_корень = math. sqrt(4) print("Квадратный корень из 4 равен",square_root) # pow() вычисляет мощность мощность = мощность (2, 3) print("2 в степени 3 равно",степень)
Вывод
Квадратный корень из 4 равен 2,0 2 в степени 3 равно 8
В приведенном выше примере мы использовали
-
math.sqrt(4)
— для вычисления квадратного корня из 4 -
pow(2, 3)
— вычисляет степень числа, т.е. 2 3
Здесь обратите внимание на оператор
import math
Так как sqrt()
определен внутри модуля math
, мы должны включить его в нашу программу.
Преимущества использования функций
1. Повторно используемый код . Мы можем использовать одну и ту же функцию несколько раз в нашей программе, что делает наш код многоразовым. Например,
# определение функции защита get_square (число): вернуть число * число для я в [1,2,3]: # вызов функции результат = get_square (я) print('Квадрат', i, '=', результат)
Вывод
Квадрат 1 = 1 Квадрат 2 = 4 Квадрат 3 = 9
В приведенном выше примере мы создали функцию с именем get_square()
для вычисления квадрата числа.