Что такое функция Python определение и вызов, возврат значения, аргументы


Содержание материала:

Что такое функция Python: определение и вызов, возврат значения, аргументы

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

Создание функции

Существуют некоторые правила для создания функций в Python.

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

Пример функции в Python:

Вызов функции

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

Аргументы функции в Python

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

  • Обязательные аргументы (Required arguments)
  • Аргументы-ключевые слова (Keyword argument)
  • Аргументы по умолчанию (Default argument)
  • Аргументы произвольной длины (Variable-length argumens)

Обязательные аргументы функции:

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

Аргументы — ключевые слова

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

Аргументы, заданные по-умолчанию

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

Аргументы произвольной длины

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

Ключевое слово return

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

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

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

В Python две базовых области видимости переменных:

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

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

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

Рекурсия

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

Напомним, что факториалом числа, например, 5 является произведение всех натуральных (целых) чисел от 1 до 5. То есть, 1 * 2 * 3 * 4 * 5

Рекурсивная функция вычисления факториала на языке Python будет выглядеть так:

Однако следует помнить, что использование рекурсии часто может быть неоправданным. Дело в том, что в момент вызова функции в оперативной памяти компьютера резервируется определенное количество памяти, соответственно чем больше функций одновременно мы запускаем — тем больше памяти потребуется, что может привести к переполнению стека (stack overflow) и программа завершится аварийно, не так как предполагалось. Учитывая это, там где это возможно, вместо рекурсии лучше применять циклы.

Рецепт создания функции в Python

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

  1. Начинать следует с примеров того, что делает функция, и подобрать подходящее название. В нашем случае это будет выглядеть так:
  2. Указать типы данных, которые принимает функция и тип данных, который она возвращает
  3. Подобрать подходящие названия для переменных
  4. Написать краткое, но содержательное описание функции
  5. Написать собственно тело функции
  6. Функция готова! Осталось вызвать ее с указанными в примерах аргументами

Как видно, при вызове команды help() с именем нашей функции в качестве аргумента мы получаем написанную нами документацию.

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

Возврат значений

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

Научиться писать функции, которые возвращают информацию — первый шаг на пути к построению по-настоящему полезных программ.

Начнем с тривиального примера: создадим и вызовем функцию, которая принимает два числа и возвращает первое число минус второе. Назовём её sub , от англ. “subtract” — «вычесть»:

Обратите внимание: мы знаем, что вызов функции — выражение, поэтому мы передали вызов одной функции в вызов другой функции — print(sub(10, 7)) .

Возврат задаётся специальной инструкцией return . Cправа от return помещается выражение. Любое выражение. То есть, мы можем делать вычисления сразу после return без создания переменной result :

После исполнения функции возвращенный результат «встаёт» на место вызова:

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

Посмотрите на эту функцию:

Что выведется на экран?

Правильный ответ: 7 . Функция всегда будет возвращать только число 7 , так как интерпретатор, наткнувшись на первый return , остановит выполнение функции. Строчка кода return 10 никогда не выполнится.

Задание

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

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

Для реализации используйте уже существующие функции parent_for и len :

  • Получение имени матери parent_for(child, ‘mother’) , где child — имя ребёнка.
  • Получение имени отца parent_for(child, ‘father’) , где child — имя ребёнка
  • Получение длины строки: len(str) , где str — строка

Вам не нужно вызывать свою функцию, только определить её.

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

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

IT-записки

вторник, 17 сентября 2013 г.

Python, функция return нескольких значений

Несколько возвращаемых значений

Функции Python могут возвращать больше одного значения. Предположим, есть функция вида:

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

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

5. Функции, возвращающие значения¶

5.1. Возвращаемые значения¶

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

До сих пор ни одна из написанных нами функций не возвращала значения.

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

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

Однако имейте в виду, что временные переменные, такие как temp , часто делают отладку проще.

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

Поскольку предложения return здесь находятся в альтернативных ветках потока выполнения, будет выполнено только одно из них. Как только это произойдет, функция завершится; никакие последующие предложения выполняться не будут.

В рассматриваемой функции можно опустить else и просто поместить второе предложение return после составного предложения if .

Посмотрите внимательно на эту версию и убедитесь, что она работает так же, как и первая.

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

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

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

None является единственным значением типа NoneType :

Все функции Python, если не возвращают некоторое значение явно, возвращают None .

5.2. Разработка программы¶

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

Для того, чтобы разрабатывать программы все возрастающей сложности, рассмотрим прием, называемый инкрементной разработкой. Цель инкрементной разработки — избежать длительной и мучительной отладки программы. Это становится возможным, если за один раз добавлять и тестировать небольшой объем кода.

Предположим, вы хотите найти расстояние между двумя точками, заданными с помощью их координат (x1, y1) и (x2, y2). Согласно теореме Пифагора, расстояние составляет:

Первый шаг разработки — обдумать, как должна выглядеть функция distance на языке Python. Другими словами, что должно быть у функции на входе (параметры) и что — на выходе (возвращаемое значение)?

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

Теперь можно набросать эскиз функции:

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

Чтобы протестировать эту функцию, вызовем её с тестовыми значениями:

Значения параметров подобраны так, чтобы горизонтальное расстояние равнялось 3, а вертикальное равнялось 4. Таким образом, результат должен быть равен 5 — гипотенуза прямоугольного треугольника со сторонами 3-4-5, изображенного на рисунке. При тестировании функции полезно заранее знать правильный ответ.

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

Первый шаг состоит в нахождении разностей x2— x1и y2— y1. Мы сохраним эти значения во временных переменных dx и dy и выведем их.

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

Далее мы подсчитываем сумму квадратов dx и dy :

Обратите внимание, что мы удалили предложения print , написанные на предыдущем шаге. Подобный код, используемый временно в ходе разработки, называется вспомогательным кодом, или отладочным. Он играет роль строительных лесов при “строительстве” программы, но сам не является частью окончательной версии программы.

И вновь мы запустим программу и проверим её вывод. Должно получиться 25.

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

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

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

Топ-пост этого месяца:  Предварительная загрузка шрифтов – отличный способ ускорить страницу

Придерживайтесь следующих правил:

  1. Начните с работающей программы и делайте небольшие инкрементные изменения. В каждый момент, когда вы столкнетесь с ошибкой, вы будете знать, где она.
  2. Используйте временные переменные для сохранения промежуточных результатов, так чтобы их можно было вывести и проверить.
  3. Если программа работает, то можно удалить вспомогательный код и собрать отдельные предложения в составные выражения. Однако это не должно сделать программу трудной для чтения!

5.3. Композиция¶

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

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

Пусть координаты центральной точки хранятся в переменных xc и yc , а координаты точки на периметре окружности — в переменных xp и yp . Первым шагом будет нахождение радиуса окружности, равного расстоянию между этими двумя точками. Для этого воспользуемся функцией distance , которая делает именно то, что нам нужно:

Второй шаг — найти площадь круга данного радиуса и вернуть её. И снова мы воспользуемся одной из ранее написанных функций:

Оформив этот код в виде функции, получаем:

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

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

5.4. Логические функции¶

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

Имя этой функции is_divisible . Принято давать логическим функциям имена, выглядящие как вопрос, предполагающий один из двух возможных ответов: да или нет. Функция is_divisible возвращает либо True либо False , тем самым показывая, делится или не делится x на y .

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

А вот новая функция в действии:

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

У вас может появиться соблазн написать:

Но дополнительное сравнение здесь лишнее.

5.5. Тип function ¶

В Python function (англ.: функция) также является типом, как и уже известные нам int , float , str , bool и NoneType .

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

Функция doto вызывается три раза. В каждом вызове аргументом для value является 7, а для func — функции f , g и h , по очереди. Этот скрипт выводит:

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

5.6. Оформление программ¶

Читабельность программ очень важна для программистов, поскольку на практике читать и изменять программы приходится гораздо чаще, чем писать новые. Все примеры кода в этой книге соответствуют Python Enhancement Proposal 8 (PEP 8). Это руководство по стилю программирования, разработанное сообществом программистов Python.

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

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

5.7. Строки в тройных кавычках¶

В дополнение к строкам, заключенным в одинарные и двойные кавычки, с которыми мы впервые встретились в разделе Значения и типы главы 2, в Python также имеются строки в тройных кавычках:

Строки в тройных кавычках могут содержать внутри как одинарные, так и двойные кавычки:

Кроме того, строковые значения, заключенные в тройные кавычки, могут распространяться на несколько строк:

5.8. Модульное тестирование с помощью doctest ¶

В последнее время широкую известность получило автоматическое модульное тестирование (англ.: unit testing) — очень полезная практика разработки программ. Модульное тестирование позволяет убедиться, что отдельные части кода, такие как функции, работают правильно.

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

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

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

Модуль doctest автоматически выполняет предложения, начинающиеся с >>> , и сравнивает следующую строку с тем, что вывел интерпретатор.

Чтобы посмотреть, как это работает, поместите следующее в скрипт с именем myfunctions.py :

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

Запустив скрипт на выполнение, получим следующее:

Это пример неуспешного теста. Тест ожидает, что вызов is_divisible_by_2_or_5(8) даст результат True . Поскольку вызов is_divisible_by_2_or_5 не вернул ничего, тест считается неуспешным, и doctest сообщает, что ожидалось значение True , но не было получено ничего.

Заставим этот тест выполняться, возвращая True :

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

Чтобы увидеть более подробный отчет о выполнении теста, запустите скрипт с опцией -v :

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

Теперь запустите скрипт с опцией -v и посмотрите, что получится.

5.9. Глоссарий¶

5.10. Упражнения¶

Все упражнения, приведенные ниже, добавляйте в файл ch05.py , в конце которого поместите следующие строки:

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

Напишите функцию compare , которая возвращает 1 , если a > b , 0 , если a == b и -1 , если a b . Поместите тело функции после следующих доктестов и убедитесь, что они успешно проходят.

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

Напишите функцию slope(x1, y1, x2, y2) (англ.: наклон), которая возвращает наклон прямой, проходящей через точки (x1, y1) и (x2, y2). Под наклоном здесь имеется в виду отношение проекции отрезка прямой на ось y к проекции этого же отрезка на ось x. (Чем больше это отношение, тем круче наклон прямой.) Убедитесь, что ваша реализация slope проходит следующие тесты:

Используйте slope в новой функции intercept(x1, y1, x2, y2) (англ.: отсекать, отделять), которая возвращает координату y точки пересечения прямой с осью y. Прямая задана точками (x1, y1) и (x2, y2) .

Функция intercept должна пройти приведенные доктесты.

Напишите функцию is_even(n) (англ.: четный), которая принимает целое число в качестве аргумента и возвращает True , если аргумент является четным, и False , если аргумент нечетный. Начните создание функции с написания доктестов для нее.

Теперь напишите функцию is_odd(n) (англ.: нечетный), возвращающую True , когда n нечетное число, и False в противном случае. Начните создание функции с написания доктестов для нее.

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

Напишите тело функции is_factor (англ.: множитель) так, чтобы доктесты проходили:

Напишите тело функции is_multiple (англ.: кратное число) так, чтобы доктесты проходили. Можно ли использовать is_factor в функции is_multiple ?

Напишите тело функции f2c , возвращающей округленное целое число градусов Цельсия для температуры, указанной в градусах Фаренгейта.

Подсказка: можно воспользоваться встроенной функцией round (англ.: округлить). Попробуйте напечатать round.__doc__ в интерактивном режиме Python и поэкспериментируйте с round , чтобы разобраться, что эта функция делает.

А теперь напишите тело функции c2f для преобразования градусов Цельсия в градусы Фаренгейта.

7 примеров функций Python с параметрами, возвратом и типом данных

Главное меню » Язык программирования Python » 7 примеров функций Python с параметрами, возвратом и типом данных

Функции улучшают возможность повторного использования кода.

В этой статье мы обсудим следующие примеры:

  1. Пример базовой функции Python
  2. Встроенные функции Python
  3. Пользовательские функции Python
  4. Параметры функции Python
  5. Функция Python. Неизвестное количество параметров
  6. Возвращаемое значение функции Python
  7. Тип данных для параметра s и возвращаемого значения

1. Пример базовой функции Python

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

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

2. Встроенные функции Python

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

Еще несколько примеров таких функций: len(), str(), int(), abs(), sum() и т. д.

Все встроенные функции, поддерживаемые Python3, здесь.

3. Пользовательские функции Python

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

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

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

4. Параметры функции Python

Функция может иметь параметры по умолчанию.

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

5. Функция Python. Неизвестное количество параметров

Если число параметров, которые должна ожидать функция, неизвестно, тогда * args добавляется в определение функции в качестве одного из параметров. Этот параметр ожидает кортеж. Звездочка (*) здесь важна. Название args – это просто соглашение. Ему можно дать любое другое имя.

Точно так же ** kwargs ожидает словарь в качестве параметра.

Приведенный выше фрагмент кода имеет ссылку на цикл for. Обратитесь к этому для получения более подробной информации: 12 незаменимых примеров команды Loop в Python

6. Возвращаемое значение функции Python

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

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

7. Тип данных для параметров и возвращаемого значения

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

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

На этом все. Удачи в программировании.

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Получить несколько переменных из функции через return

Всем привет! такой вопрос, есть функция, например:

как мне получить значения r1 и r2 максимально удобно из конструкции типа

но не вызывая функцию 2 раза? (чтобы не делать 2 запроса) и чтобы z1 присвоился строго r1, а z2- строго r2.

3 ответа 3

Присвойте оба значения сразу:

Функция func() возвращает кортеж (r1, r2) Если Вы выполните:

В r1_2 будет кортеж (r1, r2), к которому можно обращаться по индексу:

Можно сократить код, воспользовавшись особой магией питона:

Строго говоря, функция в Python всегда возвращает ОДНО значение. Однако это значение — любого типа. Например — кортеж, который вы можете распаковать указанными способами. Для удобства чтения кода пишут как у вас:

однако точно так же все будет работать, если вы подчеркнете тот факт, что возвращается кортеж явно указав скобки:

где-то в PEP-8 рекомендуется первый («ваш») вариант, однако иногда это приводит даже к синтаксическим ошибкам!! Не могу вспомнить где я это видел, но пример такой:

выдает ошибку, а это :

Всё ещё ищете ответ? Посмотрите другие вопросы с метками python python-3.x функции или задайте свой вопрос.


Похожие

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

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

дизайн сайта / логотип © 2020 Stack Exchange Inc; пользовательское содержимое попадает под действие лицензии cc by-sa 4.0 с указанием ссылки на источник. rev 2020.11.7.35374

5.1. Теория¶

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

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

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

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

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

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

Топ-пост этого месяца:  Laravel формы управление и настройка, генерация основных элементов HTML

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

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

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. К вершинам мастерства. — М.: ДМК Пресс , 2020. — 768 с.: ISBN: 978-5-97060-384-0, 978-1-491-94600-8.

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

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

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

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

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

Общеизвестные функции

Если вы уже писали код на Python, эти модули должны быть вам знакомы.

print

Вряд ли найдётся разработчик, даже начинающий, который не знает эту функцию вывода. Как минимум реализация «Hello, World!» требует использования данного метода. Но вы можете не знать о различных аргументах, которые можно передавать в print .

В Python нет синтаксиса вроде my_list.length() или my_string.length , вместо этого используются поначалу непривычные конструкции len(my_list) и len(my_string) .

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

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

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

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

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

Топ-пост этого месяца:  Как создать в Grid CSS макет приложения используемые свойства и реализация поддержки IE11

Обратите внимание, если нужно обрезать дробную часть при делении, оператор « // » более уместен (с отрицательными числами это работает иначе).

float

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

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

В Python 2 такое преобразование необходимо, но в Python 3 целочисленное деление больше не является чем-то особенным (если вы специально не используете оператор « // »). Поэтому больше не нужно использовать float для этой цели, теперь float(x)/y можно легко заменить на x/y .

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

При работе со списком метод copy позволяет создать его копию.

Если вы не знаете, с какими элементами работаете, функция list является более общим способом перебора элементов и их копирования.

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

Покоряем Python — уроки для начинающих

Бесплатные уроки для начинающих по изучению языка программирования Python. Будут рассмотрены: Django и парсинг на Python-e с помощью библиотек

11 ноября 2012 г.

Аргументы

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

• Операция присваивания именам аргументов внутри функции не оказывает влияния на вызывающую программу.

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

Передача аргументов очень близка к языку С:
• Неизменяемые объекты передаются «по значению». Такие объекты, как целые числа и строки, передаются в виде ссылок на объекты, а не в виде копий объектов.

• Изменяемые объекты передаются «по указателю». Такие объекты, как списки и словари, также передаются в виде ссылок на объекты, что очень похоже на то, как в языке C передаются указатели на массивы, – изменяемые объекты допускают возможность непосредственного изменения внутри функции так же, как и массивы в языке C.
Пример:
>>> def f(a): # Имени a присваивается переданный объект
. a = 99 # Изменяется только локальная переменная
.
>>> b = 88
>>> f(b)# Первоначально имена a и b ссылаются на одно и то же число 88
>>> print(b) # Переменная b не изменилась
88
В этом фрагменте в момент вызова функции f(b) переменной a присваивается объект 88, но переменная a существует только внутри вызванной функции. Изменение переменной a внутри функции не оказывает влияния на окружение, откуда была вызвана функция, – просто в момент вызова создается совершенно новый объект a .
——————————————————————

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


При попытке изменения кортежа будет возбуждено исключение:
L = [1, 2]
changer(X, tuple(L)) # Передается кортеж, поэтому попытка изменения
# возбудит исключение
Здесь используется встроенная функция tuple , которая создает новый кортеж из всех элементов последовательности (в действительности – любого итерируе мого объекта). Это особенно важно, потому что вынуждает писать функцию так, чтобы она никогда не пыталась изменять передаваемые ей аргументы. Од нако такое решение накладывает на функцию больше ограничений, чем следу ет, поэтому его вообще следует избегать (нельзя знать заранее, когда изменение аргументов окажется необходимым). Кроме того, при таком подходе функция
теряет возможность применять к аргументу методы списков, включая методы,
которые не производят непосредственных изменений.

Имитация выходных параметров:
Мы уже обсудили инструкцию return и использовали ее в нескольких примерах. Эта инструкция может возвращать объект любого типа, поэтому с ее помощью можно возвращать сразу несколько значений, упаковав их в кортеж или в коллекцию любого другого типа.

>>> def multiple(x, y):
. x = 2 # Изменяется только локальное имя
. y = [3, 4]
. return x, y # Новые значения возвращаются в виде кортежа
.
>>> X = 1
>>> L = [1, 2]
>>> X, L = multiple(X, L) # Результаты присваиваются именам
>>> X, L # в вызывающей программе
(2, [3, 4])

Синтаксис сопоставления, синтаксис использования специальных режимов сопоставления:
func(value)- Вызывающая программа — Обычный аргумент: сопоставление производится по позиции

func(name=value) — Вызывающая программа — Именованный аргумент: сопоставление производится по указанному имени

func(*sequence) — Вызывающая программа — Все объекты в указанной последовательности передаются как отдельные позиционные аргументы

func(**dict) — Вызывающая программа — Все пары ключ/значение в указанном словаре передаются как отдельные именованные аргументы

def func(name) — Функция — Обычный аргумент: сопоставление производится по позиции
или по имени

def func(name=value) — Функция — Значение аргумента по умолчанию, на случай, если аргумент не передается функции

def func(*name) — Функция — Определяет и объединяет все дополнительные аргументы
в кортеж

def func(**name) — Функция — Определяет и объединяет все
дополнительные именованные аргументы в словарь

def func(*args, name)
def func(*, name=value) — Функция — Аргументы, которые должны передаваться функции только по именам (3.0).

Случаи вызова функции и определения функции:
• В инструкции вызова функции (первые четыре строки таблицы) при использовании простых значений соответствие именам аргументов определяется по позиции, но при использовании формы name=value соответствие определяется по именам аргументов – это называется передачей именованных аргументов. Использование форм *sequence и **dict в вызовах функций позволяет передавать произвольное число объектов по позиции или по именам в виде последовательностей и словарей соответственно.

• В заголовке функции (остальная часть таблицы) при использовании простых значений соответствие определяется по позиции или по имени, в зависимости от того, как вызывающая программа передает значения, но при использовании формы name=value определяются значения по умолчанию. При использовании формы *name все дополнительные позиционные аргументы объединяются в кортеж, а при использовании формы **name все дополнительные именованные аргументы объединяются в словарь. В версии Python 3.0 и выше любые обычные аргументы или аргументы со значениями по умолчанию, следующие за формой *name или за единственным символом * , являются именованными аргументами, которые при вызове функции должны передаваться только по имени.

Работаем с функциями в Python

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

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

Просто, не так ли?

Пустая функция (stub)

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

А вот здесь кое-что новенькое: оператор pass. Это пустая операция, это означает, что когда оператор pass выполняется, не происходит ничего.

Передача аргументов функции

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

Каждая функция выдает определенный результат. Если вы не указываете на выдачу конкретного результата, она, тем не менее, выдаст результат None (ничего). В нашем примере мы указали выдать результат a + b. Как вы видите, мы можем вызвать функцию путем передачи двух значений. Если вы передали недостаточно, или слишком много аргументов для данной функции, вы получите ошибку:

Вы также можете вызвать функцию, указав наименование аргументов:

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

Вы, возможно, подумаете: «А что, собственно, произойдет, если мы укажем аргументы, но они названы неправильно? Это сработает?» Давайте попробуем на примере:

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

Ключевые аргументы

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

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

Функция вернулась к нам с числом 3. Почему? Причина заключается в том, что а и b по умолчанию имеют значение 1 и 2 соответственно. Теперь попробуем создать функцию, которая имеет обычный аргумент, и несколько ключевых аргументов:

Выше мы описали три возможных случая. Проанализируем каждый из них. В первом примере мы попробовали вызвать функцию, используя только ключевые аргументы. Это дало нам только ошибку. Traceback указывает на то, что наша функция принимает, по крайней мере, один аргумент, но в примере было указано два аргумента. Что же произошло? Дело в том, что первый аргумент необходим, потому что он ни на что не указывает, так что, когда мы вызываем функцию только с ключевыми аргументами, это вызывает ошибку. Во втором примере мы вызвали смешанную функцию, с тремя значениями, два из которых имеют название. Это работает, и выдает нам ожидаемый результат: 1+4+5=10. Третий пример показывает, что происходит, если мы вызываем функцию, указывая только на одно значение, которое не рассматривается как значение по умолчанию. Это работает, если мы берем 1, и суммируем её к двум значениям по умолчанию: 2 и 3, чтобы получить результат 6! Удивительно, не так ли?

*args и **kwargs

Вы также можете настроить функцию на прием любого количества аргументов, или ключевых аргументов, при помощи особого синтаксиса. Чтобы получить бесконечное количество аргументов, мы используем *args, а чтобы получить бесконечное количество ключевых аргументов, мы используем *kwargs. Сами слова “args” и “kwargs” не так важны. Это просто сокращение. Вы можете назвать их *lol и *omg, и они будут работать таким же образом. Главное здесь – это количество звездочек. Обратите внимание: в дополнение к конвенциям *args и *kwargs, вы также, время от времени, будете видеть andkw. Давайте взглянем на следующий пример:

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

Область видимость и глобальные переменные

Концепт области (scope) в Пайтон такой же, как и в большей части языков программирования. Область видимости указывает нам, когда и где переменная может быть использована. Если мы определяем переменные внутри функции, эти переменные могут быть использованы только внутри это функции. Когда функция заканчиваются, их можно больше не использовать, так как они находятся вне области видимости. Давайте взглянем на пример:

Если вы запустите этот код, вы получите ошибку:

Это вызвано тем, что переменная определенна только внутри первой функции, но не во второй. Вы можете обойти этот момент, указав в Пайтоне, что переменная а – глобальная (global). Давайте взглянем на то, как это работает:

Этот код работает, так как мы указали Пайтону сделать а – глобальной переменной, а это значит, что она работает где-либо в программе. Из этого вытекает, что это настолько же хорошая идея, насколько и плохая. Причина, по которой эта идея – плохая в том, что нам становится трудно сказать, когда и где переменная была определена. Другая проблема заключается в следующем: когда мы определяем «а» как глобальную в одном месте, мы можем случайно переопределить её значение в другом, что может вызвать логическую ошибку, которую не просто исправить.

Советы в написании кода

Одна из самых больших проблем для молодых программистов – это усвоить правило «не повторяй сам себя». Суть в том, что вы не должны писать один и тот же код несколько раз. Когда вы это делаете, вы знаете, что кусок кода должен идти в функцию. Одна из основных причин для этого заключается в том, что вам, вероятно, придется снова изменить этот фрагмент кода в будущем, и если он будет находиться в нескольких местах, вам нужно будет помнить, где все эти местоположения И изменить их.

Сайт doctorsmm.com предлагает Вам персональные предложения по покупке лайков в ВК к постам и публикациям. Здесь Вы найдете дешевые цены на услуги, а также различные критерии, подходящие к любой ситуации. На сервисе также доступно приобретение репостов, голосов в голосования и опросы сети.

Копировать и вставлять один и тот же кусок кода – хороший пример спагетти-кода. Постарайтесь избегать этого так часто, как только получится. Вы будете сожалеть об этом в какой-то момент либо потому, что вам придется все это исправлять, либо потому, что вы столкнетесь с чужим кодом, с которым вам придется работать и исправлять вот это вот всё.

Подведем итоги

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

Добавить комментарий