Лекция 2¶

Сравнение чисел и не только.¶

Можно почитать тут.

In [ ]:

11 > 11

Out[ ]:

False

In [ ]:

11 >= 11

Out[ ]:

True

In [ ]:

11 < 11

Out[ ]:

False

In [ ]:

11 <= 11

Out[ ]:

True

In [ ]:

11 == 11

Out[ ]:

True

In [ ]:

11 != 11

Out[ ]:

False

In [ ]:

var = 5 > 3
var

Out[ ]:

True

In [ ]:

5.0 > 5

Out[ ]:

False

In [ ]:

5.0 >= 5

Out[ ]:

True

In [ ]:

True + 1

Out[ ]:

In [ ]:

False + 1

Out[ ]:

In [ ]:

True + True

Out[ ]:

In [ ]:

False + False

Out[ ]:

In [ ]:

var_complex_1 = 1 + 1j
var_complex_2 = 2 + 2j

In [ ]:

var_complex_1 == var_complex_2

Out[ ]:

False

In [ ]:

var_complex_1 != var_complex_1

Out[ ]:

False

In [ ]:

var_complex_2 >= var_complex_1 # тут будет ошибка :(

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipython-input-2072968567.py in <cell line: 0>()
----> 1 var_complex_2 >= var_complex_1 # тут будет ошибка :(

TypeError: '>=' not supported between instances of 'complex' and 'complex'

In [ ]:

А что с буквами и словами?

Строки сравниваются по лексикографическому порядку — как в словаре, но с учетом ASCII / Unicode кодов.

In [ ]:

'y' > 'a'

Out[ ]:

True

In [ ]:

'a' > 'c'

Out[ ]:

False

In [ ]:

'A' < 'a'

Out[ ]:

True

In [ ]:

'ab' >= 'ab'

Out[ ]:

True

In [ ]:

'ab' >= 'abc'

Out[ ]:

False

In [ ]:

'15' > '3' # как так? :)

Out[ ]:

False

In [ ]:

't' > 'c'

Out[ ]:

True

In [ ]:

't' > 'tc'

Out[ ]:

False

In [ ]:

print("apple" < "banana")  # True (a < b)
print("cat" < "dog")       # True (c < d)
print("abc" < "abd")       # True (c < d)
print("abc" < "abcd")      # True (более короткая строка меньше)
print("10" < "2")         # True (1 < 2 в лексикографическом порядке)

True
True
True
True
True

In [ ]:

'''

Сравнение работает следующим образом:

Сравниваются первые символы строк
Если они разные - определяется какая строка "больше" или "меньше" на основе кодов символов
Если первые символы одинаковые - переходим к следующим символам
Если одна строка заканчивается, а другая нет - более короткая строка считается "меньшей"

''';

In [ ]:

print(len("apple") < len("banana"))  # False (5 < 6)

True

In [ ]:

# Списки
print([1, 2, 3] < [1, 2, 4])    # True
print([1, 2] < [1, 2, 3])       # True (короче значит меньше)

# Кортежи
print((1, 2) == (1, 2))         # True
print((1, 2, 3) > (1, 2))       # True

# Строки (посимвольно)
print("abc" < "abd")             # True

True
True
True
True
True

In [ ]:

# В современных версиях Python (3.7+) словари можно сравнивать только на равенство:

dict1 = {"a": 1, "b": 2}
dict2 = {"a": 1, "b": 2}
dict3 = {"b": 2, "a": 1}

print(dict1 == dict2)  # True
print(dict1 == dict3)  # True (порядок не важен для равенства)

# А вот это не работает:
# print(dict1 > dict2)  # TypeError!

True
True

In [ ]:

'''

# В Python 3.6 это работало:
dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 1, 'b': 3}

print(dict1 < dict2)   # True (сравнение по содержимому)
print(dict1 > dict2)   # False

''';

In [ ]:

# Но если нужно сравнивать элементы словарей, то вот:

'''
# Сравнение по ключам
sorted(dict1.keys()) < sorted(dict2.keys())

# Сравнение по значениям
sorted(dict1.values()) < sorted(dict2.values())

# Или написать свою функцию сравнения
''';

In [ ]:

# Тут нужно быть очень внимательными.

# Кажется, что должно быть True, но...
print(0.1 + 0.2 == 0.3)  # False!

# Причина: неточность представления
print(0.1 + 0.2)  # 0.30000000000000004

# Правильный способ сравнения
import math

def almost_equal(a, b, tolerance=1e-9):
    return abs(a - b) < tolerance

print(almost_equal(0.1 + 0.2, 0.3))  # True

False
0.30000000000000004
True

In [ ]:

# Python 3 строже своего предшественника:

# В Python 3 это вызовет ошибку:
try:
    print(5 > "hello")
except TypeError as e:
    print(f"Ошибка: {e}")

# Но равенство разных типов всегда False
print(5 == "5")    # False
print([] == 0)     # False
print(None == 0)   # False

Ошибка: '>' not supported between instances of 'int' and 'str'
False
False
False

In [ ]:

Логические операторы.¶

In [ ]:

# Логическое И

x = True
y = False
print(x and y)  # False (оба должны быть True)

False

In [ ]:

# Логическое И

x = True
y = True
print(x and y)  # False (оба должны быть True)

True

In [ ]:

# Логическое ИЛИ

x = True
y = False
print(x or y)   # True (хотя бы один True)

True

In [ ]:

# Логическое ИЛИ

x = False
y = False
print(x or y)   # True (хотя бы один True)

False

In [ ]:

# Логическое НЕ

x = True
print(not x)    # False

False

In [ ]:

# Логическое НЕ

x = False
print(not x)    # False

True

In [ ]:

# Ленивое вычисление

# short-circuit evaluation
# вычисления по короткой схеме # вычисления Маккарти

Ссылка на Вики.

In [ ]:

print('hello') # просто пример функции, функция может быть любой

hello

In [ ]:

# and: если первый операнд False, второй не вычисляется

False and print('hello')

Out[ ]:

False

In [ ]:

# and: если первый операнд False, второй не вычисляется

True and print('hello')

hello

In [ ]:

# or: если первый операнд True, второй не вычисляется

True or print('hello')

Out[ ]:

True

In [ ]:

# or: если первый операнд True, второй не вычисляется

False or print('hello')

hello

In [ ]:

print('hello') and print('hello')

hello

In [ ]:

print('hello') or print('hello')

hello
hello

In [ ]:

# and возвращает последний True или первый False
print(5 and 3)    # 3
print(0 and 3)    # 0

# or возвращает первый True или последний False
print(5 or 3)     # 5
print(0 or 3)     # 3
print(0 or False) # False

3
0
5
3
False

In [ ]:

age = 25
name = "Anna"

if age >= 18 and name:  # оба условия True
    print("Доступ разрешен")

if not name:  # если name пустая строка/None
    print("Имя не указано")

Доступ разрешен

In [ ]:

my_list = [1, 2, 3]

if my_list:
  print(my_list)
else:
  print(None)

[1, 2, 3]

In [ ]:

my_list = []

if my_list:
  print(my_list)
else:
  print(None)

None

In [ ]:

# Можно заполнять значения по умолчанию

config = None

# Если config не None, используем его, иначе создаем новый
var = config or {1, 2, 3}
var

Out[ ]:

{1, 2, 3}

In [ ]:

# Можно заполнять значения по умолчанию

config = [1, 2, 3, 4, 5]

# Если config не None, используем его, иначе создаем новый
var = config or {1, 2, 3}
var

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

x = 10
y = 20

if (x > 5 and y < 30) or not x:
    print("Условие выполнено")

Условие выполнено

In [ ]:

Про приоритеты рекомендуем прочитать тут.

По всем операторам, а не только по сравнению.

In [ ]:

'''
Приоритет операторов:

not - высший приоритет
and - средний
or - низший
''';

In [ ]:

x = y = z = 1

# Эквивалентные выражения:
result = not x and y or z
print(result)
result = ((not x) and y) or z
print(result)

1
1

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

In [ ]:

x = 5
y = 3
print(x, y)

y, x = x, y
print(x, y)

# Сможете ли вы сделать тоже самое в C / C++? так быстро и удобно :)

5 3
3 5

In [ ]:

Коллекции.¶

In [ ]:

my_list = [-5, 0, 9, 2.1, 1+1j, 'string', True]
my_list

Out[ ]:

[-5, 0, 9, 2.1, (1+1j), 'string', True]

О методах списков написано здесь.

In [ ]:

my_list.append(False)

In [ ]:

my_list

Out[ ]:

[-5, 0, 9, 2.1, (1+1j), 'string', True, False]

In [ ]:

var = my_list.append('False')
var

In [ ]:

print(var)

None

In [ ]:

my_list

Out[ ]:

[-5, 0, 9, 2.1, (1+1j), 'string', True, False, 'False']

In [ ]:

my_list.append([-1, -2])

In [ ]:

my_list

Out[ ]:

[-5, 0, 9, 2.1, (1+1j), 'string', True, False, 'False', [-1, -2]]

In [ ]:

my_list = [1, 2, 3, 4, 5]
my_list

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list.append([1, 2, 3, 4, 5])

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 4, 5, [1, 2, 3, 4, 5]]

In [ ]:

my_list[5]

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list[5][0]

Out[ ]:

In [ ]:

my_list = [1, 2, 3, 4, 5]
my_list

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list.append(my_list)

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 4, 5, [...]]

In [ ]:

my_list[5]

Out[ ]:

[1, 2, 3, 4, 5, [...]]

In [ ]:

my_list[5][5]

Out[ ]:

[1, 2, 3, 4, 5, [...]]

In [ ]:

my_list[5][5][5]

Out[ ]:

[1, 2, 3, 4, 5, [...]]

In [ ]:

my_list = [1, 2, 3, 4, 5]
my_list

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list.clear()

In [ ]:

my_list

Out[ ]:

[]

In [ ]:

my_list = [1, 2, 3, 4, 5]
my_list

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list_2 = my_list
my_list_2

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list_3 = my_list.copy()
my_list_3

Out[ ]:

[1, 2, 3, 4, 5]

In [ ]:

my_list.append('hello :)')

In [ ]:

print(my_list)
print(my_list_2)
print(my_list_3)

# Почему это так? Есть предположения?
# Узнаете на следующих лекциях ;)

[1, 2, 3, 4, 5, 'hello :)']
[1, 2, 3, 4, 5, 'hello :)']
[1, 2, 3, 4, 5]

In [ ]:

my_list = [1, 2, 1, 'a', 'b', 'b']
my_list

Out[ ]:

[1, 2, 1, 'a', 'b', 'b']

In [ ]:

my_list.count(7)

Out[ ]:

In [ ]:

my_list.count(1)

Out[ ]:

In [ ]:

my_list.count('b')

Out[ ]:

In [ ]:

my_list = [1, 2, 3]
my_list

Out[ ]:

[1, 2, 3]

In [ ]:

my_list.append(5)

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 5]

In [ ]:

my_list.append(6, 7) # печалька...

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipython-input-753948587.py in <cell line: 0>()
----> 1 my_list.append(6, 7) # печалька...

TypeError: list.append() takes exactly one argument (2 given)

In [ ]:

my_list.append((6, 7))

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 5, (6, 7)]

In [ ]:

my_list.extend([6, 7])

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 5, (6, 7), 6, 7]

In [ ]:

my_list.extend((8, 9))

In [ ]:

my_list

Out[ ]:

[1, 2, 3, 5, (6, 7), 6, 7, 8, 9]

In [ ]:

my_list = [1, 2, 1, 'a', 'b', 'b']
my_list

Out[ ]:

[1, 2, 1, 'a', 'b', 'b']

In [ ]:

my_list.index(1)

Out[ ]:

In [ ]:

my_list.index(2)

Out[ ]:

In [ ]:

my_list.index('b')

Out[ ]:

In [ ]: