функции параметры в питоне
Параметры (аргументы) функции
Функции могут не только возвращать данные, но также принимают их, что реализуется с помощью так называемых параметров, которые указываются в скобках в заголовке функции. Количество параметров может быть любым, так же существует несколько вариантов передачи аргументов в функцию
Параметры функции представляют собой локальные переменные, которым присваиваются значения в момент ее вызова. Иногда у параметрам задают значения (аргументы), используемые по умолчанию. Конкретные значения, которые передаются в функцию при ее вызове, называются аргументами.
Каждый раз, когда вызывается функция, создается новая область видимости для хранения локальных переменных этой функции и каждое имя передаваемого параметра связывается со значениями в новом локальном пространстве имен. Когда функция возвращает значение или завершает выполнение иным способом, это пространство имен уничтожается.
Параметры (аргументы) функции передаются в локальную область видимости с использованием вызова по значению, где значение всегда является ссылкой на объект, а не значением объекта.
Необходимость передачи по ссылке связана в первую очередь с экономией памяти. Сложные типы данных, по сути представляющие собой структуры данных, обычно копировать не целесообразно. Однако, если надо, всегда можно сделать это принудительно.
Какие бывают аргументы/параметры в функциях Python.
Есть два типа аргументов:
Например, 3 и 5 являются аргументами ключевого слова в следующих вызовах встроенной функции complex() :
Аргументы назначаются именованным локальным переменным в теле функции. Смотрите правила, регулирующие это назначение в разделе «Что происходит при вызове функции?».
Синтаксически, для представления аргумента может использоваться любое выражение, а оцененное значение присваивается локальной переменной.
Параметры и аргументы функции
В программировании функции могут не только возвращать данные, но также принимать их, что реализуется с помощью так называемых параметров, которые указываются в скобках в заголовке функции. Количество параметров может быть любым.
Параметры представляют собой локальные переменные, которым присваиваются значения в момент вызова функции. Конкретные значения, которые передаются в функцию при ее вызове, будем называть аргументами. Следует иметь в виду, что встречается иная терминология. Например, формальные параметры и фактические параметры. В Python же обычно все называют аргументами.
Рассмотрим схему и поясняющий ее пример:
Когда интерпретатор переходит к функции, чтобы начать ее исполнение, он присваивает переменным-параметрам переданные в функцию значения-аргументы. В примере переменной a будет присвоено 100, b будет присвоено 12.
Существуют изменяемые типы данных. Для Питона, это, например, списки и словари. В этом случае данные передаются по ссылке. В функцию передается ссылка на них, а не сами данные. И эта ссылка связывается с локальной переменной. Изменения таких данных через локальную переменную обнаруживаются при обращении к ним через глобальную. Это есть следствие того, что несколько переменных ссылаются на одни и те же данные, на одну и ту же область памяти.
Необходимость передачи по ссылке связана в первую очередь с экономией памяти. Сложные типы данных, по сути представляющие собой структуры данных, обычно копировать не целесообразно. Однако, если надо, всегда можно сделать это принудительно.
Произвольное количество аргументов
Обратим внимание еще на один момент. Количество аргументов и параметров совпадает. Нельзя передать три аргумента, если функция принимает только два. Нельзя передать один аргумент, если функция требует два обязательных. В рассмотренном примере они обязательные.
Однако в Python у функций бывают параметры, которым уже присвоено значение по-умолчанию. В таком случае, при вызове можно не передавать соответствующие этим параметрам аргументы. Хотя можно и передать. Тогда значение по умолчанию заменится на переданное.
Согласно правилам синтаксиса Python при определении функции параметры, которым присваивается значение по-умолчанию должны следовать (находиться сзади) за параметрами, не имеющими значений по умолчанию.
А вот при вызове функции, можно явно указывать, какое значение соответствует какому параметру. В этом случае их порядок не играет роли:
В данном случае оба вызова – это вызовы с одними и теми же аргументами-значениями. Просто в первом случае сопоставление параметрам-переменным идет в порядке следования. Во-втором случае – по ключам, которыми выступают имена параметров.
В Python определения и вызовы функций имеют и другие нюансы, рассмотрение которых мы пока опустим, так как они требуют более глубоких знаний, чем у нас есть на данный момент. Скажем лишь, что функции может быть определена так, что в нее можно передать хоть ни одного аргумента, хоть множество:
Опять же, судя по скобкам, здесь возникает упомянутый в прошлом уроке кортеж.
Практическая работа
Напишите программу, в которой определены следующие четыре функции:
Функция getInput не имеет параметров, запрашивает ввод с клавиатуры и возвращает в основную программу полученную строку.
Функция strToInt имеет один параметр. В теле преобразовывает переданное значение к целочисленному типу. Возвращает полученное число.
Функция printInt имеет один параметр. Она выводит переданное значение на экран и ничего не возвращает.
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
Функции и их аргументы в Python 3
Встроенные функции в Python позволяют осуществлять самые разные операции. Каждая из них решает какую-то особую задачу. Но кроме них есть еще функции, которые пишут сами программисты.
В этой статье мы рассмотрим, как создавать и вызывать функции в Python. Также мы коснемся темы передачи параметров и аргументов в функцию.
Что такое функция?
Функция – это изолированный блок кода, который решает отдельную задачу.
Смысл функций в том, что они позволяют избежать ненужного повторения кода. Если какое-то действие повторяется часто и в разных местах, это хороший показатель того, что код для этого действия можно выделить в отдельную функцию.
Функции также помогают организовать ваш код.
Если нужно внести какое-то изменение в код функции, обновить придется только ее. Без функций у вас были бы многократно повторяющиеся куски одинакового кода в разных местах, и обновлять этот код пришлось бы повсюду.
Если говорить о принципах программирования, использование функций — это следование принципу DRY (Don’t Repeat Yourself — «не повтоярйся»).
Код внутри функции запускается только тогда, когда функцию вызывают.
Функции могут принимать аргументы и значения по умолчанию. При вызове они могут возвращать какое-то значение в вызвавший их код, но могут и не возвращать ничего.
Определение функции в Python
Базовый синтаксис определения функции выглядит так:
Итак, давайте разберемся:
Определение и вызов простой функции в Python
Ниже приведен пример базовой функции. В ней нет оператора return, и никаких параметров она тоже не принимает.
Эта функция просто выводит hello world при каждом вызове.
Когда функция определена, код в ней не запускается сам по себе. Для его выполнения необходимо сделать вызов функции.
Вызывать функцию можно столько раз, сколько вам нужно.
Для вызова функции используется следующий синтаксис:
Сначала пишется имя функции. За ним пишутся круглые скобки. Если функция имеет обязательные аргументы, они должны быть перечислены в скобках. Если аргументов у функции нет, скобки все равно нужно написать, просто они останутся пустыми.
Для вызова функции из нашего примера пишем следующий код:
Как определять и вызывать функции с параметрами в Python
Пока что мы рассмотрели самый базовый вариант функции. Она лишь выводит что-то в консоль.
Но что, если в функцию нужно передать какие-то дополнительные данные?
Здесь мы используем такие термины, как параметры и аргументы.
Параметры – это именованные заполнители. Они работают как переменные, определенные локально в строке объявления функции.
Для форматирования строки мы могли бы использовать f-строки. Код, приведенный ниже, работает точно так же, как и приведенный выше:
Мы можем передать функции столько параметров, сколько душе угодно, разделив их запятыми:
При вызове функции в нее передаются аргументы.
Аргументы — это информация, переданная в функцию. Они представляют собой настоящие значения, соответствующие параметрам, которые были указаны при объявлении функции.
Марк Лутц «Изучаем Python»
Скачивайте книгу у нас в телеграм
Вызов функции из предыдущего примера и передача аргументов будет выглядеть так:
Функцию можно вызывать многократно, каждый раз передавая разные значения в качестве аргументов:
Аргументы, которые мы рассматривали до сих пор, называются позиционными. Все позиционные аргументы являются обязательными.
Количество позиционных аргументов имеет значение
Когда мы вызываем наши функции, мы должны передавать правильное количество аргументов, иначе мы получим ошибку.
Число передаваемых аргументов при вызове функции должно быть равным числу параметров, указанных при объявлении этой функции. Нельзя ни убавить, ни прибавить.
Скажем, у нас есть функция с двумя параметрами:
Если мы попробуем вызвать эту функцию, передав всего один аргумент, мы получим ошибку:
Если передать три аргумента вместо двух, опять получим ошибку:
И если вообще не передать аргументов, это тоже вызовет ошибку:
Порядок позиционных аргументов тоже важен
В том, что касается позиционных аргументов, значение имеет не только количество, но и порядок следования.
Аргументы должны передаваться в том же порядке, в котором были объявлены параметры при определении функции.
Это работает так же, как присваивание значений переменным.
Первый аргумент в вызове функции используется в качестве значения для первого параметра, второй аргумент – для второго параметра и так далее.
Если порядок будет нарушен, мы можем получить не тот результат, который хотели.
Использование именованных аргументов в функциях в Python
Пока что мы имели дело только с позиционными аргументами. При вызове функций в них передавались только значения. Все эти значения идут по порядку и соответствуют параметрам, указанным при определении функции.
Но в Python есть еще и именованные аргументы.
В этом случае при вызове функции не просто передаются значения. Вы указываете имя параметра, за затем значение, которое хотите ему присвоить (в формате ключ = значение ).
Все ключи совпадают с параметрами, указанными при определении функции.
Явное указание имен параметров и их значений помогает внести дополнительную ясность и избежать возможных недоразумений.
Именованные аргументы, как видим, могут идти в том же порядке, что указан при определении функции. Но в этом плане они гибче позиционных: их порядок не имеет большого значения.
То есть, вы могли бы написать код следующим образом, и это не вызвало бы ошибок:
Но количество передаваемых аргументов имеет значение.
При вызове функции можно использовать одновременно и позиционные, и именованные аргументы. В следующем примере есть один позиционный и один именованный аргумент:
В этом случае порядок опять-таки имеет значение.
Позиционные аргументы всегда идут первыми. Все именованные аргументы должны следовать за позиционными. В противном случае будет ошибка:
Как определять параметр со значением по умолчанию
Аргументы функции также могут иметь значения по умолчанию.
Чтобы аргумент функции имел дефолтное значение, нужно назначить это самое значение параметру при определении функции.
Ранее мы видели, что можем определять функции со значением по умолчанию. Аргументы со значением по умолчанию называются аргументами по умолчанию.
Мы можем вызвать такую функцию, не передавая ей никаких аргументов. Тогда она будет использовать значение по умолчанию, которое мы присвоили при определении функции.
Значения по умолчанию при желании можно легко перезаписать, указав другое значение при вызове функции:
В функции может быть и несколько значений по умолчанию.
При вызове функции мы можем передать какой-нибудь один аргумент, несколько или даже ни одного. Порядок передачи аргументов не имеет значения.
Аргументы со значениями по умолчанию можно комбинировать с оыбчными.
Давайте рассмотрим другой пример. На этот раз наша функция принимает два аргумента: один позиционный, без значения по умолчанию ( name ), и один необязательный, со значением по умолчанию ( language ).
Важно помнить, что в этом случае порядок опять же имеет значение. Сначала идут позиционные аргументы, а за ними — аргументы с дефолтными значениями.
Вот такой код не сработал бы:
Заключение
В этой статье мы рассмотрели, как объявлять функции в Python и как вызывать их с параметрами.
Мы также разобрали тему позиционных и именованных аргументов и использование значений аргументов по умолчанию.
Спасибо за прочтение и успехов в написании кода!
Функции¶
Параметры функций¶
Функции могут принимать параметры, т.е. некоторые значения, передаваемые функции для того, чтобы она что-либо сделала с ними.
Параметры указываются в скобках при объявлении функции и разделяются запятыми. Аналогично мы передаём значения, когда вызываем функцию. Обратите внимание на терминологию: имена, указанные в объявлении функции, называются параметрами, тогда как значения, которые вы передаёте в функцию при её вызове, – аргументами.
Локальные переменные¶
При объявлении переменных внутри определения функции, они никоим образом не связаны с другими переменными с таким же именем за пределами функции – т.е. имена переменных являются локальными в функции. Это называется областью видимости переменной. Область видимости всех переменных ограничена блоком, в котором они объявлены, начиная с точки объявления имени.
Значения аргументов по умолчанию¶
Часть параметров функций могут быть необязательными, и для них будут использоваться некоторые заданные значения по умолчанию, если пользователь не укажет собственных. Этого можно достичь с помощью значений аргументов по умолчанию. Их можно указать, добавив к имени параметра в определении функции оператор присваивания (=) с последующим значением.
Обратите внимание, что значение по умолчанию должно быть неизменным.
Ключевые аргументы¶
Если имеется некоторая функция с большим числом параметров, и при её вызове требуется указать только некоторые из них, значения этих параметров могут задаваться по их имени – это называется ключевые параметры. В этом случае для передачи аргументов функции используется имя (ключ) вместо позиции (как было до сих пор).
Переменное число параметров¶
Иногда бывает нужно определить функцию, способную принимать любое число параметров:
Оператор return ¶
Оператор return используется для возврата из функции, т.е. для прекращения её работы и выхода из неё. При этом можно также вернуть некоторое значение из функции:
Из функции можно вернуть только одно значение. Если все-таки необходимо вернуть несколько значений, то для этого можно использовать кортеж:
Задачи¶
В задачах этого раздела вам даны заготовки для самопроверки. Этот код нужно скопировать и разместить после определения своей функции. Так, если вам дан код:
то ваш файл с исходным кодом должен выглядеть так:
Расскажите о назначении каждого параметра.
Функции в Python
Python включает в себя множество встроенных функций. Такие функции выполняют заранее определенную задачу и могут быть вызваны по необходимости в любой программе. Однако если вы не нашли встроенной функции, которая способна решить вашу проблему, вы всегда можете сами написать подходящую. Сейчас мы рассмотрим, как определять и использовать функции в программе на Python.
Определение функции
Функция — это многократно используемый блок программных инструкции, предназначенный для выполнения определенной задачи. Для определения функции в Python используется ключевое слово def. Ниже приведен синтаксис определения функции.
За ключевым словом def следует подходящий идентификатор (имя функции) и круглые скобки. В круглых скобках может быть дополнительно указан один или несколько параметров. Символ ‘:’ после круглых скобок начинает блок с отступом (тело функции).
Первой инструкцией в теле функции может быть строка, которая называется docstring. Она описывает функциональность функции/класса. Строка docstring не является обязательной.
В общем случае тело функции содержит одну или несколько инструкций, которые выполняют некоторые действия. В нем также может использоваться ключевое слово pass.
Последней командой в блоке функции зачастую является инструкция return. Она возвращает управление обратно вызвавшему функцию окружению. Если после оператора return стоит выражение, то его значение также передается в вызывающий код.
В следующем примере определена функция welcome().