В этом случае мы получим число 17, как и должно быть. Однако если пользователь вместо числа введет строку, то программа завершится с фатальной ошибкой. Как обработать ошиб- ку, мы разберемся по мере изучения языка.
2.6. Удаление переменных
Удалить переменную можно с помощью инструкции del
: del <Переменная1>[, ..., <ПеременнаяN>]
Глава 2. Переменные
51
Пример удаления одной переменной:
>>> x = 10; x
10
>>> del x; x
Traceback (most recent call last):
File "
", line 1, in del x; x
NameError: name 'x' is not defined
Пример удаления нескольких переменных:
>>> x, y = 10, 20
>>> del x, y
ГЛ А В А
3
Операторы
Операторы позволяют произвести с данными определенные действия. Например, операто- ры присваивания служат для сохранения данных в переменной, математические операторы позволяют выполнить арифметические вычисления, а оператор конкатенации строк служит для соединения двух строк в одну. Рассмотрим операторы, доступные в Python 3, подробно.
3.1. Математические операторы
Производить операции над числами позволяют математические операторы:
+
— сложение:
>>> 10 + 5 # Целые числа
15
>>> 12.4 + 5.2 # Вещественные числа
17.6
>>> 10 + 12.4 # Целые и вещественные числа
22.4
-
— вычитание:
>>> 10 - 5 # Целые числа
5
>>> 12.4 - 5.2 # Вещественные числа
7.2
>>> 12 - 5.2 # Целые и вещественные числа
6.8
*
— умножение:
>>> 10 * 5 # Целые числа
50
>>> 12.4 * 5.2 # Вещественные числа
64.48
>>> 10 * 5.2 # Целые и вещественные числа
52.0
/
— деление. Результатом деления всегда является вещественное число, даже если про- изводится деление целых чисел. Обратите внимание на эту особенность, если вы раньше
Глава 3. Операторы
53 программировали на Python 2. В Python 2 при делении целых чисел остаток отбрасывал- ся и возвращалось целое число, в Python 3 поведение оператора изменилось:
>>> 10 / 5 # Деление целых чисел без остатка
2.0
>>> 10 / 3 # Деление целых чисел с остатком
3.3333333333333335
>>> 10.0 / 5.0 # Деление вещественных чисел
2.0
>>> 10.0 / 3.0 # Деление вещественных чисел
3.3333333333333335
>>> 10 / 5.0 # Деление целого числа на вещественное
2.0
>>> 10.0 / 5 # Деление вещественного числа на целое
2.0
//
— деление с округлением вниз. Вне зависимости от типа чисел остаток отбрасывается:
>>> 10 // 5 # Деление целых чисел без остатка
2
>>> 10 // 3 # Деление целых чисел с остатком
3
>>> 10.0 // 5.0 # Деление вещественных чисел
2.0
>>> 10.0 // 3.0 # Деление вещественных чисел
3.0
>>> 10 // 5.0 # Деление целого числа на вещественное
2.0
>>> 10 // 3.0 # Деление целого числа на вещественное
3.0
>>> 10.0 // 5 # Деление вещественного числа на целое
2.0
>>> 10.0 // 3 # Деление вещественного числа на целое
3.0
%
— остаток от деления:
>>> 10 % 5 # Деление целых чисел без остатка
0
>>> 10 % 3 # Деление целых чисел с остатком
1
>>> 10.0 % 5.0 # Операция над вещественными числами
0.0
>>> 10.0 % 3.0 # Операция над вещественными числами
1.0
>>> 10 % 5.0 # Операция над целыми и вещественными числами
0.0
>>> 10 % 3.0 # Операция над целыми и вещественными числами
1.0
>>> 10.0 % 5 # Операция над целыми и вещественными числами
0.0
>>> 10.0 % 3 # Операция над целыми и вещественными числами
1.0
54
Часть I. Основы языка Python
**
— возведение в степень:
>>> 10 ** 2, 10.0 ** 2
(100, 100.0)
унарный минус (–) и унарный плюс (
+
):
>>> +10, +10.0, -10, -10.0, -(-10), -(-10.0)
(10, 10.0, -10, -10.0, 10, 10.0)
Как видно из примеров, операции над числами разных типов возвращают число, имеющее более сложный тип из типов, участвующих в операции. Целые числа имеют самый простой тип, далее идут вещественные числа и самый сложный тип — комплексные числа. Таким образом, если в операции участвуют целое число и вещественное, то целое число будет автоматически преобразовано в вещественное число, затем будет произведена операция над вещественными числами, а результатом станет вещественное число.
При выполнении операций над вещественными числами следует учитывать ограничения точности вычислений. Например, результат следующей операции может показаться стран- ным:
>>> 0.3 - 0.1 - 0.1 - 0.1
-2.7755575615628914e-17
Ожидаемым был бы результат
0.0
, но, как видно из примера, мы получили совсем другой результат. Если необходимо производить операции с фиксированной точностью, следует использовать модуль decimal
:
>>> from decimal import Decimal
>>> Decimal("0.3") - Decimal("0.1") - Decimal("0.1") - Decimal("0.1")
Decimal('0.0')
3.2. Двоичные операторы
Двоичные операторы предназначены для манипуляции отдельными битами. Язык Python поддерживает следующие двоичные операторы:
— двоичная инверсия. Значение каждого бита заменяется на противоположное:
>>> x = 100 # 01100100
>>> x = x # 10011011
&
— двоичное И:
>>> x = 100 # 01100100
>>> y = 75 # 01001011
>>> z = x & y # 01000000
>>> "{0:b} & {1:b} = {2:b}".format(x, y, z)
'1100100 & 1001011 = 1000000'
|
— двоичное ИЛИ:
>>> x = 100 # 01100100
>>> y = 75 # 01001011
>>> z = x | y # 01101111
>>> "{0:b} | {1:b} = {2:b}".format(x, y, z)
'1100100 | 1001011 = 1101111'
Глава 3. Операторы
55
^
— двоичное исключающее ИЛИ:
>>> x = 100 # 01100100
>>> y = 250 # 11111010
>>> z = x ^ y # 10011110
>>> "{0:b} ^ {1:b} = {2:b}".format(x, y, z)
'1100100 ^ 11111010 = 10011110'
<<
— сдвиг влево — сдвигает двоичное представление числа влево на один или более разрядов и заполняет разряды справа нулями:
>>> x = 100 # 01100100
>>> y = x << 1 # 11001000
>>> z = y << 1 # 10010000
>>> k = z << 2 # 01000000
>>
— сдвиг вправо — сдвигает двоичное представление числа вправо на один или более разрядов и заполняет разряды слева нулями, если число положительное:
>>> x = 100 # 01100100
>>> y = x >> 1 # 00110010
>>> z = y >> 1 # 00011001
>>> k = z >> 2 # 00000110
Если число отрицательное, то разряды слева заполняются единицами:
>>> x = -127 # 10000001
>>> y = x >> 1 # 11000000
>>> z = y >> 2 # 11110000
>>> k = z << 1 # 11100000
>>> m = k >> 1 # 11110000 3.3. Операторы для работы с последовательностями
Для работы с последовательностями предназначены следующие операторы:
+
— конкатенация:
>>> print("Строка1" + "Строка2") # Конкатенация строк
Строка1Строка2
>>> [1, 2, 3] + [4, 5, 6] # Списки
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4, 5, 6) # Кортежи
(1, 2, 3, 4, 5, 6)
*
— повторение:
>>> "s" * 20 # Строки 'ssssssssssssssssssss'
>>> [1, 2] * 3 # Списки
[1, 2, 1, 2, 1, 2]
>>> (1, 2) * 3 # Кортежи
(1, 2, 1, 2, 1, 2)
56
Часть I. Основы языка Python
in
— проверка на вхождение. Если элемент входит в последовательность, то возвраща- ется логическое значение
True
:
>>> "Строка" in "Строка для поиска" # Строки
True
>>> "Строка2" in "Строка для поиска" # Строки
False
>>> 2 in [1, 2, 3], 4 in [1, 2, 3] # Списки
(True, False)
>>> 2 in (1, 2, 3), 6 in (1, 2, 3) # Кортежи
(True, False)
not in
— проверка на невхождение. Если элемент не входит в последовательность, воз- вращается
True
:
>>> "Строка" not in "Строка для поиска" # Строки
False
>>> "Строка2" not in "Строка для поиска" # Строки
True
>>> 2 not in [1, 2, 3], 4 not in [1, 2, 3] # Списки
(False, True)
>>> 2 not in (1, 2, 3), 6 not in (1, 2, 3) # Кортежи
(False, True)
3.4. Операторы присваивания
Операторы присваивания предназначены для сохранения значения в переменной. Приведем перечень операторов присваивания, доступных в языке Python:
=
— присваивает переменной значение:
>>> x = 5; x
5
+=
— увеличивает значение переменной на указанную величину:
>>> x = 5; x += 10 # Эквивалентно x = x + 10
>>> x
15
Для последовательностей оператор
+=
производит конкатенацию:
>>> s = "Стр"; s += "ока"
>>> print(s)
Строка
-=
— уменьшает значение переменной на указанную величину:
>>> x = 10; x -= 5 # Эквивалентно x = x — 5
>>> x
5
*=
— умножает значение переменной на указанную величину:
>>> x = 10; x *= 5 # Эквивалентно x = x * 5
>>> x
50
Глава 3. Операторы
57
Для последовательностей оператор
*=
производит повторение:
>>> s = "*"; s *= 20
>>> s
'********************'
/=
— делит значение переменной на указанную величину:
>>> x = 10; x /= 3 # Эквивалентно x = x / 3
>>> x
3.3333333333333335
>>> y = 10.0; y /= 3.0 # Эквивалентно y = y / 3.0
>>> y
3.3333333333333335
//=
— деление с округлением вниз и присваиванием:
>>> x = 10; x //= 3 # Эквивалентно x = x // 3
>>> x
3
>>> y = 10.0; y //= 3.0 # Эквивалентно y = y // 3.0
>>> y
3.0
%=
— деление по модулю и присваивание:
>>> x = 10; x %= 2 # Эквивалентно x = x % 2
>>> x
0
>>> y = 10; y %= 3 # Эквивалентно y = y % 3
>>> y
1
**=
— возведение в степень и присваивание:
>>> x = 10; x **= 2 # Эквивалентно x = x ** 2
>>> x
100 3.5. Приоритет выполнения операторов
В какой последовательности будет вычисляться приведенное далее выражение? x = 5 + 10 * 3 / 2
Это зависит от приоритета выполнения операторов. В данном случае последовательность вычисления выражения будет такой:
1. Число 10 будет умножено на 3, т. к. приоритет оператора умножения выше приоритета оператора сложения.
2. Полученное значение будет поделено на 2, т. к. приоритет оператора деления равен при- оритету оператора умножения (а операторы с равными приоритетами выполняются сле- ва направо), но выше, чем у оператора сложения.
58
Часть I. Основы языка Python
3. К полученному значению будет прибавлено число 5, т. к. оператор присваивания
=
имеет наименьший приоритет.
4. Значение будет присвоено переменной x
>>> x = 5 + 10 * 3 / 2
>>> x
20.0
С помощью скобок можно изменить последовательность вычисления выражения: x = (5 + 10) * 3 / 2
Теперь порядок вычислений станет иным:
1. К числу 5 будет прибавлено 10.
2. Полученное значение будет умножено на 3.
3. Полученное значение будет поделено на 2.
4. Значение будет присвоено переменной x
>>> x = (5 + 10) * 3 / 2
>>> x
22.5
Перечислим операторы в порядке убывания приоритета:
1.
-x
,
+x
,
x
,
**
— унарный минус, унарный плюс, двоичная инверсия, возведение в сте- пень. Если унарные операторы расположены слева от оператора
**
, то возведение в сте- пень имеет больший приоритет, а если справа — то меньший. Например, выражение:
-10 ** -2 эквивалентно следующей расстановке скобок:
-(10 ** (-2))
2.
*
,
%
,
/
,
//
— умножение (повторение), остаток от деления, деление, деление с округле- нием вниз.
3.
+
, – — сложение (конкатенация), вычитание.
4.
<<
,
>>
— двоичные сдвиги.
5.
&
— двоичное И.
6.
^
— двоичное исключающее ИЛИ.
7.
|
— двоичное ИЛИ.
8.
=
,
+=
,
-=
,
*=
,
/=
,
//=
,
%=
,
**=
— присваивание.
ГЛ А В А
4
Условные операторы и циклы
Условные операторы позволяют в зависимости от значения логического выражения выпол- нить отдельный участок программы или, наоборот, не выполнить его. Логические выраже- ния возвращают только два значения:
True
(истина) или
False
(ложь), которые ведут себя как целые числа
1
и
0
соответственно:
>>> True + 2 # Эквивалентно 1 + 2 3
>>> False + 2 # Эквивалентно 0 + 2 2
Логическое значение можно сохранить в переменной:
>>> x = True; y = False
>>> x, y
(True, False)
Любой объект в логическом контексте может интерпретироваться как истина (
True
) или как ложь (
False
). Для определения логического значения можно использовать функцию bool()
Значение
True возвращает следующие объекты:
любое число, не равное нулю:
>>> bool(1), bool(20), bool(-20)
(True, True, True)
>>> bool(1.0), bool(0.1), bool(-20.0)
(True, True, True)
не пустой объект:
>>> bool("0"), bool([0, None]), bool((None,)), bool({"x": 5})
(True, True, True, True)
Следующие объекты интерпретируются как
False
:
число, равное нулю:
>>> bool(0), bool(0.0)
(False, False)
пустой объект:
>>> bool(""), bool([]), bool(())
(False, False, False)
60
Часть I. Основы языка Python
значение
None
:
>>> bool(None)
False
4.1. Операторы сравнения
Операторы сравнения используются в логических выражениях. Приведем их перечень:
==
— равно:
>>> 1 == 1, 1 == 5
(True, False)
!=
— не равно:
>>> 1 != 5, 1 != 1
(True, False)
<
— меньше:
>>> 1 < 5, 1 < 0
(True, False)
>
— больше:
>>> 1 > 0, 1 > 5
(True, False)
<=
— меньше или равно:
>>> 1 <= 5, 1 <= 0, 1 <= 1
(True, False, True)
>=
— больше или равно:
>>> 1 >= 0, 1 >= 5, 1 >= 1
(True, False, True)
in
— проверка на вхождение в последовательность:
>>> "Строка" in "Строка для поиска" # Строки
True
>>> 2 in [1, 2, 3], 4 in [1, 2, 3] # Списки
(True, False)
>>> 2 in (1, 2, 3), 4 in (1, 2, 3) # Кортежи
(True, False)
Оператор in можно также использовать для проверки существования ключа словаря:
>>> "x" in {"x": 1, "y": 2}, "z" in {"x": 1, "y": 2}
(True, False)
not in
— проверка на невхождение в последовательность:
>>> "Строка" not in "Строка для поиска" # Строки
False
>>> 2 not in [1, 2, 3], 4 not in [1, 2, 3] # Списки
(False, True)
Глава 4. Условные операторы и циклы
61
>>> 2 not in (1, 2, 3), 4 not in (1, 2, 3) # Кортежи
(False, True)
is
— проверяет, ссылаются ли две переменные на один и тот же объект. Если перемен- ные ссылаются на один и тот же объект, оператор is возвращает значение
True
:
>>> x = y = [1, 2]
>>> x is y
True
>>> x = [1, 2]; y = [1, 2]
>>> x is y
False
Следует заметить, что в целях повышения эффективности интерпретатор производит кэширование малых целых чисел и небольших строк. Это означает, что если ста пере- менным присвоено число 2, то в этих переменных, скорее всего, будет сохранена ссылка на один и тот же объект:
>>> x = 2; y = 2; z = 2
>>> x is y, y is z
(True, True)
is not
— проверяет, ссылаются ли две переменные на разные объекты. Если это так, возвращается значение
True
:
>>> x = y = [1, 2]
>>> x is not y
False
>>> x = [1, 2]; y = [1, 2]
>>> x is not y
True
Значение логического выражения можно инвертировать с помощью оператора not
:
>>> x = 1; y = 1
>>> x == y
True
>>> not (x == y), not x == y
(False, False)
Если переменные x
и y
равны, возвращается значение
True
, но так как перед выражением стоит оператор not
, выражение вернет
False
. Круглые скобки можно не указывать, по- скольку оператор not
имеет более низкий приоритет выполнения, чем операторы сравнения.
В логическом выражении можно указывать сразу несколько условий:
>>> x = 10
>>> 1 < x < 20, 11 < x < 20
(True, False)
Несколько логических выражений можно объединить в одно большое с помощью следую- щих операторов:
and
— логическое И. Если x
в выражении x and y интерпретируется как
False
, то воз- вращается x
, в противном случае — y
. Примеры:
>>> 1 < 5 and 2 < 5 # True and True == True
True
62
Часть I. Основы языка Python
>>> 1 < 5 and 2 > 5 # True and False == False
False
>>> 1 > 5 and 2 < 5 # False and True == False
False
>>> 10 and 20, 0 and 20, 10 and 0
(20, 0, 0)
or
— логическое ИЛИ. Если x
в выражении x or y интерпретируется как
False
, то воз- вращается y
, в противном случае — x
. Примеры:
>>> 1 < 5 or 2 < 5 # True or True == True
True
>>> 1 < 5 or 2 > 5 # True or False == True
True
>>> 1 > 5 or 2 < 5 # False or True == True
True
>>> 1 > 5 or 2 > 5 # False or False == False
False
>>> 10 or 20, 0 or 20, 10 or 0
(10, 20, 10)
>>> 0 or "" or None or [] or "s"
's'
Следующее выражение вернет
True только в том случае, если оба выражения вернут
True
: x1 == x2 and x2 != x3
А это выражение вернет
True
, если хотя бы одно из выражений вернет
True
: x1 == x2 or x3 == x4
Перечислим операторы сравнения в порядке убывания приоритета:
1.
<
,
>
,
<=
,
>=
,
==
,
!=
,
<>
, is
, is not
, in
, not in
2. not
— логическое отрицание.
3. and
— логическое И.
4. or
— логическое ИЛИ.
4.2. Оператор ветвления if...else
Оператор ветвления if...else позволяет в зависимости от значения логического выраже- ния выполнить отдельный участок программы или, наоборот, не выполнить его. Оператор имеет следующий формат: if <Логическое выражение>:
<Блок, выполняемый, если условие истинно>
[elif <Логическое выражение>:
<Блок, выполняемый, если условие истинно>
]
[else:
<Блок, выполняемый, если все условия ложны>
]
Глава 4. Условные операторы и циклы
63
Как вы уже знаете, блоки внутри составной инструкции выделяются одинаковым количест- вом пробелов (обычно четырьмя). Концом блока является инструкция, перед которой рас- положено меньшее количество пробелов. В некоторых языках программирования логиче- ское выражение заключается в круглые скобки. В языке Python это делать необязательно, но можно, т. к. любое выражение может быть расположено внутри круглых скобок. Тем не менее, круглые скобки следует использовать только при необходимости разместить условие на нескольких строках.
Скачать 7.92 Mb.