7. Булевы значения и условия

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

Вспомните повседневные решения: «Если идёт дождь, я возьму зонт». «Если температура выше 30°C, я включу кондиционер». Эти решения основаны на условиях, которые либо истинны, либо ложны. Python использует тот же принцип: он оценивает условия, чтобы определить, являются ли они истинными или ложными, а затем действует соответствующим образом.

В этой главе мы изучим булевы значения, научимся создавать условия с помощью операторов сравнения, разберёмся с понятием «истинности» в Python и откроем для себя мощные приёмы построения сложных логических выражений. К концу главы вы овладеете строительными блоками, необходимыми для операторов if и циклов, о которых вы узнаете в следующих главах.

7.1) Булевы значения True и False

В Python есть специальный тип данных под названием bool (сокращение от Boolean), который представляет значения истинности. У этого типа ровно два возможных значения: True и False. Обратите внимание, что эти значения пишутся с заглавной буквы — это важно в Python. Запись true или false (строчными буквами) приведёт к ошибке, потому что Python их не распознает.

python

# boolean_basics.py
# Создание булевых переменных
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

Булевы значения фундаментальны, потому что они представляют результат любого вопроса «да/нет», который может задать ваша программа: Больше ли это число 10? Содержит ли эта строка букву 'a'? Пользователь вошёл в систему? Любое условие в Python в конечном итоге вычисляется в True или False.

7.1.1) Булевы значения в переменных и выражениях

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

python

# boolean_variables.py
# Использование булевых переменных для отслеживания состояний
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Булевые переменные можно переназначать
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

Булевые переменные часто называют с префиксами is_, has_ или can_, чтобы сделать их назначение понятным. Такое соглашение об именовании помогает вам и другим людям, читающим код, сразу понимать, что переменная хранит значение «истина/ложь».

7.2) Операторы сравнения и базовые условия

Хотя вы можете создавать булевы значения напрямую с помощью True и False, большинство булевых значений в ваших программах будут получаться из сравнений — проверки отношений между значениями. Python предоставляет несколько операторов сравнения, которые сравнивают два значения и возвращают булев результат.

7.2.1) Шесть операторов сравнения

В Python есть шесть основных операторов сравнения:

Operator	Значение	Пример	Результат
`==`	Равно	`5 == 5`	`True`
`!=`	Не равно	`5 != 3`	`True`
`<`	Меньше чем	`3 < 5`	`True`
`>`	Больше чем	`5 > 3`	`True`
`<=`	Меньше либо равно	`5 <= 5`	`True`
`>=`	Больше либо равно	`5 >= 3`	`True`

Посмотрим на эти операторы в действии:

python

# comparison_operators.py
# Сравнение чисел
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# Сравнения равных значений
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

7.2.2) Сравнение чисел и строк

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

python

# comparing_types.py
# Сравнение чисел с плавающей точкой
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# Сравнение строк (алфавитный/лексикографический порядок)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# Сравнение строк чувствительно к регистру
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# Сравнение длины строк с помощью len()
print(len(name1) == len(name2))  # Output: False

При сравнении строк Python использует лексикографический порядок, который по сути является алфавитным порядком на основе значений символов Unicode. Заглавные буквы идут перед строчными, поэтому "Python" и "python" не равны.

7.2.3) Сохранение результатов сравнения

Результат любого сравнения — булево значение, а значит, его можно сохранить в переменной:

python

# storing_comparisons.py
# Сохранение результатов сравнения для последующего использования
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # Вскоре мы изучим составные сравнения
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# Использование сохранённых сравнений в вычислениях или других выражениях
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

Сохранение результатов сравнения в описательно названных переменных делает код более читаемым. Вместо того чтобы многократно писать age >= 18 по всей программе, вы можете использовать переменную is_adult, которая явно показывает, что вы проверяете.

7.3) Булевы значения из сравнений, выражений и функции bool()

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

7.3.1) Функция bool()

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

python

# bool_function.py
# Преобразование чисел в булевы значения
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# Преобразование строк в булевы значения
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# Преобразование None в булево значение
print(bool(None))    # Output: False

Функция bool() следует определённым правилам преобразования, которые мы подробно разберём в следующем разделе об истинности и ложности значений. Пока отметим, что большинство значений преобразуются в True, но некоторые особые значения, такие как 0, 0.0, пустые строки ("") и None, преобразуются в False.

7.4) Истинность и ложность значений в условиях

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

7.4.1) Ложные (falsy) значения: что считается False

В Python следующие значения считаются ложными (они ведут себя как False в булевом контексте):

Само булево значение False
Специальное значение None
Нулевые числа в любой форме: 0, 0.0, 0j (комплексный ноль)
Пустые последовательности: "" (пустая строка), [] (пустой список), () (пустой кортеж)
Пустые отображения: {} (пустой словарь)
Пустые множества: set()

Проверим это с помощью функции bool():

python

# falsy_values.py
# Все эти значения являются ложными
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

7.4.2) Истинные (truthy) значения: всё остальное

Все остальные значения в Python считаются истинными (они ведут себя как True в булевом контексте). К ним относятся:

Само булево значение True
Любое ненулевое число (положительное или отрицательное)
Любая непустая строка, список, кортеж, словарь или множество
Большинство создаваемых вами объектов

python

# truthy_values.py
# Все эти значения являются истинными
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

Важное замечание: Строка "False" является истинной, потому что это непустая строка. Строка "0" тоже является истинной по той же причине. Ложными являются только само булево значение False и числовое значение 0.

7.4.3) Почему истинность важна

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

Истинность позволяет писать лаконичный код, который проверяет, содержат ли коллекции элементы, есть ли содержимое у строк или присутствуют ли необязательные значения. Вот небольшой пример того, как истинность будет полезна (полный синтаксис оператора if мы изучим в главе 8):

python

# truthiness_preview.py
# Демонстрация истинности с помощью bool()
# (В главе 8 мы будем использовать это напрямую в операторах if)
 
# Проверка, есть ли содержимое у строки
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# Проверка, есть ли элементы в списке
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# Проверка, существует ли значение (не равно None)
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

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

7.5) Составные сравнения и типичные ловушки при работе с булевыми значениями

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

7.5.1) Составные сравнения

В математике вы можете записать «10 < x < 20», чтобы выразить, что x находится между 10 и 20. Python позволяет записать это точно так же:

python

# chained_comparisons.py
# Проверка, находится ли значение в диапазоне
x = 15
 
# Математическая запись (составное сравнение)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Это эквивалентно объединению двух сравнений
# (О операторе 'and' мы узнаем в главе 9)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# Проверка значения вне диапазона
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# Проверка граничных значений
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# Включение границ с помощью <= и >=
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

Составные сравнения работают, оценивая каждую пару соседних элементов. Выражение 10 < x < 20 вычисляется как (10 < x) and (x < 20). Все сравнения в цепочке должны быть истинными, чтобы всё выражение было истинным.

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

python

# multiple_chains.py
# Сцепление нескольких сравнений
a = 5
b = 10
c = 15
d = 20
 
# Проверка, идут ли значения по возрастанию
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

Вот наглядное представление того, как работают составные сравнения:

7.5.2) Типичная ловушка: присваивание vs сравнение

Одна из самых распространённых ошибок новичков — использовать оператор присваивания (=), когда нужен оператор сравнения (==):

python

# assignment_vs_comparison_pitfall.py
x = 10
 
# Это присваивание, а не сравнение
# Оно присваивает 20 переменной x, а не сравнивает x с 20
# x = 20  # Это изменит x на 20
 
# Это сравнение
result = (x == 20)  # Это проверяет, равно ли x 20
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# В главе 8 вы узнаете, что использование = в условиях вызывает ошибку
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# Правильное сравнение
# В главе 8 вы напишете: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

Python помогает предотвратить эту ошибку в операторах if (о которых вы узнаете в главе 8), вызывая SyntaxError, если вы используете присваивание вместо сравнения. Однако в других контекстах использование = там, где вы имели в виду ==, может порождать тонкие ошибки, которые сложно обнаружить.

7.5.3) Типичная ловушка: сравнение чисел с плавающей точкой

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

python

# floating_point_comparison.py
# Арифметика с плавающей точкой может иметь проблемы с точностью
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# Прямое сравнение может работать не так, как ожидается
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# Фактическое значение очень близко к 0.3, но не равно ему точно
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# Для сравнения чисел с плавающей точкой используйте небольшую погрешность
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# В Python 3.5+ для этого есть math.isclose()
# Об импорте модулей мы узнаем в главе 23
# import math
# is_close = math.isclose(result, 0.3)

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

7.6) Булевы значения как целые числа (1 и 0) и почему следует избегать арифметики с ними

Вот удивительный факт: в Python True и False на самом деле являются особыми случаями целых чисел. True эквивалентно 1, а False — 0. Это исторический артефакт в дизайне Python, но он имеет интересные последствия. Понимание этой связи помогает избежать путаницы, но напрямую использовать её в своём коде вам почти никогда не потребуется.

7.6.1) Булевы значения — это целые числа

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

python

# booleans_as_integers.py
# Булевы значения являются подтипом целых чисел
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True равно 1, False равно 0
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Вы можете использовать булевы значения в арифметике (но не стоит!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Булевы значения можно использовать как индексы списка
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

Функция isinstance() проверяет, является ли значение экземпляром типа. Когда мы вызываем isinstance(True, int), Python возвращает True, потому что тип bool является подклассом типа int.

7.6.2) Почему следует избегать арифметики с булевыми значениями

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

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

python

# boolean_arithmetic_problems.py
# Пример запутанного кода
count = 0
has_error = True
has_warning = False
 
# Это работает, но запутывает
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# Что это значит? Это неочевидно!
# Лучший подход: быть явным
# О тернарном операторе if-else мы узнаем в главе 10.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

Единственное распространённое исключение из этого правила — когда вы считаете количество значений True в коллекции:

python

# counting_trues.py
# Подсчёт количества истинных условий
conditions = [True, False, True, True, False]
 
# Это приемлемо, потому что намерение ясно
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# Это работает, потому что sum() складывает значения
# True интерпретируется как 1, False — как 0
# Поэтому sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

В этом случае использование sum() для списка булевых значений — распространённый идиоматичный приём в Python, который широко понимают. Намерение — посчитать, сколько условий истинны — ясно из контекста.

7.6.3) Булевы значения в преобразовании типов

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

python

# boolean_conversion.py
# Преобразование булевых значений в целые (излишне)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# Но преобразование целых чисел в булевы значения полезно
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

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

7.6.4) Историческая причина

Причина, по которой булевы значения являются целыми в Python, историческая. Ранние версии Python (до версии 2.3) не имели отдельного булева типа. Программисты использовали 1 для true и 0 для false. Когда тип bool был добавлен, его сделали подклассом int, чтобы сохранить обратную совместимость с существующим кодом.

Сегодня вам следует воспринимать True и False в первую очередь как булевы значения. Их связь с 1 и 0 — это деталь реализации, о которой вам редко придётся задумываться, за исключением случаев, когда вы сталкиваетесь с ней в неожиданных ситуациях.

7.7) Использование in и not in в условиях

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

7.7.1) Проверка вхождения в строки

Оператор in проверяет, содержится ли одна строка внутри другой строки:

python

# string_membership.py
# Проверка, содержится ли подстрока в строке
text = "Python programming is fun"
 
# Использование 'in' для проверки подстрок
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# Сопоставление с учётом регистра
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# Использование 'not in' для проверки отсутствия
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

Оператор in выполняет поиск с учётом регистра. Если вам нужна проверка без учёта регистра, вы можете привести обе строки к одному регистру:

python

# case_insensitive_search.py
text = "Python Programming"
 
# Чувствительный к регистру поиск (не находит совпадение)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# Поиск без учёта регистра (приводим обе к нижнему регистру)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# Исходная строка не меняется
print("Original text:", text)  # Output: Original text: Python Programming

7.7.2) Проверка вхождения в списки

Оператор in также работает со списками (подробно о них мы узнаем в главе 14):

python

# list_membership.py
# Проверка, содержится ли значение в списке
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# Использование 'not in'
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# Работает со строками в списках
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

7.7.3) Проверка принадлежности с диапазонами

Вы также можете использовать in с объектами диапазона (о них мы узнаем в главе 12):

python

# range_membership.py
# Проверка, входит ли число в диапазон
age = 25
 
# Использование 'in' с range
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# Тем не менее, операторы сравнения более эффективны для числовых диапазонов
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' с range удобно для конкретных последовательностей
valid_ages = range(18, 66)  # Трудоспособный возраст
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

7.7.4) Оператор not in

Оператор not in является противоположностью in — он возвращает True, если значение НЕ найдено в коллекции:

python

# not_in_operator.py
# Использование 'not in' для более понятной логики
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# Использование 'not in' более читаемо
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# Проверка отсутствующих обязательных полей
provided_fields = ["name", "email"]
 
# Поиск отсутствующих полей
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True

Операторы in и not in делают ваши условия более читаемыми и выразительными. Вместо того чтобы писать сложные сравнения, вы можете напрямую выразить «находится ли это значение в этой коллекции?», что соответствует тому, как вы думаете о задаче.

В этой главе вы изучили основы булевых значений и условий в Python. Теперь вы понимаете:

Булевы значения True и False и их роль в принятии решений
Операторы сравнения (==, !=, <, >, <=, >=) для создания условий
Функцию bool() для преобразования значений в булев тип
Истинность и ложность — как Python рассматривает все значения как истинные или ложные
Составные сравнения для наглядной проверки диапазонов
Типичные ловушки, которых следует избегать при работе с булевыми значениями
Связь между булевыми значениями и целыми числами (и почему следует избегать арифметики с булевыми значениями)
Проверку принадлежности с помощью операторов in и not in

Эти концепции образуют фундамент для конструкций управления потоком выполнения, о которых вы узнаете в следующих главах. В главе 8 вы будете использовать булевы выражения в операторах if, чтобы ваши программы реагировали на разные условия. В главе 9 вы научитесь объединять несколько условий с помощью логических операторов and, or и not. А в главах 10 и 11 вы будете использовать условия для управления циклами, которые повторяют действия.

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