Как использовать функции в python
Введение в Python
Поиск
Новое на сайте
Функции в Python
Функция это блок организованного, многократно используемоего кода, который используется для выполнения конкретного задания. Функции обеспечивают лучшую модульность приложения и значительно повышают уровень повторного использования кода.
Создание функции
Существуют некоторые правила для создания функций в Python.
Пример функции в Python:
Вызов функции
После создания функции, ее можно исполнять вызывая из другой функции или напрямую из оболочки Python. Для вызова функции следует ввести ее имя и добавить скобки.
Аргументы функции в Python
Вызывая функцию, мы можем передавать ей следующие типы аргументов:
Обязательные аргументы функции:
Если при создании функции мы указали количество передаваемых ей аргументов и их порядок, то и вызывать ее мы должны с тем же количеством аргументов, заданных в нужном порядке.
Аргументы, заданные по-умолчанию
Аргумент по умолчанию, это аргумент, значение для которого задано изначально, при создании функции.
Аргументы произвольной длины
Иногда возникает ситуация, когда вы заранее не знаете, какое количество аргументов будет необходимо принять функции. В этом случае следует использовать аргументы произвольной длины. Они задаются произвольным именем переменной, перед которой ставится звездочка (*).
Ключевое слово return
Выражение return прекращает выполнение функции и возвращает указанное после выражения значение. Выражение return без аргументов это то же самое, что и выражение return None. Соответственно, теперь становится возможным, например, присваивать результат выполнения функции какой либо переменной.
Область видимости
Некоторые переменные скрипта могут быть недоступны некоторым областям программы. Все зависит от того, где вы объявили эти переменные.
В Python две базовых области видимости переменных:
Переменные объявленные внутри тела функции имеют локальную область видимости, те что объявлены вне какой-либо функции имеют глобальную область видимости.
Это означает, что доступ к локальным переменным имеют только те функции, в которых они были объявлены, в то время как доступ к глобальным переменным можно получить по всей программе в любой функции.
Рекурсия
Рекурсией в программировании называется ситуация, в которой функция вызывает саму себя. Классическим примером рекурсии может послужить функция вычисления факториала числа.
Напомним, что факториалом числа, например, 5 является произведение всех натуральных (целых) чисел от 1 до 5. То есть, 1 * 2 * 3 * 4 * 5
Рекурсивная функция вычисления факториала на языке Python будет выглядеть так:
Рецепт создания функции в Python
Как видно, при вызове команды help() с именем нашей функции в качестве аргумента мы получаем написанную нами документацию.
Сопровождайте ваши функции качественной документацией и программисты, которые будут работать с вашим кодом после вас будут вам благодарны.
Самоучитель
Функции в Python для начинающих
В этой части мы изучим функции — составные инструкции, которые могут принимать данные ввода, выполнять указания и возвращать данные вывода. Функции позволяют определять и повторно использовать определенную функциональность в компактной форме.
Вызвать функцию — значит передать ей входные данные, необходимые для выполнения и возвращения результата. Когда вы передаете функции входные данные, это называется передача параметра функции.
Функции в 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 позволяет разделить большую программу на основные строительные блоки, известные как функции.
Что такое функция в Python?
Функции в Python – это организованный блок многократно используемого кода, который можно вызывать при необходимости.
Функция содержит набор программных операторов, заключенных в <>. Функцию можно вызывать несколько раз, чтобы обеспечить возможность повторного использования и модульность программы Python.
Функция помогает программисту разбить программу на более мелкие части. Она очень эффективно организует код и избегает повторения кода. По мере роста программы функция делает ее более организованной.
Python предоставляет нам различные встроенные функции, такие как range() или print(). Пользователь также может создавать свои функции, которые можно назвать пользовательскими функциями.
В основном есть два типа функций:
В этом руководстве мы обсудим функции, определяемые пользователем.
Преимущество функций в Python
У функций Python есть следующие преимущества:
Создание
Python предоставляет ключевое слово def для определения функции. Синтаксис функции определения приведен ниже.
Давайте разберемся с синтаксисом определения функций.
Вызов функции
В Python после создания функции мы можем вызывать ее из другой функции. Перед вызовом функция должна быть определена; в противном случае интерпретатор Python выдает ошибку. Чтобы вызвать функцию, используйте имя функции, за которым следуют круглые скобки.
Рассмотрим простой пример, который выводит сообщение «Hello World».
Оператор возврата return
Оператор return используется в конце функции и возвращает результат функции. Он завершает выполнение функции и передает результат туда, где функция вызывается. Оператор return не может использоваться вне функции.
Он может содержать выражение, которое оценивается, и значение возвращается вызывающей функции. Если оператор return не имеет выражения или не существует сам по себе в функции, он возвращает объект None.
Рассмотрим следующие примеры:
Выход:
The sum is: 30
В приведенном выше коде мы определили функцию с именем sum, и у нее есть оператор c = a + b, который вычисляет заданные значения, а результат возвращается оператором return вызывающей функции.
Пример 2. Создание функции без оператора возврата
В приведенном выше коде мы определили ту же функцию без оператора return, так как мы видим, что функция sum() вернула объект None вызывающей функции.
Аргументы в функции
Аргументы – это типы информации, которые можно передать функции. Аргументы указаны в скобках. Мы можем передать любое количество аргументов, но они должны быть разделены запятой.
Рассмотрим следующие примеры, содержащий функцию, которая принимает строку в качестве аргумента.
Вызов по ссылке в Python
В Python вызов по ссылке означает передачу фактического значения в качестве аргумента функции. Все функции вызываются по ссылке, т. е. все изменения, внесенные в ссылку внутри функции, возвращаются к исходному значению, на которое ссылается ссылка.
Пример 1. Передача неизменяемого объекта(списка)
Выход:
list inside function = [10, 30, 40, 50, 20, 30]
list outside function = [10, 30, 40, 50, 20, 30]
Пример 2. Передача изменяемого объекта(строки)
Выход:
печать строки внутри функции: Hi I am there Hows you
печать строки вне функции: Hi I am there.
Типы аргументов
Может быть несколько типов аргументов, которые могут быть переданы во время вызова функции.
Обязательные
Мы можем предоставить аргументы во время вызова функции. Обязательные аргументы – это аргументы, которые необходимо передать во время вызова функции с точным совпадением их позиций в вызове функции и определении функции. Если какой-либо из аргументов не указан в вызове функции или положение аргументов изменено, интерпретатор Python покажет ошибку.
Рассмотрим следующие примеры.
Выход:
Введите имя: Джон
привет, Джон
Пример 2.
Выход:
Введите основную сумму: 5000
Введите процентную ставку: 5
Введите время в годах: 3
Простой процент: 750,0
Пример 3
Выход:
TypeError: calculate() отсутствует 1 обязательный позиционный аргумент: ‘b’
Аргументы по умолчанию
Python позволяет нам инициализировать аргументы при определении функции. Если значение любого из аргументов не предоставляется во время вызова функции, то этот аргумент может быть инициализирован значением, указанным в определении, даже если аргумент не указан при вызове функции.
Выход:
My name is John and age is 22
Пример 2.
Выход:
My name is john and age is 22
My name is David and age is 10
Аргументы переменной длины(* args)
В больших проектах иногда мы можем не знать количество аргументов, которые нужно передать заранее. В таких случаях Python предоставляет нам гибкость, предлагая значения, разделенные запятыми, которые внутренне обрабатываются как кортежи при вызове функции. Используя аргументы переменной длины, мы можем передавать любое количество аргументов.
Рассмотрим следующий пример:
Выход:
type of passed argument is
printing the passed arguments.
john
David
smith
nick
В приведенном выше коде мы передали * имена в качестве аргумента переменной длины. Мы вызвали функцию и передали значения, которые внутри обрабатываются как кортежи. Кортеж – это итеративная последовательность, такая же, как и список. Чтобы напечатать заданные значения, мы повторили имена * arg, используя цикл for в Python.
Аргументы ключевого слова(** kwargs)
Python позволяет нам вызывать функцию с аргументами ключевых слов. Такой вызов функции позволит нам передавать аргументы в случайном порядке.
Имя аргументов рассматривается как ключевое слово и сопоставляется при вызове и определении функции. Если такое же совпадение найдено, значения аргументов копируются в определение функции.
Рассмотрим следующие примеры.
Выход:
printing the message with John and hello
Пример 2. С указанием значений в другом порядке при вызове.
Выход:
Simple Interest: 1900.0
Если мы предоставим другое имя аргументов во время вызова функции, будет выдана ошибка.
Рассмотрим следующий пример.
Выход:
TypeError: simple_interest() got an unexpected keyword argument ‘time’
Python позволяет нам предоставлять сочетание необходимых аргументов и аргументов ключевого слова во время вызова функции. Однако обязательный аргумент не должен указываться после аргумента ключевого слова, т. е. после того, как аргумент ключевого слова встречается в вызове функции, следующие аргументы также должны быть аргументами ключевого слова.
Рассмотрим следующие примеры.
Выход:
SyntaxError: positional argument follows keyword argument
Python предоставляет возможность передавать несколько аргументов ключевого слова, которые могут быть представлены как ** kwargs. Похож на * args, но сохраняет аргумент в формате словаря. Этот тип аргументов полезен, когда мы не знаем заранее количество аргументов.
Рассмотрим следующий пример:
Пример 6. Многие аргументы используют аргумент ключевого слова.
Объем переменных
Объем переменных зависит от места, где переменная объявляется. Переменная, объявленная в одной части программы, может быть недоступна для других частей.
В Python переменные определяются с двумя типами областей видимости:
Известно, что переменная, определенная вне любой функции, имеет глобальную область видимости, тогда как переменная, определенная внутри функции, имеет локальную область видимости.
Рассмотрим следующий пример.
Пример 1. Локальная переменная
Выход:
The sum is 60
Value of sum outside the function: 0
Функция в Python: руководство для начинающих
Мир IT меняется очень быстро, и успевать за ним нелегко. Но если вы хорошо разбираетесь в какой-нибудь технологии, это дает вам определенные преимущества.
Python – широко используемый язык, открывающий множество возможностей. Научиться правильно использовать функции – важный навык для любого Python-разработчика. Поэтому мы и решили написать это руководство по функциям Python для начинающих.
Цель этой статьи – дать вам знания, необходимые для начала работы с функциями в Python.
Итак, давайте начнем!
Зачем нужны функции Python?
Функции управляют входными и выходными данными в компьютерных программах. Языки программирования предназначены прежде всего для работы с данными. А функции — эффективный способ управления этими данными и их преобразованиями.
Модификации данных обычно нужны для получения каких-то результатов, вроде выполнения действий или поиска. Набор операций и инструкций, которые нужны для этого, выполняется из основного кода программы.
Фактически, основной (main) код — это тоже функция, просто очень важная. Все другие функции логически выстраиваются, чтобы выполняться из основного кода.
Но если функция не была объявлена ранее, вам придется сперва ее объявить. Дело в том, что в объявлении перечисляются шаги, которые выполняет функция.
Итак, функции – это не что иное, как задачи, которые хочет выполнять пользователь. И если вы пропишете нужную функциональность один раз и дадите ей имя, вы сможете использовать ее повторно, не превращая свою программу в огромного монстра. Это значительно сокращает количество строк кода и даже упрощает отладку.
Мы скоро поговорим об этом, но первая причина, по которой стоит использовать функцию, – это возможность ее повторного использования.
Функции как средство повторного использования кода
Даже сложные операции вполне могут быть набором нескольких не слишком сложных. А для осуществления каждой небольшой операции можно создать отдельную функцию и вызывать ее по имени. Такой подход сделал современные программы куда более понятными.
Все языки программирования позволяют создавать и использовать функции для решения различных задач. И самое главное — вызывать каждую функцию можно сколько угодно раз.
При этом вам не приходится каждый раз беспокоиться, как код функции встроится в основной код программы. Важно лишь осознавать, что функция выполняется так, как прописано в инструкциях внутри нее.
У машин могут быть разные функции. Калькулятор, вероятно, самый распространенный пример. В нем предусмотрены функции сложения, вычитания, умножения, деления и пр. Все его функции явно предопределены, но он выполняет только те, которые вы выбираете для вызова, нажимая соответствующую кнопку.
Благодаря использованию функций программисты сокращают время на написание кода и отладку, тем самым ускоряя разработку ПО.
Марк Лутц «Изучаем Python»
Скачивайте книгу у нас в телеграм
Что собой представляет функция в Python?
Функция в Python – классический пример многократного использования кода.
Чтобы обслуживать широкий спектр приложений, от GUI и математических вычислений до веб-разработки и тестирования, интерпретатор Python оснащен многочисленными функциями, готовыми к использованию.
Вы также можете добавлять в свою программу библиотеки или модули, содержащие дополнительные функции. Все, что вам нужно для этого сделать — загрузить необходимые пакеты, в соответствии с их документацией. После этого вы сможете свободно использовать все полезные функции, просто импортировав их в свой код.
Итак, однажды определенная функция может использоваться любое количество раз в любой точке любого вашего кода.
Дело в том, что Python придерживается принципа DRY. Аббревиатура расшифровывается как Don’t Repeat Yourself («Не повторяйся»).
Это один из принципов разработки ПО. Он направлен на замену дубликатов кода абстракциями. Это позволяет избежать избыточности и гарантировать, что абстрагированный код сможет свободно использоваться, не раскрывая внутренних деталей реализации.
Таким образом, все, что вам понадобится для использования функции, это знать ее имя, назначение, аргументы (если она их принимает) и тип ее результата (если она его возвращает).
Определение функции
Функция – это подпрограмма, которая работает с данными и производит некоторый вывод.
Чтобы определить функцию Python, вам нужно будет использовать ключевое слово def перед именем вашей функции. Сразу за именем добавляются круглые скобки, за которыми следует двоеточие.
Python для обозначения блоков использует отступы вместо скобок, чтобы код был более читабельным.
После выполнения оператора return поток программы возвращается в состояние, следующее за вызовом вашей функции, и продолжает выполнение оттуда.
Итак, функция в Python может вызываться в любом месте кода. Для вызова вам нужно будет использовать ее имя и при необходимости передать в нее аргументы в круглых скобках.
Кроме того, хорошая практика — называть функцию Python в соответствии с тем, что она делает. Используйте docstring прямо под первой строкой объявления функции. Эта строка документации, объясняющая, что делает функция.
Типы функций в Python
В Python есть много видов функций. И каждый из них по-своему очень важен:
Давайте подробно рассмотрим эти функции, начиная со встроенных, поскольку их очень легко понять и реализовать.
Встроенные функции Python
Интерпретатор Python имеет ряд функций, которые всегда доступны для использования. Эти функции называются встроенными.
Например, функция print() выводит указанный объект на стандартное устройство вывода (экран) или в файл текстового потока.
В Python 3.6 есть 68 встроенных функций. Давайте рассмотрим несколько наиболее часто используемых.
Функция all()
Синтаксис метода all() :
Функция abs()
Метод abs() возвращает абсолютное значение заданного числа. Если число является комплексным, abs() возвращает его величину.
Синтаксис метода abs() :
Функция enumerate()
Метод enumerate() добавляет счетчик к итерируемому объекту и возвращает индексы элементов с их значениями.
Метод enumerate() принимает два параметра:
Также существует множество других встроенных функций, например:
Рекурсивные функции в Python
Рекурсия – это определение чего-либо в терминах самого себя.
Примером в физическом мире может быть размещение двух параллельных зеркал, обращенных друг к другу. Любой объект между ними будет отражаться рекурсивно.
Мы знаем, что функция в Python может вызывать другие функции. Но функция может вызывать и сама себя. Конструкции такого типа и называются рекурсивными функциями.
Ниже приведен пример рекурсивной функции для поиска факториала целого числа.
Факториал числа – это произведение всех целых чисел от 1 до этого числа. Например, факториал 5 (обозначается как 5!) это 1 * 2 * 3 * 4 * 5 = 120.
В приведенном выше примере calc_factorial() является рекурсивной функцией, потому что она вызывает саму себя.
Когда мы вызываем эту функцию с положительным целым числом, она рекурсивно вызывает себя, уменьшая исходное число.
Наша рекурсия заканчивается, когда число уменьшается до 1. Это называется базовым случаем. Каждая рекурсивная функция должна иметь базовый случай, останавливающий рекурсию, потому что иначе функция будет вызывать себя бесконечно.
От редакции Pythonist. Больше примеров использования рекурсии можно найти в статье «Примеры программ с использованием рекурсии на языке Python».
Лямбда-функции в Python
В Python можно определить функцию, не давая ей имени. Такая функция называется анонимной.
Лямбда-функция в Python имеет следующий синтаксис:
Лямбда-функции могут иметь любое количество аргументов, но только одно выражение.
В приведенной выше программе lambda x: x * 2 – это лямбда-функция. Здесь x – аргумент, а x * 2 — выражение, которое вычисляется и возвращается.
Пользовательские функции Python
Функции, которые поставляются с Python, называются встроенными функциями. Если мы используем функции, написанные другими людьми и выложенные в форме библиотеки, это можно назвать библиотечными функциями.
Все остальные функции, которые мы пишем самостоятельно, относятся к пользовательским функциям. При этом наша пользовательская функция может быть библиотечной функцией для кого-то еще.
Преимущества пользовательских функций
Прежде всего, пользовательские функции помогают разбить большую программу на небольшие сегменты. Это упрощает понимание, поддержку и отладку кода.
Если в программе встречается повторяющийся код, его можно выделить в функцию и выполнять при необходимости путем вызова этой функции.
Кроме того, программисты, работающие над большим проектом, могут разделить рабочую нагрузку, занимаясь разными функциями.
Пример пользовательской функции
И в заключение давайте посмотрим, как с помощью функций Python создать простое приложение.
Создаем калькулятор на Python
В этом примере мы создадим простой калькулятор, умеющий складывать, вычитать, умножать или делить числа, введенные пользователем.
В результате получим следующее:
Заключение
Надеемся, вам понравилось это руководство по функциям. Теперь вы знаете, что из себя представляет функция в Python, какие функции бывают, как их писать и как ими пользоваться. Создание собственных функций поможет вам удобно добавлять нужный функционал в свои программы.
Функции в Python — синтаксис, аргументы, вызов, выход
Функция — это фрагмент программного кода, который решает какую-либо задачу.
Его можно вызывать в любом месте основной программы. Функции помогают избегать дублирования кода при многократном его использовании. А также имеют ряд других преимуществ, описанных ниже.
Синтаксис
💁♀️ Простой пример: Вы торгуете мёдом, и после каждой продажи вам нужно печатать чек. В нём должно быть указано: название фирмы, дата продажи, список наименований проданных товаров, их количество, цены, общая сумма, а также сакраментальная фраза «Спасибо за покупку!».
Если не пользоваться функциями, всё придётся прописывать вручную. В простейшем случае программа будет выглядеть так:
print(«ООО Медовый Гексагон») print(«Мёд липовый», end=» «) print(1, end=»шт «) print(1250, end=»р») print(«\nCумма», 1250, end=»р») print(«\nСпасибо за покупку!»)
А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.
Хорошо, что данный процесс можно легко оптимизировать с использованием функций.
Встаёт резонный вопрос: где же обещанное упрощение и куда подевались товары? Как раз для этого, мы и будем описывать состав покупки не напрямую в функции, а в отдельном списке кортежей. Каждый кортеж состоит из трёх элементов: название товара, количество и цена.
# (название, количество, цена за штуку) honey_positions = [ («Мёд липовый», 3, 1250), («Мёд цветочный», 7, 1000), («Мёд гречишный», 6, 1300), («Донниковый мёд», 1, 1750), («Малиновый мёд», 10, 2000), ]
Теперь этот список передадим в функцию как аргумент, и самостоятельно считать больше не придётся.
Да, код стал более массивным. Однако теперь для печати чека вам не придётся самостоятельно вычислять итог. Достаточно лишь изменить количество и цену товаров в списке. Существенная экономия времени! Слава функциям!
Термины и определения
Ключевое слово def в начале функции сообщает интерпретатору о том, что следующий за ним код — есть её определение. Всё вместе — это объявление функции.
# объявим функцию my_function() def my_function(): # тело функции
Аргументы часто путают с параметрами:
Ключевая особенность функций — возможность возвращать значение
# она будет принимать два множителя, а возвращать их округленное # до целого числа произведение def int_multiple(a, b): product = a * b # возвращаем значение return int(product) print(int_multiple(341, 2.7)) > 920
☝️ Главная фишка возвращаемых значений в том, что их можно использовать в дальнейшем коде: присваивать переменным, совершать с ними разные операции и передавать как аргументы в другие функции.
# найдём квадратный корень из возврата функции int_multiple # во встроенную функцию sqrt() мы передали вызов int_multiple print(math.sqrt(int_multiple(44, 44))) > 44
Важность функций
Абстракция
Человек бежит, машина едет, корабль плывёт, а самолёт летит. Всё это — объекты реального мира, которые выполняют однотипные действия. В данном случае, они перемещаются во времени и пространстве. Мы можем абстрагироваться от их природы, и рассматривать эти объекты с точки зрения того, какое расстояние они преодолели, и сколько времени на это ушло.
Мы можем написать функцию, которая вычисляет скорость в каждом конкретном случае. Нам не важно, кто совершает движение: и для человека и для самолёта средняя скорость будет рассчитываться одинаково.
def calculate_speed(distance, time): return distance / time
Это простой пример и простая функция, но абстракции могут быть куда более сложными. И именно тогда раскрывается настоящая сила функций. Вместо того чтобы решать задачу для каждого конкретного случая, проще написать функцию, которая находит решение для целого ряда однотипных, в рамках применяемой абстракции, объектов. В случае сложных и длинных вычислений, это повлечёт за собой значительное сокращение объёмов кода, а значит и времени на его написание.
Возможность повторного использования
Функции были созданы ради возможности их многократного применения. Код без функций превратился бы в огромное нечитаемое полотно, на порядки превышающее по длине аналогичную программу с их использованием.
Например, при работе с массивами чисел, вам нужно часто их сортировать. Вместо того чтобы реализовать простой алгоритм сортировки (или использовать встроенную функцию), вам пришлось бы каждый раз перепечатывать тело этой или похожей функции:
Всего 10 таких сортировок, и привет, лишние 60 строк кода.
Модульность
Разбитие больших и сложных процессов на простые составляющие — важная часть, как кодинга, так и реальной жизни. В повседневности мы занимаемся этим неосознанно. Когда убираемся в квартире, мы пылесосим, моем полы и окна, очищаем поверхности от пыли и наводим блеск на всё блестящее. Всё это — составляющие одного большого процесса под названием «уборка», но каждую из них также можно разбить на более простые подпроцессы.
В программировании модульность строится на использовании функций. Для каждой подзадачи — своя функция. Такая компоновка в разы улучшает читабельность кода и уменьшает сложность его дальнейшей поддержки.
Допустим, мы работаем с базой данных. Нам нужна программа, которая считывает значения из базы, обрабатывает их, выводит результат на экран, а затем записывает его обратно в базу.
Без применения модульности получится сплошная последовательность инструкций:
Но если вынести каждую операцию в отдельную функцию, то текст главной программы получится маленьким и аккуратным.
Это и называется модульностью.
Пространство имен
Концепция пространства имён расширяет понятие модульности. Однако цель — не облегчить читаемость, а избежать конфликтов в названиях переменных.
💁♀️ Пример из жизни: в ВУЗе учатся два человека с совпадающими ФИО. Их нужно как-то различать. Если сделать пространствами имён группы этих студентов, то проблема будет решена. В рамках своей группы ФИО этих студентов будут уникальными.
Объявление и вызов функций
def hello(): print(‘Adele is cute’)
После того как мы это сделали, функцию можно вызвать в любой части программы, но ниже самого объявления.
# код выполняется последовательно, поэтому сейчас интерпретатор # не знает о существовании функции hello hello() def hello(): print(‘Adele is cute’) > NameError: name ‘hello’ is not defined
Поэтому стоит лишь поменять объявление и вызов местами, и всё заработает:
def hello(): print(‘Adele is cute’) hello() > Adele is cute
Область видимости функций
Рассмотрим подробнее области видимости:
Локальная (L)
Локальная область видимости находится внутри def :
def L(): # переменная i_am_local является локальной внутри L() i_am_local = 5
Область объемлющих функций (E)
def e(): x = 5 def inner_e(): nonlocal x x = x + 1 return x return inner_e() print(e()) > 6
Глобальная (G)
# G num = 42 def some_function(n): res = n + num return res print(some_function(1)) > 43
Аргументы
Позиционные
Вспомним, аргумент — это конкретное значение, которое передаётся в функцию. Аргументом может быть любой объект. Он может передаваться, как в литеральной форме, так и в виде переменной.
Значения в позиционных аргументах подставляются согласно позиции имён аргументов:
Именованные
Пусть есть функция, принимающая три аргумента, а затем выводящая их на экран. Python позволяет явно задавать соответствия между значениями и именами аргументов.
def print_trio(a, b, c): print(a, b, c) print_trio(c=4, b=5, a=6) > 6 5 4
При вызове соответствие будет определяться по именам, а не по позициям аргументов.
Необязательные параметры (параметры по умолчанию)
Python позволяет делать отдельные параметры функции необязательными. Если при вызове значение такого аргумента не передается, то ему будет присвоено значение по умолчанию.
def not_necessary_arg(x=’My’, y=’love’): print(x, y) # если не передавать в функцию никаких значений, она отработает со значениями по умолчанию not_necessary_arg() > My love # переданные значения заменяют собой значения по умолчанию not_necessary_arg(2, 1) > 2 1
Аргументы переменной длины (args, kwargs)
Когда заранее неизвестно, сколько конкретно аргументов будет передано в функцию, мы пользуемся аргументами переменной длины. Звёздочка «*» перед именем параметра сообщает интерпретатору о том, что количество позиционных аргументов будет переменным:
def infinity(*args): print(args) infinity(42, 12, ‘test’, [6, 5]) > (42, 12, ‘test’, [6, 5])
Переменная args составляет кортеж из переданных в функцию аргументов.
Функции в питоне могут также принимать и переменное количество именованных аргументов. В этом случае перед названием параметра ставится » ** «:
def named_infinity(**kwargs): print(kwargs) named_infinity(first=’nothing’, second=’else’, third=’matters’) >
Здесь kwargs уже заключает аргументы не в кортеж, а в словарь.
Передача по значению и по ссылке
В Python аргументы могут быть переданы, как по ссылке, так и по значению. Всё зависит от типа объекта.
Изменяемые объекты передаются в функцию по ссылке. Изменяемыми они называются потому что их содержимое можно менять, при этом ссылка на сам объект остается неизменной.
В Python изменяемые объекты это:
Будьте внимательны при передаче изменяемых объектов. Одна из частых проблем новичков.
💭 В функциональном программировании существует понятие «функциями с побочными эффектами» — когда функция в процессе своей работы изменяет значения глобальных переменных. По возможности, избегать таких функций.
Словарь в качестве аргументов (упаковка)
Передаваемые в функцию аргументы можно упаковать в словарь при помощи оператора «**»:
def big_dict(**arguments): print(arguments) big_dict(key=’value’) >
Возвращаемые значения (return)
Что можно возвращать
Функции в Python способны возвращать любой тип объекта.
Распаковка возвращаемых значений
☝️ Обратите внимание, что количество возвращаемых значение в кортеже должно совпадать с количеством переменных при распаковке. Иначе произойдет ошибка:
Пустая функция
Иногда разработчики оставляют реализацию на потом, и чтобы объявленная функция не генерировала ошибки из-за отсутствия тела, в качестве заглушки используется ключевое слово pass :
Чистые функции и побочные эффекты
Немного функционального программирования. Есть такие функции, которые при вызове меняют файлы и таблицы баз данных, отправляют данные на сервер или модифицируют глобальные переменные. Всё это — побочные эффекты.
У чистых функций побочных эффектов нет. Такие функции не изменяют глобальные переменные в ходе выполнения, не рассылают и не выводят на печать никакие данные, не касаются объектов, и так далее.
Чистые функции производят вычисления по заданным аргументам и возвращают зависящий только от них самих результат.
Lambda функции
lambda_test = lambda a, b: pow(a, b) print(lambda_test(2, 4)) > 16
Docstring
Документировать код — особое искусство. Оно существует параллельно с разработкой и сопоставимо с ней по важности. Поэтому нередко документации в программе больше, чем самого кода.
Когда над проектом работает большая команда, а может и не одна, да и еще и много лёт подряд, то значение и важность документации возрастают прямо пропорционально.
Аннотация типов
Python — язык с динамической типизацией. По этой причине вполне возможны ситуации, когда вопреки ожиданиям разработчика в функцию подаются, например, не целые числа, а, допустим, строки. Чтобы отслеживать подобные случаи и сильнее контролировать процесс выполнения программы, была изобретена аннотация типов.
С помощью аннотации типов мы указываем, что параметры в функции имеют строго определенный тип.
При этом интерпретатор считывает аннотации типов, но никак их не обрабатывает.
Функции vs процедуры — в чем отличие?
Для языка нет различий между функциями и процедурами. Но с точки зрения программиста — это разные сущности.
Отличие в том, что функции возвращают значение, а процедуры — нет. Отсюда вытекают и разные области их применения и смысл использования. Скажем, производить некие вычисления в процедуре бессмысленно.
def proc(i, j): pow(i, j) proc(1, 200)
def func(i, j): return pow(i, j) print(func(3, 2)) > 9
И наоборот, оформлять набор инструкций, выполняющий некую обработку, в виде функции также лишено смысла:
def print_low_word(word): print(word.lower()) return 0 s = ‘GOOD’ print_low_word(s) > good
Возвращаемое значение не представляет собой никакой ценности, поэтому print_low_word(s) лучше оформить, как процедуру.
Время выполнения функции
Чтобы оценить время выполнения функции, можно поместить её вызов внутрь следующего кода:
Вложенные функции и рекурсия
Функции, которые объявляются и вызываются внутри других функций, называются вложенными.
def outerFunc(): def firstInner(): print(‘This is first inner function’) def secondInner(): print(‘This is second inner function’) firstInner() secondInner() outerFunc() > This is first inner function > This is second inner function
Рекурсия является частным случаем вложенной функции. Это функция, которая вызывает саму себя.