Где в функции задано значение по умолчанию python

Где в функции задано значение по умолчанию python

Функция может принимать параметры. Через параметры в функцию можно передавать данные. Банальный пример — функция 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 ask_ok(prompt, retries=4, reminder='Попробуйте еще раз!'): while True: ok = input(prompt) if ok in ('ok', 'y', 'yes'): return True if ok in ('n', 'no'): return False retries = retries - 1 if retries  0: raise ValueError('Неверный ответ пользователя') print(reminder) 

Эта функция может быть вызвана несколькими способами:

• давая только обязательный аргумент: ask_ok(‘Хочешь продолжить?’)
• давая один из необязательных аргументов: ask_ok(‘OK, чтобы перезаписать файл?’, 2)
• или даже приводя все аргументы: ask_ok(‘OK, чтобы перезаписать файл?’, 2, ‘Вводите только «ok» или «no»!’)

В этом примере также вводится in ключевое слово. Этот оператор проверяет, содержит ли последовательность определенное значение.

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

Значения по умолчанию вычисляются в точке выполняется инструкции def , а не в точке ее вызова, так что

i = 5 def f(arg=i): print(arg) i = 6 f() # напечатает 5. 

Важное предупреждение: Значения параметров по умолчанию создаются при определении функции, а НЕ каждый раз, когда она вызывается в коде программы. Это означает, что эти выражение вычисляется один раз, и что для каждого вызова используется одно и то же предварительно вычисленное значение. Если функция изменяет объект (например, путем добавления элемента в список, словарь), значение по умолчанию фактически изменяется. Например, следующая функция накапливает аргументы, переданные ей при последующих вызовах:

def f(a, L=[]): L.append(a) return L print(f(1)) print(f(2)) print(f(3)) # Это напечатает [1] [1, 2] [1, 2, 3] 

Это вообще не то, что было задумано. Способ обойти это — использовать None по умолчанию и явно проверить его в теле функции, например вы можете написать такую ​​функцию:

def f(a, L=None): if L is None: L = [] L.append(a) return L 

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

• КРАТКИЙ ОБЗОР МАТЕРИАЛА.
• Функции это объекты
• Функции могут иметь атрибуты
• Функции могут храниться в структурах данных
• Функции могут быть вложенными
• Передача функции в качестве аргумента другой функции
• Область видимости переменных функции
• Операторы global и nonlocal
• Параметры (аргументы) функции
• Ключевые аргументы в определении функции Python
• Значение аргумента по умолчанию в функциях Python
• Варианты передачи аргументов в функцию Python
• Переменные аргументов *args и **kwargs в функции Python
• Распаковка аргументов для передачи в функцию Python
• Как оцениваются аргументы при вызове функции?
• Строгие правила передачи аргументов в функцию Python
• Инструкция return
• Анонимные функции (lambda-выражения)
• Строки документации в функциях Python
• Рекурсия
• Замыкания в функциях Python
• Перегрузка функций

Python: Аргументы по умолчанию

Рассмотрим функцию round() , которая округляет переданное ей число:

result = round(10.25, 0) # 10.0 

Мы передали в нее два параметра:

• Число, которое нужно округлить
• Точность округления

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

result = round(10.25) # 10.0 

А если нужна другая точность, то можно передать параметр:

# округление до одного знака после запятой result = round(10.25, 1) # 10.2 

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

Задание

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

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.

В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Определения

• Параметр по умолчанию — необязательный параметр функции

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

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

Параметры представляют собой локальные переменные, которым присваиваются значения в момент вызова функции. Конкретные значения, которые передаются в функцию при ее вызове, будем называть аргументами. Следует иметь в виду, что встречается иная терминология. Например, формальные параметры и фактические параметры. В 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. Введение в программирование