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

Если интерпретатор Питона, выполняя тело функции, встречает return, то он "забирает" значение, указанное после этой команды, и "уходит" из функции.

def cylinder() : r = float (input () ) h = float (input () ) # площадь боковой поверхности цилиндра: side = 2 * 3.14 * r * h # площадь одного основания цилиндра: circle = 3.14 * r**2 # полная площадь цилиндра: full = side + 2 * circle return full square = cylinder() print (square)

Пример выполнения:

3 7 188.4

В данной программе в основную ветку из функции возвращается значение локальной переменной full . Не сама переменная, а ее значение, в данном случае – какое-либо число, полученное в результате вычисления площади цилиндра.

В основной ветке программы это значение присваивается глобальной переменной square . То есть выражение square = cylinder() выполняется так:

Вызывается функция cylinder() .

Из нее возвращается значение.

Это значение присваивается переменной square .

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

Print (cylinder() )

Здесь число, полученное из cylinder(), непосредственно передается функции print(). Если мы в программе просто напишем cylinder(), не присвоив полученные данные переменной или не передав их куда-либо дальше, то эти данные будут потеряны. Но синтаксической ошибки не будет.

В функции может быть несколько операторов return. Однако всегда выполняется только один из них. Тот, которого первым достигнет поток выполнения. Допустим, мы решили обработать исключение, возникающее на некорректный ввод. Пусть тогда в ветке except обработчика исключений происходит выход из функции без всяких вычислений и передачи значения:

def cylinder() : try : r = float (input () ) h = float (input () ) except ValueError : return side = 2 * 3.14 * r * h circle = 3.14 * r**2 full = side + 2 * circle return full print (cylinder() )

Если попытаться вместо цифр ввести буквы, то сработает return, вложенный в except. Он завершит выполнение функции, так что все нижеследующие вычисления, в том числе return full, будут опущены. Пример выполнения:

Но постойте! Что это за слово None, которое нам вернул "пустой" return? Это ничего, такой объект – "ничто". Он принадлежит классу NoneType. До этого мы знали четыре типа данных, они же четыре класса: int, float, str, bool. Пришло время пятого.

Когда после return ничего не указывается, то по умолчанию считается, что там стоит объект None. Но никто вам не мешает явно написать return None.

Более того. Ранее мы рассматривали функции, которые вроде бы не возвращали никакого значения, потому что в них не было оператора return. На самом деле возвращали, просто мы не обращали на него внимание, не присваивали никакой переменной и не выводили на экран. В Python всякая функция что-либо возвращает. Если в ней нет оператора return, то она возвращает None. То же самое, как если в ней имеется "пустой" return.

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

В Питоне позволительно возвращать из функции несколько объектов, перечислив их через запятую после команды return:

def cylinder() : r = float (input () ) h = float (input () ) side = 2 * 3.14 * r * h circle = 3.14 * r**2 full = side + 2 * circle return side, full sCyl, fCyl = cylinder() print ("Площадь боковой поверхности %.2f" % sCyl) print ("Полная площадь %.2f" % fCyl)

Из функции cylinder() возвращаются два значения. Первое из них присваивается переменной sCyl , второе – fCyl . Возможность такого группового присвоения – особенность Python, обычно не характерная для других языков:

>>> a, b, c = 10 , 15 , 19 >>> a 10 >>> b 15 >>> c 19

Фокус здесь в том, что перечисление значений через запятую (например, 10, 15, 19) создает объект типа tuple. На русский переводится как "кортеж". Это разновидность структур данных, которые будут изучены позже.

Когда же кортеж присваивается сразу нескольким переменным, то происходит сопоставление его элементов соответствующим в очереди переменным. Это называется распаковкой.

Таким образом, когда из функции возвращается несколько значений, на самом деле из нее возвращается один объект класса tuple. Перед возвратом эти несколько значений упаковываются в кортеж. Если же после оператора return стоит только одна переменная или объект, то ее/его тип сохраняется как есть.

Распаковка не является обязательной. Будет работать и так:

… print (cylinder() )

Пример выполнения:

4 3 (75.36 , 175.84 )

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

Напоминалка по использованию параметров (аргументов) функций в Python.

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

Замечания:

Все как обычно.
При вызове указывать обязательно все позиционные аргументы.

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

Замечания:

Обозначается звездочкой перед аргументом - *args
Внутри функции выглядит как кортеж, элементы кортежа расположены в том же порядке, что и аргументы функции, указанные при вызове.
Передать список при вызове функции как набор аргументов можно, приписав к обозначению списка спереди звездочку

Пример 1. Определение функции с переменным количеством аргументов:

Пример 2. Передача списка в функцию, как набора аргументов:

Комментарии к примеру 2:

Строка 8: Переменное к-во аргументов
Строка 9: Список (передается как один аргумент)
Строка 10: Список со звездочкой (передается как переменное к-во аргументов)

Именованные аргументы

Замечания:

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

Примечания:

При работе программы значения именованным параметрам присваиваются один раз, в месте определения функции. Если присваемый объект изменяемый, то измененный во время работы функции, он при в следующих вызовах будет иметь не то, значение, которое указано как значение в определении функции, а то, которое было присвоено во время предыдущего вызова.

Пример к примечанию:

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

Замечания:

Обозначается двумя звездочками перед аргументом - **kwargs
Внутри функции выглядит как словарь, с ключами, соответствующими именам аргументов, указанными при вызове функции.
Передать словарь при вызове функции как набор именованных аргументов можно, приписав две звездочки перед обозначением словаря. Напримиер так: **kwargs

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

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

Комментарии к примеру 2:

Строка 9: Словарь передан как один именованный аргумент.
Строка 10: Словарь передан как произвольное количество именованных аргументов.

Все виды параметров вместе

Передача параметра по ссылке (изменение параметра внутри функции)

Если при вызове функции подставим в качестве значения аргумента переменную, а в теле функции мы меняем значение аргумента, то то, что произойдет, зависит от того, с каким значение связана наша переменная. Если переменная связана с неизменяемым значением, например int, str, tulpe, то естественно, это значение не изменится. А вот если переменная связана со списком, словарем или классом, то значение связанного с переменной объекта изменится.

Не изменяется:

Изменяется:

Следствие 1: если нам нужно "передать параметр по ссылке", как в Си, делать этого не следует, может получиться не то, что хотим. Цель передачи параметра по ссылке в Си - вернуть несколько значений из функции, путем изменения значений по ссылкам внутри функции. В питоне можно возвращать кортеж, поэтому, если нужно вернуть нескоько значений, нужно возвращать кортеж и присваивать его значения переменным.

Следствие 2: во избежание "боковых эффектов", значениями по умолчанию лучше делать неизменяемые типы (None, int, str, tulpe)

Жаль, что такое большое количество примеров нельзя использовать в СРР Ибо фитонки я не знаю. А ведь тема интересная и очень хотелось бы знать, как её применять на практике, а не просто 1,2,3. Например если есть задача воплотить идею в атмегу8 На срр [это индекс массива] = {Привет мир} =)
индекс++ и каждый цикл выводим по букве.

Имя: Denis

При работе программы значения именованным параметрам присваиваются один раз, в месте определения функции. Если присваемый объект изменяемый, то измененный во время работы функции, он при в следующих вызовах будет иметь не то, значение, которое указано как значение в определении функции, а то, которое было присвоено во время предыдущего вызова.

То о чем вы упомянули относиться только к спискам.
Потому, что присваивая параметру список, и параметр и список создаются в одной ячейке и имеют один id. При изменении параметра меняется список и сохраняется все в той же ячейке.

Вообщем как-то так!

Имя: Asya

def even(x):
if x%2==0:
print("Yes")
____?
print("No")

Что поставить в предпоследне

Имя: Asya

def even(x):
if x%2==0:
print("Yes")
____?
print("No")

Что поставить в предпоследней строчке???

Имя: Shitz

Имя: aaa

Имя: Alesha

Asya, тупая!

Имя: Pavlo

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

Зачем нужны функции

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

Это простейший способ упаковать логику выполнения отдельных частей программы. При этом сокращается объем и время, которое специалист тратит на создание сценария.

Как написать первую функцию

В Python 3 для начинающих свое знакомство с программированием есть самая простая функция print(). Чтобы увидеть ее в действии вам понадобится среда разработки. Для этого скачайте дистрибутив языка с официального сайта и установите Python на компьютер.

Откройте меню «Пуск» и в списке программ найдите Python 3. Разверните его щелчком левой клавиши. В открывшемся списке найдите среду IDLE и запустите ее. Наберите print(«Hello, World!») и нажмите «Ввод». Интерпретатор вернет результат вашей первой функции.

Некоторые программисты предпочитают работать в консоли. Если вы относитесь к их числу, нажмите win+R и введите команду python.exe. Откроется обычный интерпретатор, только с интерфейсом cmd. Наберите программу описанным выше образом и нажмите Enter в конце, чтобы увидеть результат.

Как использовать def

Новые функции создаются с помощью инструкции def. Они так же эффективны, как и встроенные print() или open(), но отличаются от функций в компилирующих языках. Python def относится к исполняемым инструкциям. Это означает, что функции не существует, пока интерпретатор ее не увидит, и не перейдет к ее исполнению.

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

Теперь давайте напишем функцию, возвращающую фразу «Hello, World!», только с использованием def:

>>> def здравствуй_мир():
print(«Hello, World!»)
>>> здравствуй_мир() #вызов функции
Hello, World!

Синтаксис функций и return

Инструкция def в Python состоит из заголовка и пишется по следующим правилам:

>>>def <имя>

После заголовка следует блок инструкций, который начинается с обязательного отступа. В IDLE интерпретатор сделает его автоматически. Но в блокноте или другом текстовом редакторе вы можете забыть нажать Tab. Тогда функция не запустится. Программный код в блоке инструкции называется телом функции и выполняется каждый раз при ее вызове.

Также в теле иногда находится return:

def <имя>(аргумент 1, аргумент 2, аргумент N):
return <значение>

Return завершает работу функции и передает вызывающей программе объект-результат. Инструкция не является обязательной. Функция будет работать без return, и завершится, когда поток управления достигнет конца ее тела.

Параметры и аргументы

Каждой функции можно передавать параметры, которые указываются в скобках после def. В Python они записываются как переменные, разделенные запятыми. Значения или ссылки на объекты этим именам присваиваются в блоке за двоеточием. После операции присвоения их принято называть аргументами, а не параметрами.

Аргументы внутри функции никак не связаны с объектами вне ее, поэтому в программировании их относят к локальным переменным. Область видимости ограничена блоком функции, который начинается с def и заканчивается return. Чтобы было понятнее, приведем пример:

x = 12 #присваиваем переменным ссылки на целочисленные объекты
y = 34
>>>def example(x,y): #создаем функцию с именем example
x = «Hello» #присваиваем значения аргументам x, y
y = «Python»
print(x, y, sep= «, »)
return None
>>>example(x, y) #вызываем функцию, не забыв указать параметры
Hello, Python
>>>print(x, y)
12 34

Обратите внимание на предпоследнюю строчку кода. В интерпретаторе Python команда print() вернула переменные x и y из глобальной области видимости.

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

>>>def E_2(x, y):
return x + y
>>>E_2(«Hello, » «Python!») #чтобы слова были разделены, поставьте пробел перед закрывающей кавычкой
Hello, Python!
E_2(5, 4)

Как видно из примера с простой функцией E_2, результат полностью зависит от типа объектов x и y. В первом случае E_2 выполнила конкатенацию, а во втором - арифметическую операцию сложения. В этом заключается принцип полиморфизма и То, что объекты определяют синтаксический смысл, обуславливает гибкость и простоту языка. Не нужно тратить время на то, чтобы отдельно указать тип данных, с которым работает функция.

Правило LEGB

Это правило касается работы с переменными в разных областях видимости. По умолчанию все имена, которые вы создаете в теле функции, считаются локальными. А имена в модуле являются глобальными. При желании именам можно присвоить значение переменных верхнего уровня с помощью инструкции notlocal и global.

Правило LEGB объясняет схему разрешения имен:

Как только интерпретатор находит переменную внутри инструкции def, он сначала выполняет поиск значений в локальной области видимости.
Если поиск не дает результата, он переходит к области видимости любой всеобъемлющей инструкции def.
Дальше интерпретатор двигается к глобальным именам в верхнем уровне модуля и тем, что обозначены как global.
Если поиск не дает результатов, интерпретатор ищет имена во встроенной области видимости языка Python.

Рассмотрим наглядный пример:

>>>L = 85
>>>R = 23
>>>def пример_2(K):
R = 10
C = L + K+R
return C
>>>пример_2(5)

Переменные L и R находятся на верхнем уровне и являются глобальными именами. R, C и K - это локальные переменные, так как присваивание значения происходит внутри инструкции def.

Интерпретатор сначала выполняет операцию сложения для локальных R, C и K, игнорируя переменную R вне инструкции def. Потом ищет L, и не найдя ее среди имен local, переходит на верхний уровень.

Что такое lambda

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

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

Основы лямбда-выражений

По внешнему виду lambda-выражения напоминают инструкции def. Вначале пишется ключевое слово lambda, потом аргументы, двоеточие и само выражение:

>>>f = lambda x, y, z: x + y + z
>>>f(2, 3, 4)

Тело лямбда представляет собой одно единственное выражение, а не блок инструкций. За счет этого lambda ограничена в возможностях и не настолько универсальна как def. В ней может быть реализована только логика, без циклов while или for.

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

Lambda-выражения очень удобно встраивать в программу. За счет небольшого размера они минимизируют и упрощают код. Но использование лямбда не является принципиальным. В Python 3 начинающим для работы будет достаточно инструкции def.

Последнее обновление: 11.04.2018

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

Def имя_функции ([параметры]): инструкции

Определение функции начинается с выражения def , которое состоит из имени функции, набора скобок с параметрами и двоеточия. Параметры в скобках необязательны. А со следующей строки идет блок инструкций, которые выполняет функция. Все инструкции функции имеют отступы от начала строки.

Например, определение простейшей функции:

Def say_hello(): print("Hello")

Функция называется say_hello . Она не имеет параметров и содержит одну единственную инструкцию, которая выводит на консоль строку "Hello".

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

Def say_hello(): print("Hello") say_hello() say_hello() say_hello()

Здесь три раза подряд вызывается функция say_hello. В итоге мы получим следующий консольный вывод:

Hello Hello Hello

Теперь определим и используем функцию с параметрами:

Def say_hello(name): print("Hello,",name) say_hello("Tom") say_hello("Bob") say_hello("Alice")

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

Hello, Tom Hello, Bob Hello, Alice

Значения по умолчанию

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

Def say_hello(name="Tom"): print("Hello,", name) say_hello() say_hello("Bob")

Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть строка "Tom".

Именованные параметры

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

Def display_info(name, age): print("Name:", name, "\t", "Age:", age) display_info("Tom", 22)

При вызове функции первое значение "Tom" передается первому параметру - параметру name, второе значение - число 22 передается второму параметру - age. И так далее по порядку. Использование именованных параметров позволяет переопределить порядок передачи:

Def display_info(name, age): print("Name:", name, "\t", "Age:", age) display_info(age=22, name="Tom")

Именованные параметры предполагают указание имени параметра с присвоением ему значения при вызове функции.

Неопределенное количество параметров

С помощью символа звездочки можно определить неопределенное количество параметров:

Def sum(*params): result = 0 for n in params: result += n return result sumOfNumbers1 = sum(1, 2, 3, 4, 5) # 15 sumOfNumbers2 = sum(3, 4, 5, 6) # 18 print(sumOfNumbers1) print(sumOfNumbers2)

В данном случае функция sum принимает один параметр - *params , но звездочка перед названием параметра указывает, что фактически на место этого параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору и произвести с переданными значениями различные действия. Например, в данном случае возвращается сумма чисел.

Возвращение результата

Функция может возвращать результат. Для этого в функции используется оператор return , после которого указывается возвращаемое значение:

Def exchange(usd_rate, money): result = round(money/usd_rate, 2) return result result1 = exchange(60, 30000) print(result1) result2 = exchange(56, 30000) print(result2) result3 = exchange(65, 30000) print(result3)

Поскольку функция возвращает значение, то мы можем присвоить это значение какой-либо переменной и затем использовать ее: result2 = exchange(56, 30000) .

В Python функция может возвращать сразу несколько значений:

Def create_default_user(): name = "Tom" age = 33 return name, age user_name, user_age = create_default_user() print("Name:", user_name, "\t Age:", user_age)

Здесь функция create_default_user возвращает два значения: name и age. При вызове функции эти значения по порядку присваиваются переменным user_name и user_age, и мы их можем использовать.

Функция main

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

Def main(): say_hello("Tom") usd_rate = 56 money = 30000 result = exchange(usd_rate, money) print("К выдаче", result, "долларов") def say_hello(name): print("Hello,", name) def exchange(usd_rate, money): result = round(money/usd_rate, 2) return result # Вызов функции main main()

27 января 2009 в 14:49

Основы Python - кратко. Часть 6. Расширенное определение функций.

Python

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

Параметры по-умолчанию

Для всех параметров функций можно указывать значения по-умолчанию, это дает возможность вызвать функцию с меньшим числом параметров. Например, у нас есть функция для авторизации пользователя на сайте:
def login(username="anonymous", password=None): """Тут какие-то действия""" pass # вызвать эу функцию мы можем одним # из нижеприведенных способов login("root", "ujdyzysqgfhjkm") login("guest") login() # мы можем указать какой из параметров мы передаем, # указав его имя в явном виде login(password="[email protected]")

В общем, те параметры что есть – сопоставляются слева направо (если имя не указано конкретно), остальные заменяются значениями по-умолчанию (если они конечно заданы).
Важной особенностью в данном случае является то, что значения по-умолчанию вычисляются и ассоциируются только один раз – в момент объявления функции. Все вытекающие из этого недостатки наглядно продемонстрирует пример:
def_val = 2 def our_func(val = def_val): print val our_func(4) # выведет 4 our_func() # выведет 2 – значение по-умолчанию def_val = 12 our_func() # все равно 2, так как def_val было равно 2 на момент объявления
Более неприятное следствие из этого. Допустим, мы хотим объявить функцию, принимающую на вход список, что-то с ним делающую и печатающую его. Причем если список не задан, то по умолчанию он равен пустому.
Попытка сделать это «в лоб» будет работать не совсем так как хотелось бы:
In : def lister(lst = ): ...: lst.append() ...: print lst ...: In : lister() [] In : lister() [, ] In : lister() [, , ]
Собственно, проблема тут в том, что переменная lst будет ассоциирована с пустым списком один раз, и между вызовами будет сохранять свое значение.
В данном случае, правильно будет описать нашу функцию следующим образом (как рекомендуют все учебники):
In : def lister2(lst=None): ...: if lst is None: ...: lst= ...: lst.append() ...: print lst ...: In : lister2() [] In : lister2() [] In : lister2() ]
Данная функция как раз будет работать так как хотелось бы изначально.

Position и keyword аргументы.

Зачастую случается необходимость сделать функцию, которая обрабатывает неопределенное число параметров. Например функция расчета суммы элементов списка.
Мы конечно можем передавать все аргументы как один параметр типа list, но это выглядит некрасиво. Потому в Пайтоне был придуман специальный механизм, называемый position-arguments. Вот пример, демонстрирующий использование.
In : def list_sum(*args): ...: smm = 0 ...: for arg in args: ...: smm += arg ...: return smm ...: In : list_sum(1, 2, 3) Out: 6 In : list_sum(1) Out: 1 In : list_sum() Out: 0
В данном случае, все наши параметры «упаковываются» в список args в соответствии с их «порядковым номером» при передаче.
Возможна и обратная операция, допустим у нас есть список значений, и мы хотим передать их как список параметров функции:
In : lst = In : list(range(*lst)) Out:
В этом примере список lst был «распакован» и подставлен на место параметров функции range, то есть вызов был аналогичен:
In : list(range(1, 10, 2)) Out:
Кроме position, можно использовать и т.н. keyword аргументы. Они отличаются тем что для них надо явно задавать имя. Вот пример – функция, генерирующая insert выражение для базы данных (NB: максимальная оптимизация не ставилась в данном случае за самоцель).
def enquote1(in_str): """Quotes input string with single-quote""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def enquote2(in_str): """Quotes input string with double-quote""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def gen_insert(table, **kwargs): """Generates DB insert statement""" cols = vals = for col, val in kwargs.items(): cols.append(enquote2(col)) vals.append(enquote1(str(val))) cols = ", ".join(cols) vals = ", ".join(vals) return "INSERT INTO "%s"(%s) VALUES(%s);" % (table, cols, vals) print gen_insert("workers", name="John", age=21, salary=1500.0) params = {"name": "Mary", "age": 19, "salary": 1200.0} print gen_insert("workers", **params)
На выходе мы получим то что и ожидалось:
INSERT INTO "workers"("salary", "age", "name") VALUES("1500.0", "21", "John"); INSERT INTO "workers"("salary", "age", "name") VALUES("1200.0", "19", "Mary");
Обратите внимание на второй вызов функции gen_insert – так мы можем вызвать функцию имея только словарь параметров. Это применимо к любой функции. Так же возможны различные сочетания positional и keyword аргументов.

В качестве завершающего примера рассмотрим такую функцию:
def logging(func, *args, **kwargs): res = func(*args, **kwargs) print "calling %s, returned %r" % (func.__name__, res) return res def double(x): "Doubles a number" return 2*x print logging(double, 155)
Это – простейший способ отладки функции, мы как бы «оборачиваем» вызов одной функции другой что бы вывести промежуточную информацию.
Забегая вперед – скажу что в Пайтоне есть очень мощный инструмент для более удобного использования подобного рода «оборачивающих» функций, называемый декораторами, но про это позже.

На этом на сегодня все. Продолжение следует (либо мое, либо уважаемого