Логические выражения и логический тип данных
Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.
Подобные фразы предполагают только два возможных ответа – либо «да», когда выражение оценивается как правда, истина, либо «нет», когда утверждение оценивается как ошибочное, ложное. В программировании и математике если результатом вычисления выражения может быть лишь истина или ложь, то такое выражение называется логическим.
Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.
На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool
). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).
>>> a = True >>> type(a) <class 'bool'> >>> b = False >>> type(b) <class 'bool'>
Здесь переменной a было присвоено значение True
, после чего с помощью встроенной в Python функции type()
проверен ее тип. Интерпретатор сообщил, что это переменная класса bool
. Понятия «класс» и «тип данных» в данном случае одно и то же. Переменная b также связана с булевым значением.
В программировании False
обычно приравнивают к нулю, а True
– к единице. Чтобы в этом убедиться, можно преобразовать булево значение к целочисленному типу:
>>> int(True) 1 >>> int(False) 0
Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:
>>> bool(3.4) True >>> bool(-150) True >>> bool(0) False >>> bool(' ') True >>> bool('') False
И здесь работает правило: всё, что не 0 и не пустота, является правдой.
Логические операторы
Говоря на естественном языке (например, русском) мы обозначаем сравнения словами «равно», «больше», «меньше». В языках программирования используются специальные знаки, подобные тем, которые используются в математике: >
(больше), <
(меньше), >=
(больше или равно), <=
(меньше или равно), ==
(равно), !=
(не равно).
Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком «равно», и операцию сравнения (два знака «равно»). Присваивание и сравнение – разные операции.
>>> a = 10 >>> b = 5 >>> a + b > 14 True >>> a < 14 - b False >>> a <= b + 5 True >>> a != b True >>> a == b False >>> c = a == b >>> a, b, c (10, 5, False)
В данном примере выражение c = a == b
состоит из двух подвыражений. Сначала происходит сравнение (==
) переменных a и b. После этого результат логической операции присваивается переменной c. Выражение a, b, c
просто выводит значения переменных на экран.
Сложные логические выражения
Логические выражения типа kByte >= 1023
являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20″.
В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).
Чтобы получить True
при использовании оператора and
, необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False
, то и все сложное выражение будет ложным.
Чтобы получить True
при использовании оператора or
, необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or
сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.
Допустим, переменной x было присвоено значение 8 (x = 8
), переменной y присвоили 13 (y = 13
). Логическое выражение y < 15 and x > 8
будет выполняться следующим образом. Сначала выполнится выражение y < 15
. Его результатом будет True
. Затем выполнится выражение x > 8
. Его результатом будет False
. Далее выражение сведется к True and False
, что вернет False
.
>>> x = 8 >>> y = 13 >>> y < 15 and x > 8 False
Если бы мы записали выражение так: x > 8 and y < 15
, то оно также вернуло бы False
. Однако сравнение y < 15
не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x > 8
) уже вернуло ложь, которая, в случае оператора and
, превращает все выражение в ложь.
В случае с оператором or
второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True
, неважно по какую сторону от or
оно стоит.
В языке Python есть еще унарный логический оператор not
, то есть отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and
и or
.
Здесь у < 15
возвращает True
. Отрицая это, мы получаем False
.
>>> a = 5 >>> b = 0 >>> not a False >>> not b True
Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False
. Отрицание False
дает True
.
Практическая работа
-
Присвойте двум переменным любые числовые значения.
-
Используя переменные из п. 1, с помощью оператора
and
составьте два сложных логических выражения, одно из которых дает истину, другое – ложь. -
Аналогично выполните п. 2, но уже с оператором
or
. -
Попробуйте использовать в логических выражениях переменные строкового типа. Объясните результат.
-
Напишите программу, которая запрашивала бы у пользователя два числа и выводила бы
True
илиFalse
в зависимости от того, больше первое число второго или нет.
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
В предыдущих разделах мы уже часто сталкивались с встроенными функция ( int, float, print, type, len ) Каждая функция в Python предназначена для выполнения одной конкретной задачи. Использование функции упрощает написание и чтение кода.
1. Функция в Python
Если какая то задача выполняется многократно в программе, то не обязательно эту задачу расписывать во всех разделах программы, достаточно поместить код в функцию и в последующем вызывать эту функцию по мере необходимости.
Напишем функцию, которая вычисляет квадрат своего аргумента и выводит на экран:
>>> def square(number):
… «»»Вычисление квадрата числа»»»
… print(number ** 2)
…
>>> square(5)
25
>>> square(124.45)
15487.802500000002
Определение функции начинается с ключевого слова def, за которым следует имя функции — square. Имя функции, как и имена переменных рекомендуется писать с букв нижнего регистра, а в именах, состоящих из нескольких слов, составляющие должны разделяться символами подчеркивания. Далее в круглых скобках записываются параметры (аргументы) функции, разделенные запятыми. Функция square имеет только один аргумент с именем number — значение, возводимое в квадрат. В случае отсутствия параметров у функции пустые круглые скобки обязательны. В конце строки за параметрами всегда ставится двоеточие ( : ).
После двоеточия новая строка должна идти с отступом (4 пробела). Все строки с отступом образуют тело или блок функции. В «Руководстве по стилю кода Python» указано, что первой строкой блока функции должна быть doc-строка, кратко поясняющая назначение функции: «»»Вычисление квадрата числа»»». Сам код в теле функции состоит всего из одной строки print(number ** 2).
Команда squre(5) вызывает функции square() и передает ей значение аргумента, для выполнения команды print. Функция возводит число в квадрат и выводит на экран.
2. Передача аргументов функции в Python
2.1. Позиционные аргументы
Функция может иметь несколько параметров и при её вызове должно передаваться сразу несколько аргументов. Напишем функцию, которая выводит название автомобиля, модель и его пробег:
>>> def car(car_brend, car_model, mileage):
… «»»Выводит информацию о автомобиле»»»
… print(f»Продается {car_brend.title()} {car_model.upper()} с пробегом {mileage} км.»)
…
>>> car(‘bmw’, ‘x5’, 51345)
Продается Bmw X5 с пробегом 51345 км.
В данной функции видно, что должно передаваться три аргумента название автомобиля (car_brend), модель(car_model) и пробег (mileage). При вызове функции мы должны передать аргументы именно в том порядке, в каком они сохраняются в функции. Если нарушить порядок следования аргументов, то при вызове возможны неожиданные результаты или ошибки.
2.2. Именованные аргументы
Если порядок передачи аргументов по каким то причинам не известен, то можно использовать именованные аргументы. Именованный аргумент представляет собой пару «имя-значение«. Имя и значения связываются с аргументом напрямую, так что при передаче аргумента путаница исключается. Вызовем туже самую функцию car() с помощью именованных аргументов:
>>> def car(car_brend, car_model, mileage):
… «»»Выводит информацию о автомобиле»»»
… print(f»Продается {car_brend.title()} {car_model.upper()} с пробегом {mileage} км.»)
…
>>> car(mileage = 45152, car_model = ‘x5′, car_brend=’bmw’)
Продается Bmw X5 с пробегом 45152 км.
При обработке вызова функции Python знает к какому аргументу принадлежат данные и проблем с выводом не случается.
2.3. Значения по умолчанию
Для каждого параметра функции можно определить значение по умолчанию. Если при вызове функции не был передан аргумент, то используется значение по умолчанию. Все значение по умолчанию всегда должны следовать после параметров, у которых значений по умолчанию нет. Приведем пример той же функции, но тип автомобиля будем использовать по умолчанию
>>> def car(car_model, mileage, car_brend=’bmv’):
… «»»Выводит информацию о автомобиле»»»
… print(f»Продается {car_brend.title()} {car_model.upper()} с пробегом {mileage} км.»)
…
>>> car(‘x7’, 12345)
Продается Bmv X7 с пробегом 12345 км.
>>> car(‘m5’ , 56148)
Продается Bmv M5 с пробегом 56148 км.
Для изменения значения по умолчанию, мы можем передать именованный аргумент для изменения значения car_brend=’audi’:
>>> car(‘q7’, 35600, car_brend=’audi’)
Продается Audi Q7 с пробегом 35600 км.
Так как аргумент для параметра car_brend задан явно, Python игнорирует значение по умолчанию.
2.4. Передача произвольного набора аргументов
Иногда заранее не известно сколько аргументов должно быть передано функции, Python позволяет получить произвольное количество аргументов из вызывающей команды. Рассмотрим функцию, которая просто передает любое количество аргументов, к примеру название автомобилей:
>>> def cars(*args):
… «»»Вывод автомобилей»»»
… print(args)
…
>>> cars(‘audi’, ‘bmv’, ‘ford’, ‘kia’)
(‘audi’, ‘bmv’, ‘ford’, ‘kia’)
>>> cars(‘porshe’)
(‘porshe’)
Звездочка в имени параметра args приказывает создать Python пустой кортеж с именем args и упаковать в него все полученные результаты и с помощью команды print вывести на экран. В примере видно, что функция работает и при передаче четырех и при передаче одного аргумента.
Для более удобной работы с данными, например изменения регистра символов можно воспользоваться циклом for:
>>> def cars(*args):
… «»»Вывод автомобилей в продаже»»»
… print(‘Автомобили в продаже:’)
… for arg in args:
… print(f»-{arg.title()}»)
…
>>> cars(‘audi’, ‘bmv’, ‘ford’, ‘kia’)
Автомобили в продаже:
-Audi
-Bmv
-Ford
-Kia
2.5. Позиционные аргументы с произвольным набором аргументов
В случае, когда в функции есть позиционные аргументы и произвольные, параметр получения произвольного количества аргументов должен стоять на последнем месте. Python сначала подберет соответствия для позиционных и именных аргументов, а потом объединит все остальные аргументы в последний параметр colors:
>>> def car(car_brend, car_model, *colors):
… «»»Выводит информацию о автомобиле»»»
… print(f»Автомобиль {car_brend.title()} {car_model.upper()} можно заказать в цветах:»)
… for color in colors:
… print(f»-{color}»)
…
>>> car(‘bmw’, ‘x7’, ‘синий’, ‘зеленый’, ‘белый’, ‘черный’, ‘желтый’)
Автомобиль Bmw X7 можно заказать в цветах:
-синий
-зеленый
-белый
-черный
-желтый
В результате данная функция получает два позиционных аргумента car_brend и car_model, а остальные сохраняются в кортеже colors.
В большинстве программ часто используется имя обобщенного параметра *args для хранения произвольного набора позиционных аргументов.
2.6. Произвольный набор именованных аргументов
Иногда может потребоваться, чтобы функция получала произвольное количество именованных аргументов. В таком случае можно написать функцию, которая получает столько пар «ключ-значение», сколько указано в команде вызова. Например, для построение пользовательских профилей, заранее не известно, какую точно информацию предоставит пользователь. Поэтому определим в функции обязательное предоставление имени и фамилии, а остальная информация может быть получена с помощью произвольного количества именованных аргументов:
>>> def profile(first, last, **user_info):
… «»»Возвращает словарь с данными о пользователе»»»
… user_info[‘first_name’] = first
… user_info[‘last_name’] = last
… return user_info
…
>>> profile_1 = profile(‘tomas’, ‘edisson’, location=’usa’)
>>> print(profile_1)
{‘location’: ‘usa’, ‘first_name’: ‘tomas’, ‘last_name’: ‘edisson’}
Функция profile ожидает получить имя и фамилию пользователя, а также позволяет передать любое количество пар «имя — значение». Две звездочки в параметре **user_info заставляют Python создать пустой словарь с именем user_info и добавить в него все полученные пары «имя — значение». В теле функции сразу добавляются имя и фамилия, а остальные пары в зависимости от переданных параметров при вызове фукции. В конце словарь возвращается с помощью команды return.
В программах часто используется имя обобщенного параметра **kwargs для хранения произвольного набора ключевых аргументов.
3. Возвращаемое значение в функции на Python
Вместо вывода результата работы напрямую, функция может обработать данные и вернуть значение c помощью команды return. Значение, возвращаемое функцией, называется возвращаемым значением.
3.1. Возвращение простого значения
Напишем функцию, которая возвращает отформатированное имя и фамилию
>>> def form_name(last_name, first_name, middle_name):
… «»»Возвращает отформатированное полное имя»»»
… full_name = f»{last_name} {first_name} {middle_name}»
… return full_name.title()
…
>>> poet = form_name(‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)
Пушкин Александр Сергеевич
Функция form_name получает в параметрах имя, фамилию и отечество, далее объединяет эти имена и сохраняет их в переменной full_name. Завершив выполнение, функция возвращает управление в точку вызова с помощью команды return, то есть в строку кода, которая вызывала функцию.
Предположим, что мы не знаем отчество человека, для передачи его фукции параметру middle_name. В связи с этим удобно заранее сделать в функции необязательный аргумент. Присвоим ( middle_name = «» ) пустое значение.
>>> def form_name(last_name, first_name, middle_name=»):
… «»»Возвращает отформатированное полное имя»»»
… full_name = f»{last_name} {first_name} {middle_name}»
… return full_name.title()
…
>>> poet = form_name(‘пушкин’, ‘александр’)
>>> print(poet)
Пушкин Александр
>>> poet = form_name(‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)
Пушкин Александр Сергеевич
С необязательным аргументом мы не получим ошибку (TypeError: form_name() missing 1 required positional argument: ‘middle_name’) в случае отсутствия на входе данных по аргументу.
3.2. Возвращение словаря
Функция может возвращать и более сложную структуру данных, например словарь или список. Напишем функцию, которая будет возвращать словарь, представляющий человека:
>>> def info_person(first_name, last_name):
… «»»Возвращает словарь с данными о человеке»»»
… person = {‘first’: first_name, ‘last’: last_name}
… return person
…
>>> musician = info_person(‘Freddie’, ‘Mercury’)
>>> print(musician)
{‘first’: ‘Freddie’, ‘last’: ‘Mercury’}
При вызове функции info_person получает имя и фамилию на входе и помещает их сразу в словарь, с ключами имя и фамилия. Затем с помощью команды return возвращает словарь. В будущем со словарем будет удобнее работать, мы сможем отдельно использовать имя, фамилию или другие аргументы функции.
4. Использования функции в цикле while
Функции могут вызываться в циклах while где угодно. Приведем пример цикла while, где у посетителя запрашивают имя и фамилию, а с помощью функции form_name возвращается отформатированное имя и фамилия с приветствием:
def form_name(first_name, last_name):
«»»Возвращает отформатированное полное имя»»»
full_name = f»{first_name} {last_name}»
return full_name.title()
while True:
print(«nВведите ‘x’ если хотите завершить программу»)
first_name = input(«Введите ваше имя: «)
if first_name == ‘x’:
break
last_name = input(«Введите вашу фамилию: «)
if last_name == ‘x’:
break
formatted_name = form_name(first_name, last_name)
print(f»nДобрый день {formatted_name}!»)
В данном примере в цикле whle запрашивается имя и фамилия и с помощью функции form_name возвращается отформатированное полное имя и записывается в переменную formatted_name. А затем уже с помощью функции print данные выводятся на экран.
5. Передача списка функции на Python
При передаче аргумента функции мы можем сразу передать список. В результате функция получает доступ сразу ко всему его содержимому. Воспользуемся функцией square которую писали в первом разделе, которая выводит квадрат своего аргумента и немного обновим ее. Но в качестве аргумента мы передадим сразу список чисел, которые нужно обработать и возвести в квадрат.
>>> def square(numbers):
… «»»Вычисление квадрата числа»»»
… for number in numbers:
… print(number ** 2)
…
>>> numbers = [1, 5, 6, 15, -7, 1.5]
>>> square(numbers)
1
25
36
225
49
2.25
В результате функции square мы передаем список numbers. Для возведения всех чисел в квадрат, вначале нам нужно перебрать данный список с помощью цикла for, а затем каждое число возвести в квадрат.
6. Использование лямбда-выражений вместо функций
Для простых функций, например square, который просто вычисляют квадрат числа, можно использовать лямбда-выражения.
>>> square = lambda x: x ** 2
>>> print(square(5))
25
В начале создается переменная square и в дальнейшем по имени переменной будет вызываться лямбда-выражение. Лямбда-выражение является анонимной функцией, то есть функцией, не имеющей имени. Лямбда-выражение начинается с ключевого слова lambda, за которым следует разделенный запятыми список параметров. В нашем примере параметр один x. Затем ставится двоеточие и само выражение x ** 2. В результате при вызове переменной square мы передаем параметр число 5, и оно возводится в квадрат.
Лямбда-выражение может иметь и несколько параметров. Например, перемножать передаваемые числа.
>>> mult = lambda x, y, z: x * y * z
>>> print(mult(2, 4, 6))
48
Таким образом любая простая функция в форме
def имя_функции(список_параметров):
return выражение
может быть выражена в более компактной форме посредством лямбда-выражения
lambda список_параметров: выражение
Далее: Классы в Python
Назад: Цикл while в Python
Встроенные функции в Python позволяют осуществлять самые разные операции. Каждая из них решает какую-то особую задачу. Но кроме них есть еще функции, которые пишут сами программисты.
В этой статье мы рассмотрим, как создавать и вызывать функции в Python. Также мы коснемся темы передачи параметров и аргументов в функцию.
Что такое функция?
Функция – это изолированный блок кода, который решает отдельную задачу.
Смысл функций в том, что они позволяют избежать ненужного повторения кода. Если какое-то действие повторяется часто и в разных местах, это хороший показатель того, что код для этого действия можно выделить в отдельную функцию.
Функции также помогают организовать ваш код.
Если нужно внести какое-то изменение в код функции, обновить придется только ее. Без функций у вас были бы многократно повторяющиеся куски одинакового кода в разных местах, и обновлять этот код пришлось бы повсюду.
Если говорить о принципах программирования, использование функций — это следование принципу DRY (Don’t Repeat Yourself — «не повтоярйся»).
Код внутри функции запускается только тогда, когда функцию вызывают.
Функции могут принимать аргументы и значения по умолчанию. При вызове они могут возвращать какое-то значение в вызвавший их код, но могут и не возвращать ничего.
Определение функции в Python
Базовый синтаксис определения функции выглядит так:
def function_name(parameters): function body
Итак, давайте разберемся:
def
— ключевое слово. Оно сообщает Python, что начинается определение функции.- Затем идет имя функции. Оно может быть произвольным (ограничения те же, что и для обозначения переменных).
- Далее у нас есть пара круглых скобок
()
. Внутри них могут быть разделенные запятыми параметры. Для параметров могут указываться дефолтные значения. Количество параметров варьируется: может быть один или несколько, а может и вовсе не быть параметров. - Затем идет двоеточие
:
, которое завершает строку определения функции. - Дальше идет новая строка, начинающаяся с отступа (4 пробела или одно нажатие клавиши tab).
- В этой новой строке после отступа начинается тело функции: код действий, которые должна осуществлять функция при вызове.
- Наконец, в теле функции может быть опциональный оператор
return
, возвращающий значение вызывающей стороне при выходе из функции.
Имейте в виду, что если вы забудете круглые скобки ()
или двоеточие :
, Python сообщит вам об этом с помощью SyntaxError
.
Определение и вызов простой функции в Python
Ниже приведен пример базовой функции. В ней нет оператора return, и никаких параметров она тоже не принимает.
Эта функция просто выводит hello world при каждом вызове.
def hello_world_func(): print("hello world")
Когда функция определена, код в ней не запускается сам по себе. Для его выполнения необходимо сделать вызов функции.
Вызывать функцию можно столько раз, сколько вам нужно.
Для вызова функции используется следующий синтаксис:
function_name(arguments)
Сначала пишется имя функции. За ним пишутся круглые скобки. Если функция имеет обязательные аргументы, они должны быть перечислены в скобках. Если аргументов у функции нет, скобки все равно нужно написать, просто они останутся пустыми.
Для вызова функции из нашего примера пишем следующий код:
hello_world_func() # Результат: # hello world
Как определять и вызывать функции с параметрами в Python
Пока что мы рассмотрели самый базовый вариант функции. Она лишь выводит что-то в консоль.
Но что, если в функцию нужно передать какие-то дополнительные данные?
Здесь мы используем такие термины, как параметры и аргументы.
Параметры – это именованные заполнители. Они работают как переменные, определенные локально в строке объявления функции.
def hello_to_you(name): print("Hello " + name)
В нашем примере мы указали один параметр — name
.
Для форматирования строки мы могли бы использовать f-строки. Код, приведенный ниже, работает точно так же, как и приведенный выше:
def hello_to_you(name): print(f"Hello {name}")
Мы можем передать функции столько параметров, сколько душе угодно, разделив их запятыми:
def name_and_age(name,age): print(f"I am {name} and I am {age} years old!")
Здесь параметры функции — name
и age
.
При вызове функции в нее передаются аргументы.
Аргументы — это информация, переданная в функцию. Они представляют собой настоящие значения, соответствующие параметрам, которые были указаны при объявлении функции.
Марк Лутц «Изучаем Python»
Скачивайте книгу у нас в телеграм
Скачать
×
Вызов функции из предыдущего примера и передача аргументов будет выглядеть так:
def hello_to_you(name): print(f"Hello {name}") hello_to_you("Timmy") # Результат: # Hello Timmy
Функцию можно вызывать многократно, каждый раз передавая разные значения в качестве аргументов:
def hello_to_you(name): print(f"Hello {name}") hello_to_you("Timmy") hello_to_you("Kristy") hello_to_you("Jackie") hello_to_you("Liv") # Результат: # "Hello Timmy" # "Hello Kristy" # "Hello Jackie" # "Hello Liv"
Аргументы, которые мы рассматривали до сих пор, называются позиционными. Все позиционные аргументы являются обязательными.
Количество позиционных аргументов имеет значение
Когда мы вызываем наши функции, мы должны передавать правильное количество аргументов, иначе мы получим ошибку.
Число передаваемых аргументов при вызове функции должно быть равным числу параметров, указанных при объявлении этой функции. Нельзя ни убавить, ни прибавить.
Скажем, у нас есть функция с двумя параметрами:
def hello_to_you(first_name,last_name): print(f"Hello, {first_name} {last_name}")
Если мы попробуем вызвать эту функцию, передав всего один аргумент, мы получим ошибку:
def hello_to_you(first_name,last_name): print(f"Hello, {first_name} {last_name}") hello_to_you("Timmy") # Результат: Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: hello_to_you() missing 1 required positional argument: 'last_name'
Если передать три аргумента вместо двух, опять получим ошибку:
def hello_to_you(first_name,last_name): print(f"Hello, {first_name} {last_name}") hello_to_you("Timmy","Jones",34) # Результат: Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: hello_to_you() takes 2 positional arguments but 3 were given
И если вообще не передать аргументов, это тоже вызовет ошибку:
def hello_to_you(first_name,last_name): print(f"Hello, {first_name} {last_name}") hello_to_you() # Результат: Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: hello_to_you() missing 2 required positional arguments: 'first_name' and 'last_name'
Порядок позиционных аргументов тоже важен
В том, что касается позиционных аргументов, значение имеет не только количество, но и порядок следования.
Аргументы должны передаваться в том же порядке, в котором были объявлены параметры при определении функции.
Это работает так же, как присваивание значений переменным.
Первый аргумент в вызове функции используется в качестве значения для первого параметра, второй аргумент – для второго параметра и так далее.
def hello_to_you(first_name,last_name): print(f"Hello, {first_name} {last_name}") hello_to_you("Timmy","Jones") # Выводит в консоль "Hello, Timmy Jones" # Это можно визуализировать так: # first_name = "Timmy" # last_name = "Jones"
Если порядок будет нарушен, мы можем получить не тот результат, который хотели.
def fave_language(name,language): print(f"Hello, I am {name} and my favorite programming language is {language}") fave_language("Python","Dionysia") # Результат: # Hello, I am Python and my favorite programming language is Dionysia # Это как если бы вы сделали так: # name="Python" # language = "Dionysia"
Использование именованных аргументов в функциях в Python
Пока что мы имели дело только с позиционными аргументами. При вызове функций в них передавались только значения. Все эти значения идут по порядку и соответствуют параметрам, указанным при определении функции.
Но в Python есть еще и именованные аргументы.
В этом случае при вызове функции не просто передаются значения. Вы указываете имя параметра, за затем значение, которое хотите ему присвоить (в формате ключ = значение
).
Все ключи совпадают с параметрами, указанными при определении функции.
Явное указание имен параметров и их значений помогает внести дополнительную ясность и избежать возможных недоразумений.
def fave_language(name,language): print(f"Hello, I am {name} and my favorite programming language is {language}") fave_language(language="Python",name="Dionysia") #output: #Hello, I am Dionysia and my favorite programming language is Python
Именованные аргументы, как видим, могут идти в том же порядке, что указан при определении функции. Но в этом плане они гибче позиционных: их порядок не имеет большого значения.
То есть, вы могли бы написать код следующим образом, и это не вызвало бы ошибок:
def fave_language(name,language): print(f"Hello, I am {name} and my favorite programming language is {language}") fave_language(language="Python",name="Dionysia") #output: #Hello, I am Dionysia and my favorite programming language is Python
Но количество передаваемых аргументов имеет значение.
При вызове функции можно использовать одновременно и позиционные, и именованные аргументы. В следующем примере есть один позиционный и один именованный аргумент:
def fave_language(name,language): print(f"Hello, I am {name} and my favorite programming language is {language}") fave_language("dionysia",language="Python") #output: #Hello, I am dionysia and my favorite programming language is Python
В этом случае порядок опять-таки имеет значение.
Позиционные аргументы всегда идут первыми. Все именованные аргументы должны следовать за позиционными. В противном случае будет ошибка:
def fave_language(name,language): print(f"Hello, I am {name} and my favorite programming language is {language}") fave_language(language="Python","dionysia")
Как определять параметр со значением по умолчанию
Аргументы функции также могут иметь значения по умолчанию.
Чтобы аргумент функции имел дефолтное значение, нужно назначить это самое значение параметру при определении функции.
Делается это в формате ключ=значение
.
Ранее мы видели, что можем определять функции со значением по умолчанию. Аргументы со значением по умолчанию называются аргументами по умолчанию.
def fave_language(language="Python"): print(f"My favorite programming language is {language}!") fave_language() # Выводит в консоль "My favorite programming language is Python!"
Мы можем вызвать такую функцию, не передавая ей никаких аргументов. Тогда она будет использовать значение по умолчанию, которое мы присвоили при определении функции.
В нашем примере, если не передан аргумент, значением language
всегда будет Python
.
Значения по умолчанию при желании можно легко перезаписать, указав другое значение при вызове функции:
def fave_language(language="python"): print(f"My favorite programming language is {language}!") fave_language("Java") # Выводит в консоль "My favorite programming language is Java!"
В функции может быть и несколько значений по умолчанию.
При вызове функции мы можем передать какой-нибудь один аргумент, несколько или даже ни одного. Порядок передачи аргументов не имеет значения.
def personal_details(name="Jimmy",age=28,city="Berlin"): print(f"I am {name},{age} years old and live in {city}") # Мы можем вызывать эту функцию так: personal_details() # Результат: # I am Jimmy,28 years old and live in Berlin personal_details(age=30) # I am Jimmy,30 years old and live in Berlin personal_details(city="Athens",name="Ben",age=24) # I am Ben,24 years old and live in Athens
Аргументы со значениями по умолчанию можно комбинировать с оыбчными.
Давайте рассмотрим другой пример. На этот раз наша функция принимает два аргумента: один позиционный, без значения по умолчанию (name
), и один необязательный, со значением по умолчанию (language
).
def fave_language(name,language="Python"): print(f"My name is {name} and my favorite programming language is {language}!") fave_language("Dionysia") # Результат: #"My name is Dionysia and my favorite programming language is Python!"
Мы видим, что аргумент со значением по умолчанию language = "Python"
является опциональным. Тогда как позиционный аргумент name
всегда будет обязательным. Таким образом, если другой язык не передан, по умолчанию всегда будет Python
.
Важно помнить, что в этом случае порядок опять же имеет значение. Сначала идут позиционные аргументы, а за ними — аргументы с дефолтными значениями.
Вот такой код не сработал бы:
def fave_language(language="Python",name): print(f"My name is {name} and my favorite programming language is {language}!") fave_language("Dionysia") # Результат: File "<stdin>", line 1 SyntaxError: non-default argument follows default argument
От редакции Pythonist. Иногда нельзя предсказать, сколько аргументов получит функция. Чтобы обработать их, используются специальные конструкции *args
и **kwargs
. Почитать подробнее можно в статье «Что такое *args и **kwargs?».
Заключение
В этой статье мы рассмотрели, как объявлять функции в Python и как вызывать их с параметрами.
Мы также разобрали тему позиционных и именованных аргументов и использование значений аргументов по умолчанию.
Спасибо за прочтение и успехов в написании кода!
Перевод статьи «Python Function Examples – How to Declare and Invoke with Parameters».
Ключевые слова Python — это специальные зарезервированные слова, которые передают компилятору/интерпретатору особый смысл. Каждое ключевое слово имеет особое значение и специфическую операцию. Эти ключевые слова нельзя использовать в качестве переменной. Ниже приведен список ключевых слов Python.
True | False | None | and | as |
asset | def | class | continue | break |
else | finally | elif | del | except |
global | for | if | from | import |
raise | try | or | return | pass |
nonlocal | in | not | is | lambda |
Рассмотрим поподробнее улючевые слова, указанные выше.
- True — Представляет собой булеву истину, если заданное условие истинно, то возвращается
True
. Ненулевые значения рассматриваются как true. - False — Представляет булево значение false; если заданное условие ложно, то возвращается
False
. Нулевое значение рассматривается как false - None — обозначает нулевое значение или пустоту. Пустой список или ноль не могут рассматриваться как None.
- and — Это логический оператор. Он используется для проверки нескольких условий. Он возвращает
true
, если оба условия истинны. Рассмотрим следующую таблицу истинности.
A | B | A and B |
---|---|---|
True | True | True |
True | True | False |
False | True | False |
False | False | False |
5. or — Это логический оператор в Python. Он возвращает истину, если одно из условий истинно. Рассмотрим следующую таблицу истинности.
A | B | A or B |
---|---|---|
True | True | True |
True | True | True |
False | True | True |
False | False | False |
6. not — Является логическим оператором и инвертирует значение. Рассмотрим следующую таблицу истинности.
A | not A |
---|---|
True | False |
False | True |
7. assert — Это ключевое слово используется как инструмент отладки в Python. Оно проверяет правильность кода. Оно вызывает AssertionError
, если в коде найдена ошибка, а также печатает сообщение об ошибке.
Пример:
a = 10
b = 0
print('a is dividing by Zero')
assert b != 0
print(a / b)
Вывод:
a is dividing by Zero
Runtime Exception:
Traceback (most recent call last):
File "/home/40545678b342ce3b70beb1224bed345f.py", line 4, in
assert b != 0, "Divide by 0 error"
AssertionError: Divide by 0 error
8. def — Это ключевое слово используется для объявления функции в Python. Если за ним следует имя функции.
def my_func(a,b):
c = a+b
print(c)
my_func(10,20)
Вывод:
30
9. class — Используется для представления класса в Python. Класс — это чертеж объектов. Он представляет собой коллекцию переменных и методов. Рассмотрим следующий класс.
class Myclass:
#Variables……..
def function_name(self):
#statements………
10. continue — Используется для остановки выполнения текущей итерации. Рассмотрим следующий пример.
a = 0
while a < 4:
a += 1
if a == 2:
continue
print(a)
Вывод:
1
3
4
11. break — Используется для завершения выполнения цикла и передачи управления в конец цикла. Рассмотрим следующий пример.
for i in range(5):
if(i==3):
break
print(i)
print("End of execution")
Вывод:
0
1
2
End of execution
12. If — Используется для представления условного оператора. Выполнение определенного блока определяется оператором if. Рассмотрим следующий пример.
i = 18
if (1 < 12):
print("I am less than 18")
Вывод:
I am less than 18
13. else — Оператор else используется вместе с оператором if
. Если оператор if
возвращает false
, то выполняется блок else
. Рассмотрим следующий пример.
n = 11
if(n%2 == 0):
print("Even")
else:
print("odd")
Вывод:
Odd
14. elif — Это ключевое слово используется для проверки нескольких условий. Это сокращение от else-if. Если предыдущее условие ложно, то проверка выполняется до тех пор, пока не будет найдено истинное условие. Приведем следующий пример.
marks = int(input("Enter the marks:"))
if(marks>=90):
print("Excellent")
elif(marks<90 and marks>=75):
print("Very Good")
elif(marks<75 and marks>=60):
print("Good")
else:
print("Average")
Вывод:
Enter the marks:85
Very Good
15. del — Используется для удаления ссылки на объект. Рассмотрим следующий пример.
a=10
b=12
del a
print(b)
# a is no longer exist
print(a)
Вывод:
12
NameError: name 'a' is not defined
16. try, except — try-except используется для обработки исключений. Исключения — это ошибки времени выполнения. Рассмотрим следующий пример.
a = 0
try:
b = 1/a
except Exception as e:
print(e)
Вывод:
division by zero
17. raise — Ключевое слово raise используется для принудительной обработки исключения. Рассмотрим следующий пример.
a = 5
if (a>2):
raise Exception('a should not exceed 2 ')
Вывод:
Exception: a should not exceed 2
18. finally — Ключевое слово finally используется для создания блока кода, который будет выполняться всегда, независимо от того, приведет ли блок else
к ошибке или нет. Рассмотрим следующий пример.
a=0
b=5
try:
c = b/a
print(c)
except Exception as e:
print(e)
finally:
print('Finally always executed')
Вывод:
division by zero
Finally always executed
19. for, while — Оба ключевых слова используются для итерации. Ключевое слово for используется для итерации по последовательностям (список, кортеж, словарь, строка). Цикл while выполняется до тех пор, пока условие не вернет false
. Рассмотрим следующий пример.
Пример: цикл For
list = [1,2,3,4,5]
for i in list:
print(i)
Вывод:
1
2
3
4
5
Пример: цикл While
a = 0
while(a<5):
print(a)
a = a+1
Вывод:
0
1
2
3
4
20. import — Ключевое слово import используется для импорта модулей в текущий сценарий Python. Модуль содержит исполняемый код Python.
import math
print(math.sqrt(25))
Вывод:
5
21. from — Это ключевое слово используется для импорта определенной функции или атрибутов в текущий сценарий Python.
from math import sqrt
print(sqrt(25))
Вывод:
5
22. as — Используется для создания псевдонима имени. Он обеспечивает заданное пользователем имя при импорте модуля.
import calendar as cal
print(cal.month_name[5])
Вывод:
May
23. pass — Ключевое слово pass используется для того, чтобы ничего не выполнять или создать место для будущего кода. Если мы объявим пустой класс или функцию, это приведет к ошибке, поэтому мы используем ключевое слово pass, чтобы объявить пустой класс или функцию.
class my_class:
pass
def my_func():
pass
24. return — Ключевое слово return используется для возврата вызванной функции значения результата или его отсутствия.
def sum(a,b):
c = a+b
return c
print("The sum is:",sum(25,15))
Вывод:
The sum is: 40
25. is — Это ключевое слово используется для проверки того, ссылаются ли две переменные на один и тот же объект. Оно возвращает true
, если они ссылаются на один и тот же объект, иначе false
. Рассмотрим следующий пример.
x = 5
y = 5
a = []
b = []
print(x is y)
print(a is b)
Вывод:
True
False
26. global — Ключевое слово global используется для создания глобальной переменной внутри функции. Любая функция может получить доступ к глобальной. Рассмотрим следующий пример.
def my_func():
global a
a = 10
b = 20
c = a+b
print(c)
my_func()
def func():
print(a)
func()
Output:
Вывод:
30
10
27. nonlocal — Nonlocal похож на global
и используется для работы с переменной внутри вложенной функции (функция внутри функции). Рассмотрим следующий пример.
def outside_function():
a = 20
def inside_function():
nonlocal a
a = 30
print("Inner function: ",a)
inside_function()
print("Outer function: ",a)
outside_function()
Вывод:
Inner function: 30
Outer function: 30
28. lambda — Ключевое слово lambda используется для создания анонимной функции в Python. Это встроенная функция без имени. Рассмотрим следующий пример.
a = lambda x: x**2
for i in range(1,6):
print(a(i))
Вывод:
1
4
9
16
25
29. yield — Ключевое слово yield используется с генератором Python. Оно останавливает выполнение функции и возвращает значение вызывающей стороне. Рассмотрим следующий пример.
def fun_Generator():
yield 1
yield 2
yield 3
# Driver code to check above generator function
for value in fun_Generator():
print(value)
Вывод:
1
2
3
30. with — Ключевое слово with используется при обработке исключений. Оно делает код чище и читабельнее. Преимущество использования with заключается в том, что нам не нужно вызывать close()
. Рассмотрим следующий пример.
with open('file_path', 'w') as file:
file.write('hello world !')
31. None — Ключевое слово None используется для определения нулевого значения. Следует помнить, что None не обозначает 0
, false
или любые пустые типы данных. Это объект своего типа данных, который рассматривается в следующем примере.
def return_none():
a = 10
b = 20
c = a + b
x = return_none()
print(x)
Вывод:
None
Мы рассмотрели ключевые слова Python. Это краткое введение в ключевые слова Python. В последующих уроках мы узнаем больше.