Как в python выполнять input внутри функции

Как в python выполнять input внутри функции

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

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

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

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

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

Здесь инструкция print(«Bye») не имеет отступов от начала функции say_hello и поэтому в эту функцию не входит. Обычно между определением функции и остальными инструкциями, которые не входят в функцию, располагаются две пустых строки.

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

Например, определим и вызовем функцию:

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

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

Если функция имеет одну инструкцию, то ее можно разместить на одной строке с остальным определением функции:

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

Локальные функции

Одни функции могут определяться внутри других функций — внутренние функции еще называют локальными . Локальные функции можно использовать только внутри той функции, в которой они определены. Например:

Здесь функции say_hello() и say_goodbye() определены внутри функции print_messages() и поэтому по отношению к ней являются локальными. Соответственно они могут использоваться только внутри функции print_messages()

Организация программы и функция main

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

Самоучитель

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

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

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

Левая часть определяет функцию f, принимающую один параметр, x. А правая часть — это определение функции, которое использует переданный параметр x, чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.

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

Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:

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

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

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

Ключевое слово return используется для определения значения, которое функция возвращает при вызове.

Чтобы вызвать функцию в Python, мы используем синтаксис имя_функции (параметры, через, запятую).

Ниже описан вызов функции f из предыдущего примера с параметром 2.

Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print.

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

У функции может быть один параметр, несколько параметров или вообще их не быть. Чтобы определить функцию, не требующую параметров, оставьте круглые скобки пустыми.

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

Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None.

Обязательные и необязательные параметры

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

В Python есть и другой вид параметров — опциональные. Опциональные параметры определяются с помощью следующего синтаксиса: имя_функции(имя_параметра = значение_параметра). Как и обязательные, опциональные параметры нужно отделять запятыми. Ниже приведен пример функции, в коде которой используется опциональный параметр.

Сначала функция вызывается без передачи параметра. Так как параметр необязательный, x автоматически становится равен 2, и функция возвращает 4.

Затем та же функция вызывается с параметром 4. То есть x будет равен 4 и функция вернет 16. Вы можете определить функцию, которая принимает как обязательные, так и опциональные параметры, но обязательные нужно определять в первую очередь.

Ввод, вывод и импорт в Python

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

Функции вроде input() и print() используются для операций ввода и вывода. Подробное знакомство мы начнем с вывода.

Вывод

Функция print() используется для вывода данных на экран. Эти данные мы можем записать и в файл, но об этом мы поговорим позже.

Пример использования

Вывод:

Еще один пример

Вывод:

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

Синтаксис

• objects — то, что мы хотим вывести.
• sep — разделитель между переменными. По умолчанию это пробел.
• end — то, чем кончается строка. По умолчанию это переход на новую строку.
• file — объект, указывающий, куда нужно производить вывод. По умолчанию данные выводятся на экран — sys.stdout .

Примеры

Вывод:

Форматирование вывода

Иногда нужно отформатировать вывод, чтобы он выглядел соответствующим образом. Для этого есть метод str.format() . Его можно использовать с любым строковым объектом.

Фигурные скобки <> здесь выступают в виде заполнителей. Порядок их вывода можно изменять с помощью индексов (индексов кортежа).

Вывод:

Для форматирования строк можно использовать именованные аргументы.

Для форматирования строк можно использовать sprintf() . Это старый способ, который использовался еще в языке Си. Для этого используется оператор % .

До этого момента все наши программы были статическими — все значения переменных мы объявляли заранее.

Теперь нам нужно больше свободы — возможно, мы захотим получить данные от пользователя. В Python для этих целей существует функция input() . Ее синтаксис выглядит так:

promt — это строка, которую мы хотим вывести на экран.

Как можно заметить, введенное значение — строка, а не число. Преобразовать это значение в число можно с помощью функции int() или float() .

Эту же операцию можно выполнить с помощью функции eval() . У eval() есть преимущество — эта функция может проводить расчеты даже если в качестве аргумента передана строка.

Импорт модулей

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

Модуль — это файл, содержащий функции и операторы. У всех модулей в Python есть имя, которое заканчивается расширением .py .

Операторы внутри модуля могут быть импортированы в другой модуль или в интерпретатор Python. Для этого мы используем ключевое слово import .

Например, мы можем импортировать модуль math . Делается это следующим образом:

Пример использованияя

Вывод:

Теперь все переменные внутри модуля math доступны в нашей программе. Можно импортировать и только определенные функции и переменные из модуля.

5.1. Теория¶

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

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

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

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

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

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

тип возвращаемого значения (необязательно).

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

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

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

указать имя подпрограммы;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

декомпозиция сложной задачи на несколько более простых подзадач: это один из двух главных инструментов структурного программирование (второй — структуры данных);

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

распределение большой задачи между несколькими разработчиками или стадиями проекта;

сокрытие деталей реализации от пользователей подпрограммы;

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

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

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

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

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

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

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

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

пустые строки для отделения функций, а большие блоки кода помещать внутрь функций;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

нет необходимости отслеживать порядок аргументов;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Локальная (англ. Local)

Собственная область внутри инструкции def .

Нелокальная (англ. Enclosed)

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

Глобальная (англ. Global)

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

Встроенная (англ. Built-in).

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

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

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

функции образуют локальную область видимости, а модули – глобальную;

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

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

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

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

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

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

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

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

передать мутирующий аргумент в качестве параметра функции.

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

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

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

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

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

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

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

5.1.3.4. Рекурсия¶

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

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

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

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

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

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

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

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

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

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

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

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

часть parameters является необязательной, и если она присутствует, то обычно представляет собой простой список имен переменных, разделенных запятыми (позиционных аргументов);

выражение expression не может содержать условных инструкций или циклов (условные выражения — допустимы), а также не может содержать инструкцию return ;

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

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

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

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

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

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

изменение данных в памяти;

чтение/запись файла или устройства;

самостоятельную реакцию на исключительные ситуации;

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

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

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

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

Например, если необходимо вычислить сумму и среднее значение элементов списка, правильнее будет создать 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.