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. Функция задокументирована (испольузется формат описания сигнатуры reStructuredText). Кроме строки документации тело функции не содержит инструкций, тем не менее функция возвращает 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 (вызываемый)»: Аргументы вызова Параметры вызываемых объектов
У нас есть представительство в Facebook. Ссылка в самом низу страницы.
создать, вызвать, разные параметры и примеры аргументов
В компьютерной терминологии функция — это блок программного кода, который используется несколько раз для решения задачи. Тело функции — набор инструкций, которые поочередно исполняют в процессе вызова.
Обычно у функции есть один или несколько аргументов. Их указывают в скобках во время вызова. Они делятся на обязательные (позиционные) и со значением по ключу (именованные).
Синтаксис функций в Python
Любые функции и методы начинаются с инструкции def (от английского define — «определять»). За def в Python идет название функции, после — набор аргументов. Двоеточие в конце открывает блок тела функции, которое располагают с новой строки.
В Python нет фигурных скобок для блока кода. Вместо них применяют отступы в четыре пробела. Новая инструкция — новая строка. Или можно отделить их точкой с запятой.Чтобы завершить функцию и вернуть из нее значение, используют ключевое слово return. Если этого не указать, то, когда тело функции достигает конца, функция завершится. Возвращается объект типа None.
Аргументы и их виды
Если надо передавать аргументы через функцию, нужно расположить их в скобках по порядку. Исключение — именованные аргументы. Такие аргументы могут идти в любом порядке, но сначала — позиционные.
🚀 Позиционные
Это обязательные аргументы.
Чтобы функция работала корректно, важно размещать их в определенном порядке.
def addfunc(val1, val2):
return val1 + val2
result = addfunc(3, 2)
print(result)
5
addfunc() # вызов без аргументов
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, Alex
Атрибуту 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 3 Примечания[ ГЛАВНАЯ | ЛИНГ 1330/2330] | Пользовательские функции<< Предыдущее примечание Следующее примечание >> | |||||||||||||||||||||||||||||||||
На этой странице: def, return, строки документации, help(), функции, возвращающие значение, и функции void.![]() Функции: основыДавайте разберемся с алгеброй старой школы. Вы выучили «функции» примерно так:f(x) = x 2 + 1 В Python определение функции работает следующим образом. def — это ключевое слово для определения функции. За именем функции следует параметр(ы) в (). Двоеточие : сигнализирует о начале тела функции, отмеченного отступом. Внутри тела функции оператор return определяет возвращаемое значение. После завершения определения функции вызов функции с аргументом возвращает значение.
Несколько параметров, строка документацииНиже приведена немного более сложная функция. Она принимает два аргумента, имеет условное выражение в теле функции и начинается со строки:
Функции: Возвращение против ПустотыВы можете подумать: «Подождите минутку, я не видел ни одного оператора возврата в учебнике по определению функций». Вы правы — функция get_legal(), определенная Эдом, не включала никаких операторов возврата, а только набор функций печати. В Python можно составить функцию без оператора возврата. Такие функции называются void и возвращают None, специальный объект Python для «ничего». Вот пример функции void:
Возвращающая функция дает вам строку (примечание »), а функция печати показывает вывод строки на печать — обратите внимание на отсутствие кавычек. Обратите внимание, что возвращаемое значение отображается только в среде интерактивной оболочки; в сценарии только команды печати приводят к отображению вывода.
Опять же, поскольку функции void ничего не возвращают, они не могут этого сделать. Ниже get_ing(‘eat’) передается функции len() для успешного результата. С len(print_ing(‘eat’)) печать происходит независимо, а затем возникает ошибка типа:
По правде говоря, функции возвращающего типа гораздо более похожи на функции и полезны. В других языках функции типа void вообще не называются функциями — вместо этого они называются процедурами. |
Ключевое слово Python def — GeeksforGeeks
Улучшить статью
Сохранить статью
- Уровень сложности: Средний
- Последнее обновление: 14 фев, 2023
Улучшить статью
Сохранить статью
Ключевое слово Python def используется для определения функции, оно помещается перед именем функции, которое предоставляется пользователем для создания определяемой пользователем функции. В python функция — это логическая единица кода, содержащая последовательность операторов с отступом под именем, заданным с помощью «9».0238 по умолчанию ” ключевое слово. В python ключевое слово def является наиболее часто используемым ключевым словом.
Синтаксис:
def имя_функции:
операторы определения функции.
.. Использование ключевого слова def:
- В случае классов ключевое слово def используется для определения методов класса.
- Ключевое слово def также требуется для определения специальной функции-члена класса, такой как __init__().
Возможное практическое применение заключается в том, что он обеспечивает функцию повторного использования кода, вместо того, чтобы писать фрагмент кода снова и снова, мы можем определить функцию и написать код внутри функции с помощью по умолчанию ключевое слово. Это будет более понятно на иллюстрированном примере, приведенном ниже. Возможно, может быть много применений def в зависимости от вариантов использования.
Пример 1: Использование ключевого слова def.
В этом примере мы собираемся создать функцию, определяемую пользователем, используя ключевое слово def.
Python3
9 8 "IS =" 9 8 "IS =" 9 Пример 2: Пользователь определяет функцию с первыми 10 простыми числами. + Результат Пример 3: Пользователь определяет функцию с помощью факториала. : 8 8 8 8 8 8 8 8 8 8 8 8 8 |


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
0)
{'kone': 'One', 'ktwo': 2, 'kthree': 3.0}
..
2
A few of example text...
3
A few of example text...
4
A few of example text...
5
..
Traceback (most recent call last):
...
StopIteration
Оба типа аргументов могут быть переменной длины.
Она принимает два аргумента, имеет условное выражение в теле функции и начинается со строки:
Различие регистра игнорируется.
>>>
В Python можно составить функцию без оператора возврата. Такие функции называются void и возвращают None, специальный объект Python для «ничего». Вот пример функции void:
Возвращающая функция дает вам строку (примечание »), а функция печати показывает вывод строки на печать — обратите внимание на отсутствие кавычек. Обратите внимание, что возвращаемое значение отображается только в среде интерактивной оболочки; в сценарии только команды печати приводят к отображению вывода.
Опять же, поскольку функции void ничего не возвращают, они не могут этого сделать. Ниже get_ing(‘eat’) передается функции len() для успешного результата. С len(print_ing(‘eat’)) печать происходит независимо, а затем возникает ошибка типа:
По правде говоря, функции возвращающего типа гораздо более похожи на функции и полезны. В других языках функции типа void вообще не называются функциями — вместо этого они называются процедурами.
..
0277 Выход
0279 
