7. 布尔值与条件

# 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'>

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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
 
# 它等价于组合两个比较
# （我们会在第 9 章学习 'and'）
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

# 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

# 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

# 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，但并不完全等于 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)

# 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

# boolean_arithmetic_problems.py
# 令人困惑的代码示例
count = 0
has_error = True
has_warning = False
 
# 这段代码虽然能运行，但非常令人困惑
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# 这到底是什么意思？并不直观！
# 更好的做法是：显式表达意图
# 我们会在第 10 章学习 if-else 表达式。
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

# 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

# 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

# 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

# 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

# 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

# range_membership.py
# 检查数字是否在某个 range 中
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

# 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