Аргументы функций: обязательные, ключевые, со значением по умолчанию, произвольной длины
Функция может принимать произвольное количество аргументов или не принимать их вовсе. Вызывая функцию, можно передавать ей следующие типы аргументов:
Обязательные аргументы (Required arguments), Ключевые аргументы (Keyword argument), Аргументы со значением по умолчанию (Default argument), Аргументы произвольной длины (Variable-length argumens)
Обязательные аргументы
При описании функции указываются аргументы, при вызове функции указываются аргументы в том же количестве и том же порядке, как и при описании. В предыдущих примерах все аргументы были обязательными.
Ключевые аргументы
В этом случае для передачи аргументов функции используется имя (ключ) вместо позиции (как было до сих пор). Рассмотрим пример
def f(osn, pok): #функция возводит osn в степень pok
return osn**pok
print(f(osn=2, pok=3))
print(f(pok=3, osn=2))#порядок параметров при вызове может не сопадать с порядком при описании,
#если указывать имя параметра вместе со значением при вызове
Аргументы со значением по умолчанию
При описании функции можно указывать значение аргументов по умолчанию, тогда такой аргумент при вызове может отсутствовать. Рассмотрим пример
#функция возводит osn в степень pok, параметр osn будет иметь значение по умолчанию 1, параметр pok будет иметь значение по умолчанию 1
def f(osn=1, pok=1):
return osn**pok
print(f(2, 3))# получим 2 в степени 3
print(f(2)) # получим 2 в степени 1
print(f()) # получим 2 в степени 1
Если в функции имеется несколько аргументов со значением по умолчанию, то при вызове можно опустить только один последний или несколько аргументов. Например, в предыдущем примере можно при вызове опустить один последний аргумент или два аргумента. Опустить только первый аргумент, указав второй нельзя. Можно опустить только первый аргумент, но второй должен быть указан как ключевой
Аргументы произвольной длины
Иногда возникает ситуация, когда заранее не известно, какое количество аргументов необходимо принять функции. В этом случае следует использовать аргументы произвольной длины. Они задаются именем переменной, перед которой ставится звездочка (*) или две звездочки (**).
Когда мы объявляем параметр со звёздочкой (*args), то все позиционные аргументы, начиная с этой позиции и до конца, будут собраны в кортеж под именем args.
Аналогично, когда мы объявляем параметры с двумя звёздочками (**param), все ключевые аргументы, начиная с этой позиции и до конца, будут собраны в словарь под именем param.
Оба способа объявления аргументов можно использовать в одной функции.
Глобальные и локальные переменные. Нелокальная область видимости.
Переменные, которые появились первый раз внутри функции, являются локальными, доступ к ним возможен только внутри этой функции. Область видимости всех переменных ограничена блоком, в котором они объявлены, начиная с точки объявления имени. В других функциях и в основной программе доступ к значениям локальных переменных невозможен. Глобальными переменными называются переменные, которые появились в основной программе. Доступ к значениям возможен в основной программе, чтобы получить доступ к глобальным переменным внутри функции надо объявить эту переменную глобальной с помощью директивы global.
Рассмотрим на примере
def function(a):
c = 5 #локальная переменная
global d #глобальная переменная
d = 100 #изменяем глобальную переменную
a = a + 1
print('Внутри функции d=', d, 'f=', f, 'a=', a) #Внутри функции d= 100 f= 1 a= 2
d = 10 #глобальная переменная
f = 1 #глобальная переменная
print('До вызова функции d=',d, 'f=', f) #До вызова функции d= 10 f= 1
function(f)
print('После вызова функции d=',d, 'f=', f) #После вызова функции d= 100 f= 1
!!! Аргументы передаются в функцию всегда по значению. Т.е. изменения значения аргумента внутри функции не отобразятся на значении переменной, которую подставили вместо этого аргумента при вызове функции.
Попробуем не писать слово global перед переменной d
def function(a):
c = 5 #локальная переменная
d = 100 #изменяем переменную, которая в данном случае будет локальной
a = a + 1
print('Внутри функции d=', d, 'f=', f, 'a=', a) #Внутри функции d= 100 f= 1 a= 2
d = 10 #глобальная переменная
f = 1 #глобальная переменная
print('До вызова функции d=', d, 'f=', f) #До вызова функции d= 10 f= 1
function(f)
print('После вызова функции d=', d, 'f=', f) #После вызова функции d= 10 f= 1
В этом случае переменная d будет локальной внутри функции, но существует и глобальная переменная d. Т.е. имена глобальной и локальной переменных совпадают. Внутри функции изменили значение аргумента (a = a + 1). Эти изменения не отразились на значении глобальной переменной f, ее значение осталось равно 1
Но есть исключения. Если аргументом является изменяемая последовательность и изменить значение элемента последовательности, то это отразиться на значении глобальной переменной
def fuction(a):
a[0] = a[0] + 10
print('Внутри функции', *a) #Внутри функции 11 2 3 4 5
a = [1, 2, 3, 4, 5]
print('До вызова функции', *a) #До вызова функции 1 2 3 4 5
fuction(a)
print('После вызова функции', *a) #После вызова функции 11 2 3 4 5
Но если изменять не отдельный элемент, а целиком переприсваивать последовательность, то глобальная переменная не изменится
def fuction(a):
a = [11, 12, 13, 14]
print('Внутри функции', *a) #Внутри функции 11 12 13 14
a = [1, 2, 3, 4, 5]
print('До вызова функции', *a) #До вызова функции 1 2 3 4 5
fuction(a)
print('После вызова функции', *a) # После вызова функции 1 2 3 4 5
Нелокальная область видимости
Нелокальные области видимости встречаются, когда вы определяете функции внутри функций. Появилось это понятие в Python 3 вместе с ключевым словом nonlocal. Логика его написания примерно такая же, как и у global. Однако у nonlocal есть особенность. Nonlocal используется чаще всего во вложенных функциях, когда мы хотим дать интерпретатору понять, что для вложенной функции определенная переменная не является локальной, но она и не является глобальной в общем смысле.
