Обучение языку программирования Python

[kirilljsx]

Введение

И так, всем здравствуйте! Меня зовут Кирилл Дворянинов и в этом треде я собираю для себя и для вас компактный, но по‑возможности полный вводный курс по Python. Я не пытаюсь написать еще одну «великую книгу» на сотни страниц - здесь будет только то, что реально нужно, без лишней теории и кругов вокруг да около.

По профессии я веб-разработчик, моя базовая «родная» среда - JavaScript и веб‑стек. Python мне понадобился как второй рабочий инструмент: для автоматизации, мелких скриптов, бэкенда и задач, где JS чувствуется уже не так удобно. Я не позиционирую себя как гуру Python; это честный конспект пути разработчика из JS‑мира, который системно осваивает еще один язык и параллельно документирует все по шагам начиная с самого простого понимая.

Если совсем коротко, Python - это универсальный язык программирования общего назначения с простым синтаксисом и упором на читаемость кода. На нем пишут бэкенды, скрипты для автоматизации, инструменты анализа данных и машинного обучения, игры, утилиты и еще кучу всего, от домашних скриптов до серьезных сервисов. За счет динамической типизации и лаконичного синтаксиса многие вещи на Python пишутся быстрее и «короче», чем на классических C‑подобных языках.

Подход который я буду использовать в этом материале простой:

• минимум лирики, максимум практики;
• объяснять так, чтобы было понятно человеку с базовыми представлениями о программировании, а не с двумя высшими по матанализу;
• не переписывать документацию, а помогать ее понимать.

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

Содержание

• Установка Python и работа с venv
• Часть 1 - Типы, значения и переменные
• Часть 2 - Числа
• Часть 3 - Условия
  Новые части будут добавляться по мере написания материала

[kirilljsx]

Установка Python и работа с venv

Для того что бы начать работать с Python, его необходимо установить. Я не буду уделять этому много времени, вы можете самостоятельно установить его под любую операционную систему с официального сайта - https://www.python.org/downloads/

Также нам понадобится IDE для работы с кодом, эпоха VS code прошла, по этому я рекомендую редактор нового поколения - ZED.

Работать через IDE удобно, так как у нас будет сразу же терминал и редактор кода в одном месте:

В профессиональной сфере хорошим тоном считается работа с терминалом, по этому создание папок и файлов будем писать в терминале, и так для того что бы создать нам папку, мы будем использовать команду - mkdir , а аргументом будет наименование папки:

mkdir project

Отлично, теперь после создания папки давайте перейдем в нее написав в терминале cd project. Теперь необходимо создать файл с которым мы будем работать для этого используем команду touch аргументом выступает наименование файла:

touch main.py

Теперь у нас есть подготовленная папка для проекта и начальный файл.
Но для начала работы, необходимо разобраться с виртуальным окружением.

Виртуальное окружение venv

Venv или по другому виртуальное окружение - это изолирование вашего проекта, а именно библиотеки и прочее. За пределами виртуальной среды, Python не будет иметь доступ к библиотекам проекта.

От теории к практике, для установки виртуальной среды, необходимо воспользоваться установкой, через встроенную утилиту pip:

pip install virtualenv

Далее создадим само виртуальное окружение, по стандарту оно называется venv, но мы можем использовать другое наименование к примеру project

python3 -m venv project

После установки, нам необходимо активировать окружение.

source project/bin/activate

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

Теперь давайте выйдем из него, для этого напишем в терминале deactivate:

deactivate

Так это выглядит в терминале.

Виртуальные окружения в Python решают проблему конфликтов зависимостей: каждый проект получает изолированный site-packages.

Пример: legacy-проект на Django 2.2 с mysqlclient==1.4.0, новый — на Django 4.1 с asyncpg. Без venv pip install django==4.1 сломает первый проект.

[kirilljsx]

Часть 1 - Типы, значения и переменные

Эта часть будет довольно теоретическая, но ее следует прочитать внимательно и вникнуть.

В Python данные являются объектами, память любого компьютера можно визуально представить в виде длинного ряда полок. Каждый слот имеет ширину в 1 байт (8 бит), если не знакомы с базовой информатикой не забивайте голову.

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

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

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

В Python каждый тип данных представлен собственным объектом в памяти: bool, int, str, float, а также функции и другие сущности.

А теперь коротко про каждый из типов:

• bool - логический тип: хранит только два значения True и False (удобен для условий и флагов).

• int - целые числа без дробной части; поддерживает числа произвольной длины и обычные операции (+, -, *, //, %).

• float - числа с плавающей точкой (дробные); это приближённые значения, поэтому возможны эффекты округления в вычислениях.

• complex - комплексные числа вида a+bja+bj (в Python мнимая единица - j); применяются в математике/сигналах и т.п.

• str - строка (текст), последовательность символов; неизменяемая, поэтому любые “правки” создают новую строку.

• list - список, упорядоченная изменяемая коллекция; можно добавлять/удалять элементы и менять по индексу.

• tuple - кортеж, упорядоченная неизменяемая коллекция; часто используют для “записей” (наборов значений) и как ключи словаря (если элементы тоже неизменяемые).

• bytes - неизменяемая последовательность байтов (0–255); удобно для бинарных данных (файлы, сети, хэши).

• bytearray - изменяемая версия bytes; удобно, когда нужно редактировать бинарные данные “на месте”.

• set - множество: неупорядоченная коллекция уникальных элементов; быстро проверять “есть ли элемент” и делать операции множеств (объединение/пересечение).

• frozenset - неизменяемое множество; можно использовать там, где требуется хэшируемость (например, как ключ словаря).

• dict - словарь “ключ → значение”; основная структура для отображений, конфигов, JSON-подобных данных и быстрого доступа по ключу.

Наименование	Тип	Изменяемый	Примеры
Булево значение	bool	Нет	True, False
Целое число	int	Нет	47, 25000, 25_000
Число с плавающей точкой	float	Нет	3.14, 2.7e5
Комплексное число	complex	Нет	3j, 5 + 9j
Текстовая строка	str	Нет	‘alas’, “alack”, “‘a verse attack’”
Список	list	Да	[‘Winken’, ‘Blinken’, ‘Nod’]
Кортеж	tuple	Нет	(2, 4, 8 )
Байты	bytes	Нет	b’ab\xff’
Массив байтов	bytearray	Да	bytearray(…)
Множество	set	Да	set()
Фиксированное множество	frozenset	Нет	frozenset([‘Elsa’, ‘Otto’])
Словарь	dict	Да	{‘game’: ‘bingo’, ‘dog’: ‘dingo’, ‘drummer’: ‘Ringo’}

---

Переменные

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

Но у Python имеются свои правила написания переменных и могут содержать только следующие символы:

• буквы в нижнем регистре от a до z
• буквы в верхнем регистре от A до Z
• цифры от 0 до 9
• нижнее подчеркивание (_)
• чувствительность к регистру: name, Name, NAME - будут разными именами
• начинаются с буквы или нижнего подчеркивания, но не с цифры
• имена не должны совпадать с зарезервированными словами самого Python

Ниже список зарезервированных слов:

Группа 1	Группа 2	Группа 3	Группа 4	Группа 5
False	await	else	import	pass
None	break	except	in	raise
True	class	finally	is	return
and	continue	for	lambda	try
as	def	from	nonlocal	while
assert	del	global	not	with
async	elif	if	or	yield

На заметку: что бы увидеть список этих слов, внутри интерпретатора введите команду help("keywords") или import keywords

Теперь поговорим о присваивание, как и во многих других языка Python использует символ равно = для присваивания значения переменных.

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

x = y + 10

Решить уравнение можно подставив какое либо значение для y, к примеру подставим число 5:

y = 5
x = y + 10
y
15

Также отмечу что строки программы означают нечто большее чем в уравнениях. x и y являются переменными. К тому же Python знает что последовательность цифр имеет типизацию Number или по другому числовой литерал.

---

Переменные - это имена, а не ячейки памяти

Одна важная отличительная особенность Python от других языков, что операция присваивания = не копирует значение, а лишь прикрепляет имя к объекту. Такой подход экономит время, но у него есть свои недостатки. Для сравнения с языком C, у Python скорость работы ниже, так как под капотом он заставляет компьютер выполнять больше работы для того что бы нам не пришлось выполнять ее самостоятельно.

Пример:

a = 7
print(a)
7

b = a
print(b)

В первом примере с a имена указывают на объекты, переменная указывает на целочисленный объект со значением.
В примере с b происходит копирование имени, теперь переменная b указывает на тот же целочисленный объект.

Для проверки типов у Python есть внутренняя функция type():

type(7)
<class int>

А для проверки указывает ли переменная на объект определенного типа используется конструкция isinstance(type) которая принимает два аргумента:

isinstance(7, int)
True

Вы наверное заметили ключевое слово class - это определение объекта, их мы гораздо рассмотрим позже.

Особенности переменных

Далее я перечислю еще несколько особенностей Python с переменными.
Оператор присваивания = можно использовать для назначения значения сразу нескольким переменным следующим образом:

two = qwe = zxc = 2

Еще одной из особенностью является копирование, если мы присвоим существующей переменной a новой переменной b то питон будет указывать на тот же объект что и a
Для наглядного примера взглянем на следующий код:

a = 5
b = a

И если мы попробуем вывести переменную b то получим в ответ 5.

А теперь давайте сделаем ситуацию чуть запутаннее:

a = 5
b = a

a = 10
a
# 10

b
# 5

Давайте разберемся что выведет наш код, при выполнении a = 5 создается объект со значением 5, и имя a начинает ссылаться на него. Затем строка b = a делает то же самое - теперь и a, и b указывают на один и тот же объект 5.
Когда мы выполняем a = 10, имя a просто переназначается и начинает ссылаться на другой объект - число 10.
Переменная b при этом остается связанной с прежним объектом 5, поэтому вывод b даст 5, а a - 10.

Таким образом переменные - это не изменяемый тип.

А теперь рассмотрим списки, или по другому изменяемый массив значений. В качестве примера у нас будет a и b которые будут указывать на список с 3 числами:

a = [2, 4, 6]
b = a
a
# [2, 4, 6]

b
# [2, 4, 6]

Элементы списка/массива a[0], a[1], a[2] сами по себе являются именами которые в свою очередь указывают на числа со значениями 2, 4 и 6. Подмечу что список хранит данные в заданном порядке.

А теперь давайте попробуем изменить первый элемент списка при помощи имени a и посмотрим что выведет список b:

a[0] = 10
a
# [10, 4, 6]
b
# [99, 4, 6]

Теперь первый элемент списка изменился и больше не указывает на объект со значением 2. Сам по себе список имеет тип list, но значения, порядок и элементы можно изменить. Про списки и массивы данных мы будем говорить в следующих темах.

Правила написание имени переменных

В примерах выше мы использовали простые имена переменных по типу a, b или x и y. Однако в реальных программах стоит выбирать более информативные и понятные названия - это значительно упрощает чтение, понимание и поддержку кода.

[kirilljsx]

Часть 2 - Числа

В этой части материала мы познакомимся более подробно с типизацией Python, а именно:

• булевые значения - true/false
• целы числа - int
• числа с плавающей точкой - float

Булевы значения

Одним из самых главных типов являются булевы значения и Python не исключения. Булевы имеются всего два - true и false.
В Python есть даже специальная функция bool() которая умеет преобразовывать любой другой тип в булев.

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

Давайте рассмотрим на примере для ненулевых числе:

bool(True)
# True
bool(1)
# True
bool(35)
# True
bool(-45)
# True

Во всех этих примерах функция bool() вернет нам значение True даже для отрицательных чисел.

А вот с нулевыми значениями дела обстоят иначе:

bool(False)
# False
bool(0)
# False
bool(0.0)
# False

Чем конкретно полезные булевы мы узнаем чуть позже и чем они полезны, при каких обстоятельствах списки, словари и другие типы данных могут преобразовываться как в True так и в False.

---

Про числа литералы

Любая последовательность чисел в Python будет число-литерал, для примера:

5
# 5
0
# 0

Обратите внимание что таже 0 будет числом литералом, но не стоит ставить его перед другими цифрами иначе мы получим синтаксическую ошибку:

05
# File "<stdin>", line 1
# SyntaxError: invalid token

Также отмечу что любая последовательность цифр будет указывать на целое число и даже если мы поместим знак + перед цифрами то число останется прежним:

123
# 123
+123
# 123

А вот что бы указать отрицательное число, необходимо всего лишь поместить перед цифрами знак - :

-123
# -123

Также есть ограничения на запятые, нельзя их использовать при записи целого числа:

1,000,000
# (1, 0, 0)

Вместо числа миллион мы получит кортеж с тремя значениями - про кортежи мы поговорим позже.
Но если нам необходимо разделить наш миллион для лучше читаемости то мы можем воспользовать нижним подчеркиванием:

million = 1_000_000
million
# 1000000

Нижние подчеркивания просто игнорируются, а мы можем ставить их на любую позицию по желани:

1_2_3
# 123

---

Операции с целыми числами

Почти как и любой другой язык - Python можно использовать как калькулятор, далее мы выполним простые арифметические операции, используя математические операторы:

• • сложение
• • вычитание
• • умножение
• / Деление с плавающей точкой
• // Целочисленное деление
• % Вычисление остатка
• ** Возведение в степень

Сложения и вычитания работают так как мы этого и ожидаем:

5 + 10
10

1000 - 7
993

5 - 10
-5

Мы можем работать абсолютно с любым количеством чисел и операторов:

10 + 10 - 5
15

5 + 10 - 10 + 15
20

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

10+5       + 5
20

Умножение также работаем как мы этого ожидаем:

5 * 2
10

5 * 3
15

5 * 4
20

А теперь к самому интересному, в Python есть два вида деления:

1. При помощи оператора / выполняются деления с плавающей точкой
2. С помощью оператора // выполняются целочисленные деления (деления с остатком)

И даже если мы будем делить целые числа друг на друга, оператор / даст результат с плавающей точкой, попробуй:

9 / 4
2.25

А вот если мы используем оператор // для целочисленного деления то в результате увидим целочисленное числа, так как оператор отбросит отстаток:

9 // 4
2

---

Целые числа и переменные

В предыдущих примерах мы использовали целочисленные значения, но их также можно смешивать с переменными, рассмотрим пример:

x = 100
x
# 100

x - 5
# 95

Ранее в 1-й части мы говорили про переменные, x - это имя которое указывает на целочисленный объект, в нашем случае это 100. Но когда мы выполняем операцию x - 5, то мы не присваиваем новое значение для переменной x, и ее значение остается неизменным.

x
# 100

А вот если мы в действительности хотим изменить значение нашей переменной x, необходимо сделать следующее:

x = x - 5
x
# 95

С точки зрения математики такая операция не совсем является корректной, но именно таким образом мы выполним повторное присвоение нового значения нашей переменной x. Также важно понимать про очередность выполнения, выражения стоящие справа после знака = первым делом вычисляются и только потом присваиваются переменной.

Лучше и конечно же проще выстраивать логику таким образом:

• Вычитаем 5 из x
• Присваиваем результат временной переменной
• Присваиваем x значение временной переменной

Вот как это можно описать в коде:

x = 100
y = x - 5
x = y

Но первый вариант все же будет короче, а второй нагляднее.

Также можно использовать оператор совместно с присваиванием, а выглядит это следующим образом:

x -= 5
# Такое выражение аналогично - x = x - 3

Аналогично будет и с оператором +:

x += 5
x
# 105

И с оператором умножения *:

x *= 2
x
# 200

А вот пример с оператором деления /:

x /= 3
x
# 33.333333333333336

И наконец попробуем целочисленное деление //:

x //= 3
x
# 33

Теперь поговори об операторе - % он же вычисляет остаток от деления первого числа:

10 % 4
# 2

Есть одна интересная встроенная функция - divmod(a,b) он умеет определять не только остаток, но и частное:

divmode(10,4)
# (2,2)

Достаточно удобная функция, так как она заменяет операции по отдельности:

10 // 4
# 2

10 % 4
# 2

Между делом - функция которую мы увидели divmod() она получает два аргумента, а возвращает кортеж. Но о кортежах мы будем говорить гораздо дальше, а пока просто имейте ввиду что есть такая функция.

Последняя математическая функция которую мы рассмотрим позволяет работать как с целыми числами, так и с плавающей точкой и называется это - возведением в степень или оператор **:

2 ** 5
# 32

2.0 ** 5
# 32.0

2 ** 5.0
# 32.0

---

Приоритет операций

Теперь рассмотрим с вами приоритетность операций, давайте попробуем вывести следующее выражение:

2 + 2 * 4
# 10

Если мы выполним сложение первым то получим следующее: 2+2=4, а 44=16, но если мы выполним умножение первым: 24=8 и 2+8=10. В языке Python как и почти во всех умножение имеет высокий приоритет в отличии от сложения.

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

2 + (2 * 4)

А вот еще пример с возведениями в степень:

-4 ** 2
# -16

Его можно записать так:

- (4 ** 2)
# -16

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

(-4) ** 2
# 16

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

---

Системы счисления

Скорее всего, другие системы счисления вам не пригодятся, но упомянуть их все равно полезно. В жизни и в коде мы привыкли к десятичной - вот она и в Python на первом месте.

Десятичная похожа на двоичную, но с нюансами. В двоичной 1 + 1 даст ответ 10, потому что это одна “единица двойки” плюс ноль единиц.

В Python поддерживаются ещё три варианта - с префиксами:

• 0b или 0B - двоичная
• 0o или 0O - восьмеричная
• 0x или 0X - шестнадцатеричная

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

Интерпретатор покажет их в десятичном виде. Давай проверим на примерах:

10
# 10 (десятичное)

Двоичное:

0b10
# 2

Восьмеричное:

0o10
# 8

Шестнадцатеричное:

0x10
# 16

Также существует обратная конверсия - из числа в строку нужной системы:

val = 65
bin(val)
'0b1000001'
oct(val)
'0o101'
hex(val)
'0x41'

Плюс chr() - число в символ:

chr(65)
'A'

И ord() - наоборот:

ord('A')
# 65

---

Преобразование типов

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

Давай рассмотрим пример на булев, наверное вы уже догадываетесь что True = 1, а False = 0. Давайте убедимся в этом:

int(True)
# 1
int(False)
# 0

Аналогично int() есть функция bool() которая возвращает булев эквивалент целого числа:

bool(1)
# True
bool(0)
# False

Рассмотрим пример с плавающими точками, функция int() просто отсекает все что находится после точки:

int(98.6)
# 98
int(1.0e4)
# 10000

И точно также, но наоборот если преобразовывать числа с плавающей точкой в булево:

bool(1.0)
# True
bool(0.0)
# False

А вот так выглядит преобразование строк в целочисленные числа:

int('99')
# 99
int('-23')
# -23
int('+12')
# 12
int('1_000_000')
# 1000000

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

int('10', 2) # двоичная
# 2
int('10', 8) # восьмеричная
# 8
int('10', 16) # шестнадцатеричная
# 16

Также можно попробовать преобразовать целое числа в целое число, но это ничего не даст, но также и и не навредит:

int(123)
# 123

Если мы попробуем преобразовать что-то не совсем похожее на числа, то всего скорее увидим ошибку:

int('hello!')

Правило функции int()- int не будет преобразовывать строки в числа.

Преобразования числе с плавающей точкой

Как и с функций int() ей есть аналог для числе с плавающей точкой и называется она точно также как и тип - float(), разу же рассмотрим пример:

float(True)
# 1.0
float(False)
# 0.0

Преобразование целых числе типа int, через float добавится просто десятичная точка:

float(20)
# 20.0
float(33)
# 33.0

Аналогично можно конвертировать и строки:

float('1.1')
# 1.1
float('-2.4')
# -2.4

И на последок - язык Python поддерживает многие математические функции, таких как косинусы, квадратные корни и многое другое. Их мы будем разбирать отдельно в будущих частях обучения, а также затронем такие библиотеки как math и cmath.

[kirilljsx]

Часть 3 - Условия

И так наконец-то мы боле менее подготовлены к следующему этапу - структурированию кода при помощи операторов - if, elif, else. И сразу приступим писать код, в качестве примера возьмем переменную с булевым значением. Ах да, также рекомендую начинать работать не в интерпретаторе, а через IDE и привыкать писать код в файлах. Создайте файл main.py и давайте напишем следующий код:

title = True

if title:
    print("Title is True")
else:
    print("Title is False")

После того как напишите коде, сохраните файле и вызовите его через консоль - python3 main.py
Если все корректно, то увидите в консоли строку - Title is True

Теперь подробнее про операторы if и else - эти операторы проверяют является ли значение нашего выражения равным True и выводит сообщение - Title is True. А если значение ложь (False) то выведет - Title is False. Надеюсь логика понятная тут ничего сложного нету.

Давайте напишем пример чуть-чуть посложнее, мы можем использовать проверку столько раз сколько захотим этого:

title = True
titleOne = True

if title:
    if titleOne:
        print("TitleOne is True")
    else:
        print("TitleOne is False")
else:
    if titleOne:
        print("TitleOne is True")
    else:
        print("TitleOne is False")

Обратите внимание на отступы - в Python они не косметика, а синтаксис. Интерпретатор по количеству пробелов понимает, где заканчивается блок if и начинается вложенный.

PEP 8 (стандарт стиля) требует ровно 4 пробела на уровень - без табов. В примере:

• Первый if title: проверяет title (True), входит в блок.
• Python видит следующие строки с +4 пробела - они “прикреплены” к этому if.
• Вложенный if titleOne: имеет +8 пробелов от начала - его пара else на том же уровне.

Без отступов мы получим ошибку - IndentationError. Это делает код читаемым и строгим.

Идем дальше и разберем пример еще сложнее, и так нам нужно проверить больше двух вариантов. Мы будем использовать операторы в определенной последовательности - if для первого варианта, elif (он же else if - иначе если) для промежуточных вариантов и else для последнего:

color = "blue"

if color == "red":
    print("The color is red.")
elif color == "green":
    print("The color is green.")
elif color == "purple":
    print("The color is purple.")
else:
    print("The color is not red, green, or purple.")

Важный момент: ни один if/elif не сработал (color ≠ red/green/purple), поэтому выполняется финальный else - выводит “The color is not…”. Штатная логика: else ловит все неподходящие случаи. Без else код просто завершится молча.

Обратим внимание на оператор == который проверяет равенство, по мимо него есть и другие:

• равенство (==)
• неравенство (!=)
• меньше (<)
• меньше или равно (<=)
• больше (>)
• больше или равно (>=)

Эти операторы возвращают булевы значение - True или False.
Давайте посмотрим на то как они работают:

x = 10

x == 10
# True

x == 5
# False

Для одновременного нескольких сравнений существуют дополнительные булевы операторы - and, or и not, они используются для определения итогового результата.

Подмечу: булевы операторы имеют более низкий приоритет в сравнении с операторами сравнивания.

Взглянем на пример:

x = 7
5 < x and x < 10
# True

В данном примере мы установили значение переменной x равным 7, проверка 5 < x вернет True, проверка x < 10 также вернет True, тем самым мы получим выражение True and True

Помните про круглые скобки из Части 2? Что бы избежать путаницы мы можем применить их:

(5 < x) and (x < 10)
# True

Рассмотрим и другие примеры:

5 < x or x < 10
# True

5 < x and x > 10
# False

5 < x and not x > 10
# True

Python по мимо проверки оператора and, также позволяет следующее:

5 < x < 10
# True

Это выражение аналогично этому - 5 < x and x < 10, мы также можем писать более длинные сравнения:

5 < x < 10 < 999

---

Истина

Материал подготавливается