Что такое аргумент в программировании
Перейти к содержимому

Что такое аргумент в программировании

  • автор:

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

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

/* возвращает 1 в случае, если с является частью строки s; в противном случае возвращается 0*/

int is_in(char *s, char с)
while(*s)
if(*s==c) return 1;
else s++;
return 0;
>

Функция is_in() имеет два параметра: s и с. Функция возвращает 1, если символ с является частью строки s. В противном случае она возвращает ноль.

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

  • Передача по значению и передача по ссылке
  • Создание передачи по ссылке
  • Передача массивов в функции

Параметры и аргументы функции

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

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

Рассмотрим схему и поясняющий ее пример:

Когда функция вызывается, то ей передаются аргументы. В примере указаны глобальные переменные num1 и num2 . Однако на самом деле передаются не эти переменные, а их значения. В данном случае числа 100 и 12. Другими словами, мы могли бы писать mathem(100, 12) . Разницы не было бы.

Когда интерпретатор переходит к функции, чтобы начать ее исполнение, он присваивает переменным-параметрам переданные в функцию значения-аргументы. В примере переменной a будет присвоено 100, b будет присвоено 12.

Изменение значений a и b в теле функции никак не скажется на значениях переменных num1 и num2 . Они останутся прежними. В Python такое поведение характерно для неизменяемых типов данных, к которым относятся, например, числа и строки. Говорят, что в функцию данные передаются по значению. Можно сказать, когда a присваивалось число 100, то это было уже другое число, не то, на которое ссылается переменная num1 . Число 100 было скопировано и помещено в отдельную ячейку памяти для переменной a .

На самом деле переменная a в момент присваивания значения может указывать на то же число 100, что и переменная num1 . Однако, когда a в результате вычислений в теле функции получает новое значение, то связывается с другой ячейкой памяти, потому что числа относятся к неизменяемым типам данных, то есть нельзя переписать значение содержащей их ячейки. При этом переменная num1 остается связанной со старым значением.

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

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

Произвольное количество аргументов

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

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

def cylinder(h, r = 1): side = 2 * 3.14 * r * h circle = 3.14 * r**2 full = side + 2 * circle return full figure1 = cylinder(4, 3) figure2 = cylinder(5) print(figure1) print(figure2)
131.88 37.68

При втором вызове cylinder() мы указываем только один аргумент. Он будет присвоен переменной-параметру h . Переменная r будет равна 1.

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

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

… figure3 = cylinder(10, 2) figure4 = cylinder(r=2, h=10) print(figure3) print(figure4)

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

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

def few_or_many(*a): print(a) few_or_many(1) few_or_many('1', 1, 2, 'abc') few_or_many()
(1,) ('1', 1, 2, 'abc') ()

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

Практическая работа

Напишите программу, в которой определена функция int_test , имеющая один параметр. Функция проверяет, можно ли переданное ей значение преобразовать к целому числу. Если можно, возвращает логическое True . Если нельзя – False .

В основной ветке программы присвойте переменной s то, что пользователь вводит с клавиатуры. Вызовите функцию int_test() , передав ей значение s . Если функция возвращает истину, преобразуйте строку s в число n и выведите на экран значение n + 10 .

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

Различия между параметрами и аргументами (Visual Basic)

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

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

Параметры

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

При определении Function процедуры или Sub необходимо указать список параметров в круглых скобках сразу после имени процедуры. Для каждого параметра укажите имя, тип данных и механизм передачи (ByVal или ByRef). Можно также указать, что параметр является необязательным. Это означает, что вызывающему коду не нужно передавать для него значение.

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

Аргументы

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

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

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

См. также раздел

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

Совместная работа с нами на GitHub

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

Аргументы

Аргументы в вызове функции могут иметь следующую форму:

expression(expression-listopt) /* Вызов функции */

При вызове функции параметр expression-list содержит список выражений, разделенных запятыми. Значения этих выражений являются аргументами, которые передаются функции. Если функция не принимает аргументы, то список expression-list должен содержать ключевое слово void .

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

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

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

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

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

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

Пример

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

int main() < /* Function prototype */ void swap( int *num1, int *num2 ); int x, y; . . . swap( &x, &y ); /* Function call */ >/* Function definition */ void swap( int *num1, int *num2 )

В этом примере функция swap объявлена внутри функции main . Она имеет два аргумента, num1 и num2 , которые являются указателями на значения типа int . Параметры num1 и num2 в определении прототипа также объявляются как указатели на значения типа int .

Функция вызывается следующей инструкцией:

swap( &x, &y ) 

Адрес x , который здесь используется, сохраняется в аргументе num1 , а адрес y — в аргументе num2 . Теперь для одного и того же местоположения имеется два имени, или псевдонима. Ссылки на значения *num1 и *num2 в функции swap одновременно представляют собой ссылки на значения x и y в функции main . Присваивания внутри функции swap , по сути, меняют содержимое переменных x и y . Поэтому оператор return не требуется.

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

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *