5 августа 2008 в 16:14

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

• Python

Начав писать главу про ООП, понял что совсем забыл освятить такой большой и нужный раздел Пайтона как функции. Тема это большая и обширная, потому, чтобы не сильно растягивать паузу между уроками, решил разделить ее на 2 части. Сначала расскажу основы, потом уже углубленные особенности Пайтоновского функциестроения.

Функции в Пайтоне объявляются не просто, а очень просто. Вот пример самой простой:

Def empty_func(): pass
Начинается объявление с ключевого слова def, что как не сложно догадаться является сокращением от define. После него идет имя функции. После имени в круглых скобках задается список параметров, в данном случае отсутствующих.
Тело функции пишется с отступом со следующей строки. учтите, что в Пайтоне функции с пустым телом запрещены, потому в качестве тела приведенной выше функции используется «пустой оператор» pass.
Теперь рассмотрим пример посерьезнее.

Def safe_div(x, y): """Do a safe division:-) for fun and profit""" if y != 0: z = x / y print z return z else: print "Yippie-kay-yay, motherf___er!"
В этом примере есть несколько нововведений. первое, что бросается в глаза - это строка документации (docstring), идущая сразу после тела функции.
Обычно эта строка занимает не одну строку исходного текста (простите за каламбур) и потому задается в тройных кавычках. Она предназначена для описания функции, ее предназначения, параметров и т.п. Все хорошие ИДЕ умеют с этой строкой работать. Получить к ней доступ можно и из самой программы, используя свойство __doc__:

Print safe_div.__doc__
Этим свойством (да, да, именно свойством, в Пайтоне даже функции на самом деле - классы) удобно пользоваться во время сеансов работы интерактивной консоли.
>>> from ftplib import FTP >>> print FTP.__doc__ An FTP client class. To create a connection, call the class using these argument: host, user, passwd, acct These are all strings, and have default value "". Then use self.connect() with optional host and port argument. # дальнейшее почикано мною:-)
Вернемся к нашей исходной функции. Суть ее очень проста, она принимает 2 параметра: х и у. Если у не равен 0, она делит х на у, выводит результат на экран и возвращает свое частное в виде результата. Результат функции возвращают с помощью команды return. Благодаря механизму кортежей, описанному в прошлом уроке, функции в Пайтоне могут возвращать одновременно множество объектов.
Если же делитель все-таки равен нулю, функция выводит сообщение об ошибке. Неверно было бы предположить что в этом случае функция ничего не вернет. Правильнее будет сказать что функция вернет «ничего»:) Иначе говоря, если в функции отсутствует оператор return, или же он вызван без параметров, то функция возвращает специальное значение None. В этом легко убедиться вызвав что-то типа print safe_div(10, 0).

Вот пример слегка посложнее, он взят из доклада-презентации Гвидо ван Россума.

Def gcd(a, b): "Нахождение НОД" while a != 0: a,b = b%a,a # параллельное определение return b
Данная функция находит наибольший общий делитель двух чисел.

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

Mystic_function = safe_div print mystic_function(10, 4)
Вот на этот раз и все, «за бортом» осталось еще много аспектов определения функций в Пайтоне, которые будут освещены в следующий раз.

Упражнения для проверки.
1. На основе существующей функции нахождения НОД, напишите функцию поиска НОК двух чисел.
2. Напишите подпрограмму табулирования функции, переданной в качестве аргумента. Так же аргументами задается начальное, конечное значение и шаг табуляции.

PS кстати, каков оптимальный объем «урока»? Что лучше - реже выходящие большие главы, или «лучше меньше да чаще».

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)
Это – простейший способ отладки функции, мы как бы «оборачиваем» вызов одной функции другой что бы вывести промежуточную информацию.
Забегая вперед – скажу что в Пайтоне есть очень мощный инструмент для более удобного использования подобного рода «оборачивающих» функций, называемый декораторами, но про это позже.

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

Последнее обновление: 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()

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

Python предлагает множество встроенных функций. Вы наверняка знакомы с такими:

• print() выводит объект в терминал.
• int() преобразовывает строки или числа в целые числа.
• len() возвращает длину объекта.

Имя функции содержит круглые скобки и может содержать параметры.

Данное руководство научит вас определять пользовательские функции.

Определение функции

Для начала попробуйте преобразовать простую программу «Hello, World!» в функцию.

Создайте новый текстовый файл hello.py, а затем определите функцию.

Для определения функции используется ключевое слово def, затем указывается имя функции и круглые скобки, в которых могут находиться параметры (если параметров нет, скобки остаются пустыми), в конце ставится двоеточие.

Чтобы определить функцию hello(), добавьте в файл hello.py:

Это исходное определение функции.

def hello():
print("Hello, World!")

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

После определения функции вызовите её:

def hello():
print("Hello, World!")
hello()

Теперь запустите программу:

Она должна вернуть:

Функция hello() – довольно простой пример. Функции могут быть гораздо сложнее: содержать циклы for, условные выражения и другие компоненты.

Достигая оператора return, функция прекращает выполнение.

# Файл return_loop.py
def loop_five():
for x in range(0, 25):
print(x)
if x == 5:
# Stop function at x == 5
return
print("This line will not execute.")
loop_five()

Оператор return в цикле for прекращает выполнение функции, потому строки после функции не будут запущены. Если бы вместо него использовался оператор break, программа прекратила бы выполнение цикла, а не функции, и последнее выражение print() было бы обработано.

Функция main()

В языке Python функцию можно вызвать в конце программы, и она запустится (как показано в предыдущих примерах), однако некоторым языкам программирования (например, C++ или Java) требуется функция main. Функция main() в Python необязательна, но она позволяет логически структурировать программу Python и объединить наиболее важные её компоненты в одну функцию. Также с её помощью программы Python легче читать программистам, которые работают с другими языками.

Вернитесь в файл hello.py и добавьте функцию main(), сохранив при этом функцию hello().

def hello():
print("Hello, World!")
def main():

В функцию main() добавьте выражение print(). Затем вызовите функцию hello() внутри функции main().

def hello():
print("Hello, World!")
def main():
print("This is the main function")
hello()

В конце файла вызовите функцию main().

def hello():
print("Hello, World!")
def main():
print("This is the main function.")
hello()
main()

Теперь можно запустить программу:

python hello.py
This is the main function.
Hello, World!

Теперь попробуйте использовать несколько функций.

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

Чем меньше и специализированнее код функции, тем проще выбрать для нее понятное имя . Не бойтесь использовать длинные имена . Длинное содержательное имя лучше короткого невразумительного. Будьте последовательны в выборе имени. Используйте в имени функции те же словосочетания, глаголы и существительные, которые используются в ваших модулях. Создание функции производится с помощью инструкции def, как показано в следующем примере. Мы уже научились , давайте воспользуется знаниями тут.

# -*- coding: utf-8 -*- Phones = ["Nokia", "Samsung", "LG", "Sony"] def show_as_text(user_list): words = "" for value in user_list: words += str(value) + " " return words print "Phones: ", show_as_text(Phones) # Вернет: Phones: Nokia Samsung LG Sony

Достаточно простая структура функции. Название функции show_as_text, важно чтобы не совпадала с названием функции самого Python. Имя функции должна быть уникальна и по сравнению с переменными. Если функция будет иметь название get_values, и после нее в скрипте будет создана переменная с тем же именем, тогда вызов get_values(args) выдаст ошибку.

# -*- coding: utf-8 -*- def get_value(): return True a = 1 b = 3 get_value = "some text..." is_true = get_value()

Получим ошибку:

TypeError: "str" object is not callable Если потребуется вернуть из функции несколько значений, можно использовать кортеж. Создадим небольшой аналог игры Бинго! чтобы получить разные номера. # -*- coding: utf-8 -*- import random def bingo(): return (random.randint(0, 30), random.randint(0, 30), random.randint(0, 30)) Numbers = bingo() print "Первый: ", Numbers print "Второй: ", Numbers print "Третий: ", Numbers

Присвоить аргументу функции значение по умолчанию можно с помощью оператора присваивания.

Def connect(ip, port=8080): return str(ip) + " " + str(port) print connect("127.0.0.1") # Получим: 127.0.0.1 8080

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

Connect("сайт", 80)

также имеется возможность передавать функции именованные аргументы, которые при этом можно перечислять в произвольном порядке. Однако в этом случае вы должны знать, какие имена аргументов указаны в определении функции.

Connect(port=80, host="сайт")

Когда внутри функции создаются новые переменные, они имеют локальную область видимости. То есть такие переменные определены только в пределах тела функции, и они уничтожаются, когда функция возвращает управление программе. ЧТобы иметь возможность изменять глобальные переменные внтури функции, эти переменные следует определить в теле функции с помощью инструкции global.

Num = 1 # Глабальная перемення def next_number(): global num personal_num = 999 num += 1 return num print next_number() # результат 2 # Попробуем получить значении локальной переменной personal_num print personal_num # Ошибка NameError: name "personal_num" is not defined