Формальные и фактические параметры
Формальные параметры — это идентификаторы входных данных для подпрограммы. Если формальные параметры получают конкретные значения, то они называются фактическими. Формальные параметры могут получить конкретные значения только в той программе, где производится обращение к данному модулю-подпрограмме. Тип и порядок записи фактических параметров должны быть такими же, как и формальных параметров. В противном случае результат работы программы будет непредсказуемым. Из этого следует, что фактические параметры используются при обращении к подпрограмме из основной, а формальные параметры — только в самом модуле.
Подпрограмма с параметрами используется для записи многократно повторяющихся действий при разных исходных данных.
При составлении подпрограмм с параметрами надо соблюдать следующие правила:
1) каждая подпрограмма имеет свое имя и список формальных параметров;
2) процедура из основной программы вызывается командой вызова, которая по форме ничем не отличается от вызова команды исполнителя. Результат присваивается одной или нескольким переменным, которые находятся в списке формальных параметров. Но результатом могут быть, конечно, не только значения переменных, но какое либо действие, выполненное ЭВМ.
Подпрограммы с параметрами можно разделить на два типа: подпрограммы-функции и просто подпрограммы с параметрами (их называют процедурами).
Корректность передачи параметров основывается на соответствии их количества и порядка перечисления в заголовке процедуры/функции и в операторе вызова, а также на совместимости по присваиванию между соответствующими фактическими и формальными параметрами. Область видимости имен параметров такая же, как и локальных данных.
Многие процедуры имеют несколько.параметров. Задача программиста – убедиться, что параметры, которые он указывает при вызове (фактические параметры), соответствуют по смыслу формальным параметрам. Компилятор может проверить только очевидные случаи – неправильное число параметров или несовместимость типов.
Как называются значения которые указывают при вызове функции
Функция может принимать параметры. Через параметры в функцию можно передавать данные. Банальный пример — функция print() , которая с помощью параметра принимает значение, выводимое на консоль.
Теперь определим и используем свою функцию с параметрами:
def say_hello(name): print(f"Hello, ") say_hello("Tom") say_hello("Bob") say_hello("Alice")
Функция say_hello имеет параметр name, и при вызове функции мы можем передать этому параметру какой-либо значение. Внутри функции мы можем использовать параметр как обычную переменную, например, вывести значение этого параметра на консоль функцией print. Так, в выражении:
say_hello("Tom")
Строка «Tom» будет передаваться параметру name. В итоге при выполнении программы мы получим следующий консольный вывод:
Hello, Tom Hello, Bob Hello, Alice
При вызове функции значения передаются параметрам по позиции. Например, определим и вызовем функцию с несколькими параметрами:
def print_person(name, age): print(f"Name: ") print(f"Age: ") print_person("Tom", 37)
Здесь функция print_person принимает два параметра: name и age. При вызове функции:
print_person("Tom", 37)
Первое значение — «Tom» передается первому параметру, то есть параметру name . Второе значение — 37 передается второму параметру — age. И внутри функции значения параметров выводятся на консоль:
Name: Tom Age: 37
Значения по умолчанию
Некоторые параметры функции мы можем сделать необязательными, указав для них значения по умолчанию при определении функции. Например:
def say_hello(name="Tom"): print(f"Hello, ") say_hello() # здесь параметр name будет иметь значение "Tom" say_hello("Bob") # здесь name = "Bob"
Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть строка «Tom». Консольный вывод данной программы:
Hello, Tom Hello, Bob
Если функция имеет несколько параметров, то необязательные параметры должны идти после обязательных. Например:
def print_person(name, age = 18): print(f"Name: Age: ") print_person("Bob") print_person("Tom", 37)
Здесь параметр age является необязательным и по умолчанию имеет значение 18. Перед ним расположен обязательный параметр name. Поэтому при вызове функции мы можем не передавать значение параметру age, но параметру name передать значение необходимо.
При необходимости мы можем сделать все параметры необязательными:
def print_person(name = "Tom", age = 18): print(f"Name: Age: ") print_person() # Name: Tom Age: 18 print_person("Bob") # Name: Bob Age: 18 print_person("Sam", 37) # Name: Sam Age: 37
Передача значений параметрам по имени. Именованные параметры
В примерах выше при вызове функции значения передаются параметрами функции по позиции. Но также можно передавать значения параметрам по имени. Для этого при вызове функции указывается имя параметра и ему присваивается значение:
def print_person(name, age): print(f"Name: Age: ") print_person(age = 22, name = "Tom")
В данном случае значения параметрам age и name передаются по имени. И несмотря на то, что параметр name идет первым в определении функции, мы можем при вызове функции написать print_person(age = 22, name = «Tom») и таким образом передать число 22 параметру age, а строку «Tom» параметру name.
Символ * позволяет установить, какие параметры будут именнованными — то есть такие параметры, которым можно передать значения только по имени. Все параметры, которые располагаются справа от символа * , получают значения только по имени :
def print_person(name, *, age, company): print(f"Name: Age: Company: ") print_person("Bob", age = 41, company ="Microsoft") # Name: Bob Age: 41 company: Microsoft
В данном случае параметры age и company являются именнованными.
Можно сделать все параметры именнованными, поставив перед списком параметров символ *:
def print_person(*, name, age, company): print(f"Name: Age: Company: ")
Если наоборот надо определить параметры, которым можно передавать значения только по позиции, то есть позиционные параметры, то можно использовать символ / : все параметры, которые идут до символа / , являются позиционными и могут получать значения только по позиции
def print_person(name, /, age, company="Microsoft"): print(f"Name: Age: Company: ") print_person("Tom", company="JetBrains", age = 24) # Name: Tom Age: 24 company: JetBrains print_person("Bob", 41) # Name: Bob Age: 41 company: Microsoft
В данном случае параметр name является позиционным.
Для одной функции можно определять одновременно позиционные и именнованные параметры.
def print_person(name, /, age = 18, *, company): print(f"Name: Age: Company: ") print_person("Sam", company ="Google") # Name: Sam Age: 18 company: Google print_person("Tom", 37, company ="JetBrains") # Name: Tom Age: 37 company: JetBrains print_person("Bob", company ="Microsoft", age = 42) # Name: Bob Age: 42 company: Microsoft
В данном случае параметр name располагается слева от символа /, поэтому является позиционным и обязательным — ему можно передать значение только по позиции.
Параметр company является именнованным, так как располагается справа от символа *. Параметр age может получать значение по имени и по позиции.
Неопределенное количество параметров
С помощью символа звездочки можно определить параметр, через который можно передавать неопределенное количество значений. Это может быть полезно, когда мы хотим, чтобы функция получала несколько значений, но мы точно не знаем, сколько именно. Например, определим функцию подсчета суммы чисел:
def sum(*numbers): result = 0 for n in numbers: result += n print(f"sum = ") sum(1, 2, 3, 4, 5) # sum = 15 sum(3, 4, 5, 6) # sum = 18
В данном случае функция sum принимает один параметр — *numbers , но звездочка перед названием параметра указывает, что фактически на место этого параметра мы можем передать неопределенное количество значений или набор значений. В самой функции с помощью цикла for можно пройтись по этому набору, получить каждое значение из этого набора в переменную n и произвести с ним какие-нибудь действия. Например, в данном случае вычисляется сумма переданных чисел.
Параметры (аргументы) функции
Функции могут не только возвращать данные, но также принимают их, что реализуется с помощью так называемых параметров, которые указываются в скобках в заголовке функции. Количество параметров может быть любым, также существует несколько вариантов передачи аргументов в функцию
Параметры функции представляют собой локальные переменные, которым присваиваются значения в момент ее вызова. Иногда у параметрам задают значения (аргументы), используемые по умолчанию. Конкретные значения, которые передаются в функцию при ее вызове, называются аргументами.
Каждый раз, когда вызывается функция, создается новая область видимости для хранения локальных переменных этой функции и каждое имя передаваемого параметра связывается со значениями в новом локальном пространстве имен. Когда функция возвращает значение или завершает выполнение иным способом, это пространство имен уничтожается.
Параметры (аргументы) функции передаются в локальную область видимости с использованием вызова по значению, где значение всегда является ссылкой на объект, а не значением объекта.
def func (a, b): a = a * b b = a / 2 return a + b n1 = 10 n2 = 5 rez = func(n1, n2) print(rez) print(n1, n2) # напечатает 75,0 10 5
Изменение значений a и b в теле функции никак не скажется на значениях переменных n1 и n2 , определенных в глобальном пространстве. Они останутся прежними. Говорят, что в функцию данные передаются по значению. Когда a присваивалось число 10, то это было уже другое число, не то, на которое ссылается переменная n1 . Число 10 было скопировано и помещено в отдельную ячейку памяти для переменной a .
Необходимость передачи по ссылке связана в первую очередь с экономией памяти. Сложные типы данных, по сути представляющие собой структуры данных, обычно копировать не целесообразно. Однако, если надо, всегда можно сделать это принудительно.
Какие бывают аргументы/параметры в функциях Python.
Аргумент — это значение, передаваемое функции (или методу) при вызове функции.
Есть два типа аргументов:
-
ключевой аргумент: аргумент, которому предшествует идентификатор (например, name= ) в вызове функции или переданный как значение в словаре, которому предшествует две звездочки ** — обозначение распаковки словаря. Например, 3 и 5 являются аргументами ключевого слова в следующих вызовах встроенной функции complex() :
# передача значений ключевым # аргументам функции complex(real=3, imag=5) dict_args ='real': 3, 'imag': 5> # передача словаря со значениями # ключевых аргументов complex(**dict_args)
# передача значений позиционным # аргументам функции complex(3, 5) tuple_args = (3, 5) # передача кортежа со значениями # позиционных аргументов complex(*tuple_args)
Аргументы назначаются именованным локальным переменным в теле функции. Смотрите правила, регулирующие это назначение в разделе «Что происходит при вызове функции?».
Синтаксически, для представления аргумента может использоваться любое выражение, а оцененное значение присваивается локальной переменной.
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Функции это объекты
- Функции могут иметь атрибуты
- Функции могут храниться в структурах данных
- Функции могут быть вложенными
- Передача функции в качестве аргумента другой функции
- Область видимости переменных функции
- Операторы global и nonlocal
- Параметры (аргументы) функции
- Ключевые аргументы в определении функции Python
- Значение аргумента по умолчанию в функциях Python
- Варианты передачи аргументов в функцию Python
- Переменные аргументов *args и **kwargs в функции Python
- Распаковка аргументов для передачи в функцию Python
- Как оцениваются аргументы при вызове функции?
- Строгие правила передачи аргументов в функцию Python
- Инструкция return
- Анонимные функции (lambda-выражения)
- Строки документации в функциях Python
- Рекурсия
- Замыкания в функциях Python
- Перегрузка функций
Как называются значения которые указывают при вызове функции
Создание пользовательских функций.
Функция может быть объявлена в любой части программы ( в пределах операторов ) , но до места ее использования. Для объявления функций используется синтаксис:
function Имя ( аргумент1 [ =значение1 ] , . . . ,аргумент N [ =значение N])
Объявление функции начинается служебным словом function, затем следует имя функции, после имени — список аргументов в скобках. Тело функции заключается в фигурные скобки и может содержать произвольное количество операторов.
Требования к именам функций:
- имя функции может содержать русские буквы, но не рекомендуется.
- имя функции не должно содержать пробелов и пробельных символов.
- имя должно быть уникальным с точностью до регистра, то есть функции F1() и f1() — это разные функции.
- функциям можно давать такие же имена, как и переменным, только без знака доллара ( $ ) в начале имени.
Т.к. тип возвращаемого значения может быть любым, его (тип) не указывают вовсе. Для передачи результата работы функции в основную программу используется инструкция return. Если функция ничего не возвращает, инструкцию return не указывают. Инструкция return может возвращать все, что угодно, в том числе и массивы.
Пример функции возвращающей массив из 10 случайных чисел:
foreach ($A as $K=>$v) echo «$v»;
Описание работы функции: функция создает пустой локальный массив $LocalArr , затем настраивает регенератор случайных чисел на новую последовательность (mt_srand), чтобы при каждом новом запуске программы получалась новая строка. Затем заполняется массив случайными числами и передается в основную программу, где присваивается массиву $A. Цикл foreach выводит значения массива.
При объявлении функции нужно указать список параметров, которые могут передаваться функции, например:
function func ($a, $b, $c) < . . . >;
При вызове функции func() нужно обязательно указать все три параметра, поскольку они обязательны.
В PHP есть два вида аргументов функций:
- параметры — значения;
- параметры — переменные.
Функция не может изменить параметр — значение, то есть он доступен «только для чтения» — она может его использовать, но не более. В качестве параметра — значения необязательно указывать переменную, можно указать само значение, отсюда название — параметр — значение, например:
echo » Параметр = $a\n»;
Данная функция выведет строку «Параметр — 3» дважды.
В отличии от параметров — значений, параметр -переменные могут быть изменены в процессе работы функции. Здесь уже нельзя передавать значение, нужно обязательно передать переменную. В PHP для объявления параметров — переменных используется механизм передачи переменной по ссылке. Пример передачи переменной по ссылке:
$First = $Second = 5;
function f1 ($f, &$s)
echo » Изменяем параметры \n»;
echo «First = $f, Second = $s\n»;
echo » Значение переменных до вызова функции \n»;
echo «First = $First Second = $Second\n»;
f1 ($First, $Second);
echo «First = $First Second = $Second\n»;
В PHP функция может возвращать любое значение в зависимости от переданных ей параметров. параметры по умолчанию описываются так:
Например: function my_func ($x = 10, $y = 5)
Если параметр не задан при вызове функции, интерпретатор передаст функции значение параметра по умолчанию.
Контроль за количеством переданных параметров по умолчанию осуществляется функциями — func_num_args() и func_get_arg().
Первая возвращает число переданных функций аргументов, а вторая — аргумент с указанным номером. Кроме данных двух функций можно использовать еще одну — func_get_args() , которая возвращает список всех аргументов. Например:
foreach (func_get_args() as $a=>$v)
echo «
«;
Пример функции print_str , которая выводит переданные ей строки в виде таблицы HTML:
echo «
«;
echo «
«;
print_str (» Первый «, » Второй «, » Третий «, » Четвертый «);
Локальные переменные доступны только в функции, а глобальные во всей программе. Они доступны всем функциям.
Пример использования глобальных и локальных переменных:
Переменные $i и $g — глобальные, они доступны во всей программе. Для передачи глобальных переменных в функцию используется инструкция global:
global список переменных
Если не выполнить эту инструкцию, функция не получит доступ к переменной $g . В данном примере использованы две переменные $i: одна — глобальная, другая — локальная ( в теле функции).
В функции используется локальная переменная, однако, если объявить переменную глобальной:
то будет использоваться значение глобальной переменной.
Кроме глобальных и локальных переменных, существуют переменные — статические. Если в теле функции объявлена статическая переменная, то компилятор не будет ее удалять после завершения работы функции. Например:
Этот сценарий выведет строку 1 2 3 4 5 . Если удалить инструкцию static, то будет выведена строка 1 1 1 1 1, потому что переменная $x будет удаляться при завершении работы функции и обнуляться при каждом вызове. Т.к. переменная $x инкрементируется сразу после обнуления, а потом выводится, поэтому в результате 1 1 1 1 1, а не 0 0 0 0 0. Статические переменные не являются элементами $GLOBALS.
Рекурсией называется вызов функции самой на себя. Такой вызов называется рекурсивным. Рекурсия бывает прямая и обратная.
Пример прямой рекурсии:
function fact ($x)
else return $x*fact ($x-1);
Функция fact() вычисляет факториал x! . Функция fact() в своем теле вызывает саму себя — это и есть прямая рекурсия. Непрямая рекурсия возникает, когда первая функция вызывает вторую, а вторая — первую.