Что такое процедура в питоне

Разница функции и процедуры в python?

В питоне нет понятия процедуры, только функции и методы (это функции у классов).

И объекты в нем передаются по ссылке.

Кроме того, список array является изменяемыми, поэтому, если не хотите поменять его внутри функции и вернуть измененную копию, то сделайте копирование списка через copy.deepcopy:

import copy def cofactor(array, i, q): #алгебраическое дополнение ((−1)^(i+j) * Mi,j) array = copy.deepcopy(array) for k in range(i): array[k].pop(q) array.pop(i) return array 

Отслеживать
ответ дан 2 ноя 2020 в 14:48
76.7k 6 6 золотых знаков 54 54 серебряных знака 120 120 бронзовых знаков
Спасибо. А без модуля copy это реально сделать?
2 ноя 2020 в 14:56

Я бы не сказал, что это передача «по ссылке». Передаётся имя ссылающееся на тот же объект в памяти. array = [] никак не затрагивает переданный аргумент. Впрочем, это вопрос терминологии))

2 ноя 2020 в 14:59

@EgorFedorov, можно, нужно заново воссоздать список списков, что-то вроде такого: array = [[x for x in array[i]] for i in range(len(array))] , короткий вариант array = [list(x) for x in array]

2 ноя 2020 в 15:30

В питоне вообще нет разницы между функцией и процедурой. В питоне даже если вы ничего не вернёте с помощью return в явном виде, по факту вернётся значение None .

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

Да, это не очень хороший стиль, когда процедура/функция меняет что-то переданное ей, чего вы не ожидаете, но от такого поведения нет никакой страховки.

Отслеживать
ответ дан 2 ноя 2020 в 14:50
67.8k 5 5 золотых знаков 20 20 серебряных знаков 51 51 бронзовый знак

• python
• функции

Важное на Мете

Похожие

Подписаться на ленту

Лента вопроса

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.10.27.43697

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

5.1. Теория¶

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

Как правило, подпрограмма — это именованный фрагмент программного кода, к которому можно обратиться из другого места программы, однако она может и не иметь имени (называясь в таком случае анонимной).

5.1.1. Основные понятия и механизм работы¶

5.1.1.1. Определение подпрограммы¶

Подпрограмма должна быть объявлена и в общем случае содержать:

• имя;
• список имен и типов передаваемых параметров (необязательно);
• тип возвращаемого значения (необязательно).

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

5.1.1.2. Вызов подпрограммы¶

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

• указать имя подпрограммы;
• передать требуемые аргументы (значения параметров).

Код, вызвавший подпрограмму, передает ей управление и ожидает завершения выполнения.

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

В настоящее время наиболее часто встречаются следующие способы передачи аргументов:

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

Изменения, которые происходят в теле подпрограммы с переменной, переданной по ссылке, происходят с самой переданной переменной.

5.1.1.3. Механизм работы¶

Большинство современных языков программирования для управления вызовом подпрограмм используют стек вызовов.

Примерный цикл работы стека вызова следующий (Видео 5.1.1, Видео 5.1.2):

1. Вызов подпрограммы создает запись в стеке; каждая запись может содержать информацию о данных вызова (аргументах, результате, а также адресе возврата).
2. Когда подпрограмма завершается, запись удаляется из стека и программа продолжает выполняться, начиная с адреса возврата.

Видео 5.1.1 — Cтек вызовов (пример, Нетология)

Your browser does not support the video tag.

Видео 5.1.2 — Cтек вызовов (пример, Stepik.org)

5.1.1.4. Преимущества и недостатки¶

Главное назначение подпрограмм сегодня — структуризация программы с целью удобства ее понимания и сопровождения.

Преимущества использования подпрограмм:

• декомпозиция сложной задачи на несколько более простых подзадач: это один из двух главных инструментов структурного программирование (второй — структуры данных);
• уменьшение дублирования кода и возможность повторного использования кода в нескольких программах — следование принципу DRY «не повторяйся» (англ.Don’t Repeat Yourself);
• распределение большой задачи между несколькими разработчиками или стадиями проекта;
• сокрытие деталей реализации от пользователей подпрограммы;
• улучшение отслеживания выполнения кода (большинство языков программирования предоставляет стек вызовов подпрограмм).

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

5.1.2. Функции в Python¶

В Python нет формального разделения подпрограмм на функции и процедуры (как, например, в Паскале или Си), и процедурой можно считать функцию, возвращающую пустое значение — в остальном используется единственный термин — функция.

Для объявления функции в Python используется ключевое слово def :

def function_name([parameters]): # `parameters`: параметры функции (через запятую) suite # Тело функции 

На имя функции в Python накладываются такие же ограничения, как и на прочие идентификаторы .

Соглашение рекомендует использовать:

• змеиный_регистр (англ. snake_case) для наименования функций: my_function ;
• пустые строки для отделения функций, а большие блоки кода помещать внутрь функций;
• строки документации .

В Python все данные — объекты, при вызове в функцию передается ссылка на этот объект. При этом, мутирующие объекты передаются по ссылке, немутирующие — по значению.

Функция в Python может возвращать результат своего выполнения, используя оператор return (например, return 5 ). В случае, если он не был указан или указан пустой оператор return , возвращается специальное значение None .

При встрече оператора return в коде Python немедленно завершает выполнение функции, аналогично break для циклических конструкций.

Пример определения и вызова функции приведен в Листинге 5.1.1 и на Рисунке 5.1.1.

Листинг 5.1.1 — Пример определения и вызова функции | скачать ¶

# Функция для вычисления гипотенузы # Имя: hypot, 2 параметра: x, y # return возвращает результат работы функции вызвавшему def hypot(x, y): return (x**2 + y**2)**0.5 z = hypot(3, 4) # Передача в функцию 2-х аргументов: 3 и 4 print(z) # 5.0 a = 5 b = 12 print(hypot(a, b)) # 13.0 - результат функции может быть использован сразу 

Рисунок 5.1.1 — Передача параметров и возвращение результата функции ¶

Python, как и многие другие языки, позволяет создавать собственные (пользовательские) функции, среди которых можно выделить четыре типа (Листинг 5.1.2):

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

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

Не имеют имени и объявляются в месте использования. В Python и представлены лямбда-выражениями.

Функции, ассоциированные с каким-либо объектом (например, list.append() , где append() — метод объекта list ).

Листинг 5.1.2 — Четыре типа функций в Python | скачать ¶

class Car: def move(self, x): # Метод (3) self.x += x def sum_of_cubes(x, y): # Глобальная функция (1) # Локальная функция (2) (ее "видит" только код внутри sum_of_cubes()) def cube(a): return a**3 return cube(x) + cube(y) # return возвращает результат выполнения тому, # кто вызвал эту функцию players = ["name": "Юрий", "rank": 5>, "name": "Сергей", "rank": 3>, "name": "Максим", "rank": 4>] # Анонимная функция (4) (лямбда-выражение) # В функции sorted() используется для определения порядка сортировки print(sorted(players, key=lambda player: player["name"])) # Сортировка по name # [, , ] print(sorted(players, key=lambda player: player["rank"])) # Сортировка по rank # [, , ] 

5.1.3. Глобальные и локальные функции¶

5.1.3.1. Параметры и аргументы¶

5.1.3.1.1. Позиционные и ключевые параметры/аргументы¶

Все параметры, указываемые в Python при объявлении и вызове функции делятся на:

позиционные: указываются простым перечислением:

def function_name(a, b, c): # a, b, c - 3 позиционных параметра pass 

def function_name(key=value, key2=value2): # key, key2 - 2 позиционных аргумента pass # value, value2 - их значения по умолчанию 

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

def example_func(a, b, c): # можно : 'a', 'b', 'c' - позиционные параметры pass def example_func(a, b, c=3): # можно : 'a', 'b' - позиционные параметры, pass # 'c' - ключевой параметр def example_func(a=1, b=2, c=3): # можно : 'a', 'b', 'c' - ключевые параметры pass def example_func(a=1, с, b=2): # нельзя: ключевой параметр 'a' pass # идет раньше позиционнных 

def example_func(a, b, c=3): # a, b - позиционные параметры, c - ключевой параметр pass # Вызовы функции example_func(1, 2, 5) # можно : аргументы 1, 2, 5 распределяются # позиционно по параметрам 'a', 'b', 'c' example_func(1, 2) # можно : аргументы 1, 2 распределяются позиционно # по параметрам 'a', 'b' # в ключевой параметр 'c' аргумент # не передается, используется значение 3 example_func(a=1, b=2) # можно : аналогично example_func(1, 2), # все аргументы передаются по ключу example_func(b=2, a=1) # можно : аналогично example_func(a=1, b=2), # если все позиционные параметры заполнены как # ключевые аргументы, можно не соблюдать порядок example_func(c=5, b=2, a=1) # можно : аналогично example_func(1, 2), # аргументы передаются по ключу example_func(1) # нельзя: для позиционного аргумента 'b' # не передается аргумент example_func(b=1) # нельзя: для позиционного аргумента 'a' # не передается аргумент 

Преимущества ключевых параметров:

• нет необходимости отслеживать порядок аргументов;
• у ключевых параметров есть значение по умолчанию, которое можно не передавать.

Пример функции со смешанными типами параметров приведен в Листинге 5.1.3.

Листинг 5.1.3 — Позиционные и ключевые параметры функций в Python | скачать ¶

# Функция выдает запрос и # - возвращает True в случае положительного ответа # - возвращает False в случае отрицательного ответа # - возвращает False если не получает ответ за [retries] попыток def ask_user(prompt, retries=3, hint="Ответьте, ДА или НЕТ?"): while True: retries -= 1 ok = input(prompt + " -> ").upper() if ok in ("Д", "ДА"): return True elif ok in ("Н", "НЕТ"): return False if retries  0: print("Не смог получить нужный ответ, считаю за отказ.") return False print(hint) # С ключевыми параметрами будут доступны также следующие варианты: # ask_user("Сохранить файл?", 0) # ask_user("Сохранить файл?", retries=1) # ask_user("Сохранить файл?", 2, "Жми Д или Н. ") # и др. if ask_user("Сохранить файл?"): print("Сохранил!") else: print("Не сохранил.") # ------------- # Пример вывода: # # Сохранить файл? -> Не знаю # Ответьте, ДА или НЕТ? # Сохранить файл? -> Да # Сохранил! 

5.1.3.1.2. Упаковка и распаковка аргументов¶

В ряде случаев бывает полезно определить функцию, способную принимать любое число аргументов. Так, например, работает функция print() , которая может принимать на печать различное количество объектов и выводить их на экран.

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

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

Пример упаковки аргументов приведен в Листинге 5.1.4.

Листинг 5.1.4 — Упаковка аргументов | скачать ¶

# При упаковке аргументов все переданные позиционные аргументы # будут собраны в кортеж 'order', а ключевые - в словарь 'info' def print_order(*order, **info): print("Музыкальная библиотека №1\n") # Словарь 'infos' должен содержать ключи 'author' и 'birthday' for key, value in sorted(info.items()): print(key, ":", value) # Кортеж 'order' содержит все наименования произведений print("Вы выбрали:") for item in order: print(" -", item) print("\nПриходите еще!") print_order("Славянский марш", "Лебединое озеро", "Спящая красавица", "Пиковая дама", "Щелкунчик", author="П.И. Чайковский", birthday="07/05/1840") # ------------- # Пример вывода: # # Музыкальная библиотека №1 # # author : П.И. Чайковский # birthday : 07/05/1840 # Вы выбрали: # - Славянский марш # - Лебединое озеро # - Спящая красавица # - Пиковая дама # - Щелкунчик # # Приходите еще! 

Python также предусматривает и обратный механизм — распаковку аргументов, используя аналогичные обозначения перед аргументом:

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

Пример распаковки аргументов приведен в Листинге 5.1.5.

Листинг 5.1.5 — Распаковка аргументов | скачать ¶

# Площадь треугольника по формуле Герона # # Данный пример функции предназначен для демонстрации распаковки # Не проектируйте функцию таким образом - # расчетная функция должна возвращать число, а не строку! def heron_area_str(a, b, c, units="сантиметры", print_error=True): if a + b  c or a + c  b or b + c  a: if print_error: return "Проверьте введенные стороны треугольника!" return p = (a + b + c) / 2 s = (p * (p - a) * (p - b) * (p - c)) ** 0.5 return "<> <>".format(s, units) abc = [3, 4, 5] params = dict(print_error=True, units="см.") # При распаковке аргументов список 'abc' будет распакован в # позиционные аргументы, а словарь 'params' - ключевые print(heron_area_str(*abc, **params)) # ------------- # Пример вывода: # # 6.0 см. 

5.1.3.2. Область видимости¶

Область видимости — область программы, где определяются идентификаторы, и транслятор выполняет их поиск. За пределами области видимости тот же самый идентификатор может быть связан с другой переменной, либо быть свободным (не связанным ни с какой из них).

В Python выделяется четыре области видимости:

Собственная область внутри инструкции def .
Область в пределах вышестоящей инструкции def .
Область за пределами всех инструкций def — глобальная для всего модуля.

«Системная» область модуля builtins : содержит предопределенные идентификаторы, например, функцию max() и т.п.

Локальная и нелокальная области видимости являются относительными, глобальная и встроенная — абсолютными.

• идентификатор может называться локальным, глобальным и т.д., если имеет соответствующую область видимости;
• функции образуют локальную область видимости, а модули – глобальную;
• чем ближе область к концу списка, тем более она открыта (ее содержимое доступно для более закрытых областей видимости; например, глобальные идентификаторы и предопределенные имена могут быть доступны в локальной области видимости функции, но не наоборот).

В Листинге 5.1.6 приведен пример четырех областей видимости.

Листинг 5.1.6 — 4 области видимости в Python | скачать ¶

def min_of_cubes(x, y): # Идентификаторы 'x' и 'y' являются: # - локальными для min_of_cubes() # - нелокальными для cube() def cube(a): return a**3 # 'a' - локальный идентификатор функции cube() return min(cube(x), cube(y), cube(c)) # Функция min() находится # во встроенной области # видимости и видна везде # Идентификаторы 'a', 'b' и 'c' имеют глобальную область видимости a, b, c = 2, 3, 4 print(min_of_cubes(a, b)) # 8 

Схема разрешения имен в языке Python называется правилом LEGB (Local, Enclosed, Global, Built-in) 6: когда внутри функции выполняется обращение к неизвестному имени, интерпретатор пытается отыскать его в четырех областях видимости по очереди до первого нахождения.

В Листингах 5.1.7 (а-д) приведены некоторые случае выполнения LEGB-правила.

Листинг 5.1.7 (а) — Области видимости в Python (пример) | скачать ¶

# Увеличиваем переменную 'a' локально def sum_of_2(a, b): a += 2 return a + b a, b = 3, 4 print(sum_of_2(a, b)) # 9 print(a, b) # 3 4 

Листинг 5.1.7 (б) — Области видимости в Python (пример) | скачать ¶

# Добавляем к сумме локальную переменную 'x' def sum_of_2(a, b): x = 5 return a + b + x a, b = 3, 4 print(sum_of_2(a, b)) # 12 print(a, b, x) # NameError: name 'x' is not defined 

Листинг 5.1.7 (в) — Области видимости в Python (пример) | скачать ¶

# Пробуем увеличить глобальную переменную 'c' def sum_of_2(a, b): c *= 5 # UnboundLocalError: local variable 'c' referenced before assignment return a + b + с a, b, c = 3, 4, 5 print(sum_of_2(a, b)) 

Листинг 5.1.7 (г) — Области видимости в Python (пример) | скачать ¶

# Пробуем изменить глобальную переменную 'c' def sum_of_2(a, b): с = 10 return a + b + с a, b, c = 3, 4, 5 print(sum_of_2(a, b)) # 17 print(a, b, c) # 3 4 5 

Листинг 5.1.7 (д) — Области видимости в Python (пример) | скачать ¶

# Используем глобальную переменную 'c', не имея соответствующего параметра def sum_of_2(a, b): return a + b + c a, b, c = 3, 4, 5 print(sum_of_2(a, b)) # 12 

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

Если необходимо изменять в функции переменные более закрытой области видимости, существует 3 способа:

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

В Листингах 5.1.8, 5.1.9 и 5.1.10 приведены примеры использования ключевых слов global , nonlocal , а также передачи мутирующего аргумента.

Листинг 5.1.8 — Использование global позволяет менять значение глобальной переменной внутри функции | скачать ¶

def func(): # 'value' создается как локальный идентификатор value = 100 def func_with_global(): global value # global указывает, что нужно использовать 'value' # из глобальной области видимости value = 100 value = 0 func() print(value) # 0 func_with_global() print(value) # 100 

Листинг 5.1.9 — Использование nonlocal позволяет менять значение нелокальной переменной внутри вложенной функции | скачать ¶

def func(): def inner_func(): # 'value' создается как локальный идентификатор inner_func() value = 100 def inner_func_with_nonlocal(): nonlocal value # Благодаря nonlocal используется 'value' из func() value = 100 value = 10 inner_func() print(value) # 10 inner_func_with_nonlocal() print(value) # 100 value = 0 func() print("global value =", value) # 0 

Листинг 5.1.10 — Передача мутирующего аргумента в функцию | скачать ¶

# Функция принимает список, и добавляет сумму элементов в конец списка # # Изменение внутри функции мутирующего объекта приводит к его # изменению и в вызывающем коде def sum_list(lst): lst.append(sum(lst)) my_list = [1, 2, 3, 4, 5] sum_list(my_list) print(my_list) # [1, 2, 3, 4, 5, 15] 

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

В большинстве случаев необходимо придерживаться концепции изолированного доступа через области видимости.

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

Листинг 5.1.11 — Мутирующие аргументы сохраняют значения после нескольких вызовов | скачать ¶

# Функция принимает число и список, к которому его нужно добавить # Если список не передан, число должно оказаться в пустом списке # 1. Данная реализация не учитывает единовременное создание значений # ключевых аргументов, и приводит к неожиданным эффектам def change_list(a, lst=[]): lst.append(a) return lst my_list = change_list(1) my_list = change_list(2) my_list = change_list(3) print(my_list) # [1, 2, 3] # Та же функция, реализованная правильно def change_list_2(a, lst=None): L = lst if L is None: L = [] L.append(a) return L my_list = change_list_2(1) my_list = change_list_2(2) my_list = change_list_2(3) print(my_list) # [3] 

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

Часто из функции необходимо вернуть несколько значений (например, в Паскале, для этого используются выходные параметры с ключевым словом var ). Одним из лучших способов для этого в Python является возврат кортежа с несколькими значениями (Листинг 5.1.12).

Листинг 5.1.12 — Возврат нескольких значений в виде кортежа | скачать ¶

# Функция выполняет решение квадратного уравнения, # сообщая вызывающему коду, сколько решений удалось получить # в формате (num, (x1, . )), # где в начале идет количество решений, а в отдельном кортеже сами решения def solve_equation(a, b, c): d = b**2 - 4 * a * c if d  0: return (0, ()) elif d == 0: x = -b / (2*a) return (1, (x, )) else: x1 = (-b - d**0.5) / (2*a) x2 = (-b + d**0.5) / (2*a) return (2, (x1, x2)) # Рекурсивный вариант вычисления факториала a = int(input("a = ")) b = int(input("b = ")) c = int(input("c = ")) num, x = solve_equation(a, b, c) print("\nРезультат решения: ", end="") if num == 0: print("решений нет") elif num == 1: print("x =", x[0]) elif num == 2: print("x1 =", x[0], " x2 =", x[1]) else: print("ошибка!") # ------------- # Пример вывода: # a = 1 # b = 4 # c = 3 # # Результат решения: x1 = -3.0 x2 = -1.0 

Прочие способы (например, изменение глобальных переменных) не рекомендуются 7.

5.1.3.4. Рекурсия¶

Рекурсия — вызов функции внутри самой себя, непосредственно (простая рекурсия) или через другие функции (сложная или косвенная рекурсия)

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

Не рекомендуется использовать рекурсию, если такая функция может привести или приводит к большой глубине рекурсии — лучше заменить ее циклической конструкцией. Рекурсивный вызов требуется некоторое количество оперативной памяти компьютера, и при чрезмерно большой глубине рекурсии может наступить переполнение стека (англ. англ. Stack Overflow) вызовов.

В Листинге 5.1.13 приведен пример реализации рекурсивной функции.

Листинг 5.1.13 — Рекурсивные функции | скачать ¶

# Вычисление факториала, используя цикл def factorial_1(x): res = 1 for i in range(x): res *= i + 1 return res # Рекурсивный вариант вычисления факториала def factorial_2(x): if x == 1: return 1 else: return x * factorial_2(x - 1) print(factorial_1(5)) # 120 print(factorial_2(5)) # 120 

5.1.3.5. Строки документации¶

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

Python предоставляет возможность добавить документацию (описание) к любой функции, используя строки документирования — это обычные строки тройных кавычках «»» , которые следуют сразу за строкой с инструкцией def перед программным кодом функции и воспринимаются транслятором специальным образом.

Соглашения по документированию функций содержатся в документе PEP 257.

Верно оформленная строка документации является краткой справкой по функции, которую можно увидеть, вызвав метод __doc__ , или функцию help() .

В Листинге 5.1.14 приведен пример написания документации к функции.

Листинг 5.1.14 — Документирование функции в Python | скачать ¶

# Для небольшой функции можно использовать однострочное документирование # Как правило, это описание действия в повелительном наклонении def sqrt(x): """Вернуть квадратный корень из 'x'.""" return x**0.5 # Если функция объемная, используется многострочное документирование def heron(a, b, c): """Вернуть площадь треугольника по формуле Герона. Параметры: - a, b, c (float): стороны треугольника. Результат: - float: значение площади. - None: если треугольник не существует. """ if not (a + b > c and a + c > b and b + c > a): return p = (a + b + c) / 2 return sqrt(p * (p - a) * (p - b) * (p - c)) # Справочную информацию о функции можно получить 2 способами: # heron.__doc__ или help(heron) print(heron.__doc__) params = [float(x) for x in input('Введите стороны (a b c): ').split()] s = heron(*params) if s: print('S = '.format(s)) else: print('Треугольник не существует!') # ------------- # Пример вывода: # Вернуть площадь треугольника по формуле Герона. # # Аргументы: # - a, b, c (float): стороны треугольника. # # Результат: # - float: значение площади. # - None: если треугольник не существует. # # Введите стороны (a b c): 3 4 5 # S = 6.00 

5.1.4. Анонимные функции¶

Python поддерживает синтаксис, позволяющий определять анонимные функции (лямбда-функции или лямбда-выражения):

lambda parameters: expression 

• часть parameters является необязательной, и если она присутствует, то обычно представляет собой простой список имен переменных, разделенных запятыми (позиционных аргументов);
• выражение expression не может содержать условных инструкций или циклов (условные выражения — допустимы), а также не может содержать инструкцию return ;
• результатом лямбда-выражения является анонимная функция.

Когда лямбда-функция вызывается, она возвращает результат вычисления выражения expression .

Пример записи лямбда-функции приведен в Листинге 5.1.15.

Листинг 5.1.15 — Лямбда-функции | скачать ¶

# Лямбда-функции, как правило, используются в случаях, где использование # функции не требует наличия у нее имени # # Если это требуется - лучше объявить обычную функцию, используя def # 1. Обычная и лямбда-функция выполняют одно и то же действие, # разница в синтаксисе def sqr1(x): return x**2 sqr2 = lambda x: x**2 # Если лямбда-выражение привязывается к идентификатору - # - оно не нужно; используйте обычные функции print(sqr1(6)) # 36 print(sqr2(6)) # 36 # 2. Лямбда-выражения удобно использовать для элементов функционального программирования # Эл-ты из таблицы Менделеева (номер группы, порядковый номер, наименование) elements = [(2, 12, "Mg"), (1, 11, "Na"), (1, 3, "Li"), (2, 4, "Be")] elements.sort(key=lambda x: x[1]) # Сортировка порядковому номеру print(elements) # [(1, 3, 'Li'), (2, 4, 'Be'), (1, 11, 'Na'), (2, 12, 'Mg')] # Функции max и min имеют ключевой аргумент key - параметр сортировки # key - ссылка на функцию, имеющую 1 возвращающую значение, по которому следует # сравнивать величины # 2.1. Используя лямбда-выражение lst = ["Java", "Algol", "C++"] print(max(lst, key=lambda x: x.count("a"))) # Элемент lst, в котором # больше всего "a" # 2.2. Тоже самое возможно с использованием обычной функции def find_a(x): return x.find("a") print(min(lst, key=find_a)) # Элемент lst, в котором # "a" находится левее 

5.1.5. Побочный эффект¶

Побочный эффект (англ. Side Effect) — любые действия программы, изменяющие среду выполнения (англ. Execution Environment).

К побочным эффектам выполнения функции можно отнести:

• изменение данных в памяти;
• чтение/запись файла или устройства;
• ввод/вывод значений;
• самостоятельную реакцию на исключительные ситуации;
• и др.

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

Создавая функцию, необходимо избегать побочных эффектов — такие функции легче тестируются и не содержат скрытых действий. Один из примеров такой функции — функция solve_equation() в Листинге 5.1.12 .

Естественно, что полностью избежать побочных эффектов невозможно. В таких случаях необходимо локализовать участки кода с побочным эффектом в отдельные функции (Листинге 5.1.16).

Листинг 5.1.16 — Локализация кода с побочным эффектом в отдельные функции | скачать ¶

def heron(a, b, c): """Вернуть площадь треугольника по формуле Герона. Параметры: - a, b, c (float): стороны треугольника. Результат: - float: значение площади. - None: если треугольник не существует. """ if not (a + b > c and a + c > b and b + c > a): return p = (a + b + c) / 2 return (p * (p - a) * (p - b) * (p - c))**0.5 def input_data(): """Запросить стороны треугольника с клавиатуры. Результат: - tuple of float: (a, b, c). Побочный эффект! """ return (float(x) for x in input('Введите стороны (a b c): ').split()) def print_res(res): """Вывести на экран 'res'. Параметры: - res (float): площадь треугольника. Побочный эффект! """ if res: print('S = '.format(res)) else: print('Треугольник не существует!') a, b, c = input_data() res = heron(a, b, c) print_res(res) 

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

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

Sebesta, W.S Concepts of Programming languages. 10E; ISBN 978-0133943023.

Саммерфилд М. Программирование на Python 3. Подробное руководство. — М.: Символ-Плюс, 2009. — 608 с.: ISBN: 978-5-93286-161-5.

Лучано Рамальо. Python. К вершинам мастерства. — М.: ДМК Пресс , 2016. — 768 с.: ISBN: 978-5-97060-384-0, 978-1-491-94600-8.

A Beginner’s Guide to Python’s Namespaces, Scope Resolution, and the LEGB Rule. URL: http://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html.

How do I write a function with output parameters (call by reference). URL: https://docs.python.org/3/faq/programming.html#id17.

Версия: 2023. Обновлено: 16.05.2023.

Процедуры и функции в Python

1 слайд Программирование на языке Python
Функции и процедуры
Выполнила: преподаватель информатики и ИТ Исмаилова Ш.П.

2 слайд ПОДПРОГРАММЫ: ФУНКЦИИ И ПРОЦЕДУРЫ
В процессе программирования может потребоваться использовать повторно какой-то фрагмент определенных операций в разных частях программы. Часть программы, содержащая этот набор действий, называется подпрограммой.
Подпрограммы выполняют определенную функцию, но не образуют отдельную систему.
Во время обращения к подпрограмме основная программа, обратившаяся к ней, останавливает свою работу и передаёт управление подпрограмме. После завершения выполнения подпрограммы управление опять возвращается к основной программе.

3 слайд ПОДПРОГРАММЫ: ФУНКЦИИ И ПРОЦЕДУРЫ
Вызов подпрограмм в основной программе дает следующие возможности:
• Подпрограмма вызывается только тогда, когда в ней есть необходимость. Она устраняет необходимость писать один и тот же код по несколько раз, и им можно воспользоваться повторно. Это повышает разделение кода на блоки, облегчает понимание кода и помогает в обнаружении ошибок.
Наличие ошибки в коде можно проверять в одном лишь блоке. Если ошибка находится в блоке, его можно устранить, всего лишь исправив одну ошибку в подпрограмме. А если не пользоваться подпрограммами, а несколько раз скопировать один и тот же код в несколько мест программы, то для устранения ошибки придется искать их по всей программе.
Можно будет в одном месте обновлять код: все внесенные изменения начнут действовать, как только произойдет обращение к подпрограмме.

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

5 слайд Стандартные функции
print() – выводит данные для пользователя. Например, разные выводы и результаты вычислений.
input() – обратная функция print(), передаёт данные, введенные пользователем программы.
randint() – выводит случайное число. Например, можно пользоваться для генерации в программе случайного числа.

6 слайд Объявление и вызов функции
В Python каждой созданной подпрограмме, как функции, так и процедуре, обязательно требуется название, и оно вводится после ключевого слова def – от define (анг.define – определение).
def – ключевое слово, объявляющее функцию;
название_функции – название для функции;
список параметров – этот список может состоять из нескольких параметров, они разделяются запятой;
блок_команд – тело функции должно располагаться с отступом, как и некоторые ранее рассмотренные операторы.
Когда функция вызывается названием, команды в ее теле будут выполняться последовательно. После окончания выполнения этих команд управление возвращается в ту самую точку, откуда была вызвана эта подпрограмма, и продолжится.

7 слайд Пример. Вывод сообщения

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

9 слайд Передача значений функции
Пример. Напишите программу, вычисляющую факториал n.
S=1*2*3*…*n=n!

10 слайд ФУНКЦИИ И ПЕРЕМЕННЫЕ
Каждая переменная после объявления выполняет какое-то важное действие в программе и связывается с другими элементами программы. Переменные, объявленные внутри функции (локальные переменные), и переменные, объявленные вне функции (глобальные переменные), тоже имеют разные степени доступа и важности.
Локальные переменные Локальные переменные можно использовать только внутри функции, в которой она была объявлена. В основной программе и других функциях она не работает. Поэтому во время обращения к локальной переменной вне функции появляется сообщение об ошибке.

11 слайд Пример

12 слайд Глобальные переменные
Глобальные переменные – это переменные, активные во всей программе. Они объявляются вне подпрограммы, то есть, в основной программе. Их обычно объявляют после импортирования модулей, в начале кода. К ним можно обращаться как к обычным переменным.

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

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

15 слайд Напишите программу вычисления самого максимального из трех чисел a, b и c. Используйте функцию.
Задача 1

16 слайд Решение Задачи 1
Напишите программу вычисления самого большого из трех чисел a, b и c. Используйте функцию.

17 слайд Напишите программу для вычисления степени k числа а. Для этого создайте функцию stepen (a, k)
Задача 2

18 слайд Решение Задачи 2
Напишите программу для вычисления степени k числа а. Для этого создайте функцию stepen (a, k)
def stepen(a, k):
b=a
while(k>1):
a=a*b
k=k-1
return a

a=int(input(‘Введите число: ‘))
k=int(input(‘Введите степень: ‘))
print(stepen(a, k))

19 слайд Напишите программу, зеркально отражающую заданное число. Например, 123 отражается как 321. Используйте функцию.
Задача 3

20 слайд Задача 3. Напишите программу, зеркально отражающую заданное число. Например, 123 отражается как 321. Используйте функцию.
def reverseNum(a):
while(a>0):
print(a%10, end=‘’)
a=a//10
return

a=int(input(‘Введите число: ‘))
reverseNum(a)

Рабочие листы
к вашим урокам

Доступно для всех учеников
1-11 классов и дошкольников

Наградные документы для всех участников

Подать заявку

Оплата после прохождения

Как учителю увеличить свой доход?

Стать автором рабочих листов

2 000 учителей заработали с нами более 6 000 000 рублей за последние пол года!

Рабочие листы и материалы для учителей и воспитателей

Более 20 000 дидактических материалов для школьного и домашнего обучения

Практическая работа Функции и процедуры в Python Цель работы: изучение процедур и функций в Python

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

Подпрограмма — это именованный фрагмент программы, к которому можно обратиться из другого места программы

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

1. Процедуры.

Рассмотрим синтаксис процедуры:

def имя процедуры(Список параметров):

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

Процедура — вспомогательный алгоритм, выполняющий некоторые действия.

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

Вызов процедуры осуществляется по ее имени, за которым следуют круглые скобки, например, Err().

В одной программе может быть сколько угодно много вызовов одной и той же процедуры.

Использование процедур сокращает код и повышает удобочитаемость.