функция с несколькими параметрами python
Функции и их аргументы
В этой статье я планирую рассказать о функциях, именных и анонимных, инструкциях def, return и lambda, обязательных и необязательных аргументах функции, функциях с произвольным числом аргументов.
Именные функции, инструкция def
Определим простейшую функцию:
Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y.
Теперь мы ее можем вызвать:
Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и даже функции!):
Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:
Аргументы функции
Функция может принимать произвольное количество аргументов или не принимать их вовсе. Также распространены функции с произвольным числом аргументов, функции с позиционными и именованными аргументами, обязательными и необязательными.
Функция также может принимать переменное количество позиционных аргументов, тогда перед именем ставится *:
Функция может принимать и произвольное число именованных аргументов, тогда перед именем ставится **:
В переменной kwargs у нас хранится словарь, с которым мы, опять-таки, можем делать все, что нам заблагорассудится.
Анонимные функции, инструкция lambda
Анонимные функции могут содержать лишь одно выражение, но и выполняются они быстрее. Анонимные функции создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией def func():
lambda функции, в отличие от обычной, не требуется инструкция return, а в остальном, ведет себя точно так же:
Функции в Python
Функции — важный компонент любого языка, и Python не является исключением. При написании любого крупного проекта невозможно обойтись без функций, поэтому каждый программист должен знать, как работать с ними.
Что такое функция
Функция — это блок кода, который можно многократно вызывать на выполнение. Она является фундаментальной частью любого языка программирования.
Функция может использоваться для обработки данных, она получает на вход значения, обрабатывает его и возвращает результат в программу. Также она может не возвращать значение, а выводить его на экран или записывать в файл.
Объявление
Объявляя функцию, нужно следовать определенным правилам:
Синтаксис объявления
Параметры (аргументы) нужно передавать в том порядке, в котором они определены в круглых скобках.
Пример кода
Функция складывает два числа, переданные в качестве аргументов. Если один или оба аргумента не были переданы, используются значения по умолчанию.
Вызов
После определения функции её можно вызвать в любой точке скрипта, как в теле самого скрипта, так и в теле другой функции:
Значение функции можно сразу передать в переменную или в другую функцию:
Необязательные параметры
При описании функции в Python 3 аргументы, которым задаются начальные значения, являются необязательными. Вначале должны описываться обязательные параметры и только после них необязательные.
При вызове функции нам не обязательно указывать значения необязательных параметров. Если мы хотим изменить значение аргумента, не меняя начальные значения других аргументов, можно обращаться к нему по ключу.
Вывод будет следующим:
Функция с переменным числом аргументов
Часто возникает необходимость создать такую функцию, которая может принимать разное количество аргументов. Это можно реализовать с помощью передачи списка или массива, однако Python позволяет использоваться более удобный подход (также с использованием списка).
Для того чтобы функция могла принять переменное количество аргументов, перед именем аргумента ставится символ » * «. Когда программист передаёт аргументы, они записываются в кортеж, имя которого соответствует имени аргумента:
Вместо одного символа звёздочки можно использовать два, тогда аргументы будут помещаться не в список, а в словарь:
Анонимные функции
Это особый вид функций, которые объявляются с помощью ключевого слова lambda вместо def :
Лямбда функции принимают любое количество аргументов, но не могут содержать несколько выражений и всегда возвращают только одно значение.
В программировании на Python можно обойтись без анонимных функций, которые по сути являются обычными, но без имени и с ограничением в одно выражение. Однако их использование в нужных местах упрощает написание и восприятие кода. Например, в программе калькулятор мы с её помощью сделали обработчики нажатия кнопок.
Синтаксис
Возврат значений
С помощью оператора return из функции можно вернуть одно или несколько значений. Возвращаемым объектом может быть: число, строка, None.
Чтобы вернуть несколько значений, нужно написать их через запятую. Python позволяет вернуть из функции список или другой контейнер: достаточно указать после ключевого слова return имя контейнера.
Вот пример когда возвращается список:
А это пример того, как функция в Python 3 возвращает несколько значений. Так как переменные перечислены через запятую, то они образуют список. Эти значения можно присвоить сразу нескольким переменным, как это показано в следующем примере:
Рекурсия
Рекурсией называется процесс, когда функция вызывает саму себя. Её можно использовать вместо циклов, например, для задачи по нахождению факториала.
Рекурсию рекомендуется использовать только там, где это действительно необходимо. Интерпретатор Python автоматически выделяет память для выполняющейся функции, если вызовов самой себя будет слишком много, это приведёт к переполнению стека и аварийному завершению программы. Следующий код вызовет исключение «RecursionError», которая показывает, что превышен максимальный лимит рекурсии.
Узнать максимальный лимит и его изменить можно с помощью getrecursionlimit() и setrecursionlimit(предел) из библиотеки sys.
Один из примеров применения рекурсии — это расчёт чисел Фибоначчи.
Пустая функция
Такие функции могут использоваться для различных специфичных задач, например, при работе с классами, асинхронной отправкой форм.
Области видимости
Область видимости — важная составляющая любого языка программирования. С её помощью в одном модуле можно использовать одно и то же имя переменной несколько раз.
Области видимости также делают программу более безопасной, не позволяя получить доступ к важным переменным.
В Python существует две области видимости:
Важно понимать, из локальной области видимости можно обратить к переменным, находящимся в глобальной, но не наоборот.
Подробнее про области видимости можно прочитать в отдельной статье на сайте.
Основные встроенные функции в Python
Python предоставляет программисту все необходимые основные функции для работы, кроме того, используя дополнительные модули (подключая разные библиотеки), можно найти уже реализованные методы для практически любой задачи.
Функции в Python
Python включает в себя множество встроенных функций. Такие функции выполняют заранее определенную задачу и могут быть вызваны по необходимости в любой программе. Однако если вы не нашли встроенной функции, которая способна решить вашу проблему, вы всегда можете сами написать подходящую. Сейчас мы рассмотрим, как определять и использовать функции в программе на Python.
Определение функции
Функция — это многократно используемый блок программных инструкции, предназначенный для выполнения определенной задачи. Для определения функции в Python используется ключевое слово def. Ниже приведен синтаксис определения функции.
За ключевым словом def следует подходящий идентификатор (имя функции) и круглые скобки. В круглых скобках может быть дополнительно указан один или несколько параметров. Символ ‘:’ после круглых скобок начинает блок с отступом (тело функции).
Первой инструкцией в теле функции может быть строка, которая называется docstring. Она описывает функциональность функции/класса. Строка docstring не является обязательной.
В общем случае тело функции содержит одну или несколько инструкций, которые выполняют некоторые действия. В нем также может использоваться ключевое слово pass.
Последней командой в блоке функции зачастую является инструкция return. Она возвращает управление обратно вызвавшему функцию окружению. Если после оператора return стоит выражение, то его значение также передается в вызывающий код.
В следующем примере определена функция welcome().
Параметры и аргументы функции
В программировании функции могут не только возвращать данные, но также принимать их, что реализуется с помощью так называемых параметров, которые указываются в скобках в заголовке функции. Количество параметров может быть любым.
Параметры представляют собой локальные переменные, которым присваиваются значения в момент вызова функции. Конкретные значения, которые передаются в функцию при ее вызове, будем называть аргументами. Следует иметь в виду, что встречается иная терминология. Например, формальные параметры и фактические параметры. В Python же обычно все называют аргументами.
Рассмотрим схему и поясняющий ее пример:
Когда интерпретатор переходит к функции, чтобы начать ее исполнение, он присваивает переменным-параметрам переданные в функцию значения-аргументы. В примере переменной a будет присвоено 100, b будет присвоено 12.
Существуют изменяемые типы данных. Для Питона, это, например, списки и словари. В этом случае данные передаются по ссылке. В функцию передается ссылка на них, а не сами данные. И эта ссылка связывается с локальной переменной. Изменения таких данных через локальную переменную обнаруживаются при обращении к ним через глобальную. Это есть следствие того, что несколько переменных ссылаются на одни и те же данные, на одну и ту же область памяти.
Необходимость передачи по ссылке связана в первую очередь с экономией памяти. Сложные типы данных, по сути представляющие собой структуры данных, обычно копировать не целесообразно. Однако, если надо, всегда можно сделать это принудительно.
Произвольное количество аргументов
Обратим внимание еще на один момент. Количество аргументов и параметров совпадает. Нельзя передать три аргумента, если функция принимает только два. Нельзя передать один аргумент, если функция требует два обязательных. В рассмотренном примере они обязательные.
Однако в Python у функций бывают параметры, которым уже присвоено значение по-умолчанию. В таком случае, при вызове можно не передавать соответствующие этим параметрам аргументы. Хотя можно и передать. Тогда значение по умолчанию заменится на переданное.
Согласно правилам синтаксиса Python при определении функции параметры, которым присваивается значение по-умолчанию должны следовать (находиться сзади) за параметрами, не имеющими значений по умолчанию.
А вот при вызове функции, можно явно указывать, какое значение соответствует какому параметру. В этом случае их порядок не играет роли:
В данном случае оба вызова – это вызовы с одними и теми же аргументами-значениями. Просто в первом случае сопоставление параметрам-переменным идет в порядке следования. Во-втором случае – по ключам, которыми выступают имена параметров.
В Python определения и вызовы функций имеют и другие нюансы, рассмотрение которых мы пока опустим, так как они требуют более глубоких знаний, чем у нас есть на данный момент. Скажем лишь, что функции может быть определена так, что в нее можно передать хоть ни одного аргумента, хоть множество:
Опять же, судя по скобкам, здесь возникает упомянутый в прошлом уроке кортеж.
Практическая работа
Напишите программу, в которой определены следующие четыре функции:
Функция getInput не имеет параметров, запрашивает ввод с клавиатуры и возвращает в основную программу полученную строку.
Функция strToInt имеет один параметр. В теле преобразовывает переданное значение к целочисленному типу. Возвращает полученное число.
Функция printInt имеет один параметр. Она выводит переданное значение на экран и ничего не возвращает.
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
Функции в 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
Важность функций
Абстракция
Человек бежит, машина едет, корабль плывёт, а самолёт летит. Всё это – объекты реального мира, которые выполняют однотипные действия. В данном случае, они перемещаются во времени и пространстве. Мы можем абстрагироваться от их природы, и рассматривать эти объекты с точки зрения того, какое расстояние они преодолели, и сколько времени на это ушло.
Мы можем написать функцию, которая вычисляет скорость в каждом конкретном случае. Нам не важно, кто совершает движение: и для человека и для самолёта средняя скорость будет рассчитываться одинаково.
Это простой пример и простая функция, но абстракции могут быть куда более сложными. И именно тогда раскрывается настоящая сила функций. Вместо того чтобы решать задачу для каждого конкретного случая, проще написать функцию, которая находит решение для целого ряда однотипных, в рамках применяемой абстракции, объектов. В случае сложных и длинных вычислений, это повлечёт за собой значительное сокращение объёмов кода, а значит и времени на его написание.
Возможность повторного использования
Функции были созданы ради возможности их многократного применения. Код без функций превратился бы в огромное нечитаемое полотно, на порядки превышающее по длине аналогичную программу с их использованием.
Например, при работе с массивами чисел, вам нужно часто их сортировать. Вместо того чтобы реализовать простой алгоритм сортировки (или использовать встроенную функцию), вам пришлось бы каждый раз перепечатывать тело этой или похожей функции:
Всего 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 trio_printer(a, b, c): print(a, b, c) trio_printer(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 low_word_printer(word): print(word.lower()) return 0 s = ‘GOOD’ low_word_printer(s) > good
Возвращаемое значение не представляет собой никакой ценности, поэтому low_word_printer(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
Рекурсия является частным случаем вложенной функции. Это функция, которая вызывает саму себя.