Python: 运算符全览

print(4 / 2)    # 输出 2.0，而不是 2

print(7 // 3)     # 输出 2（7 ÷ 3 = 2.333，取整 = 2）
print(-7 // 3)    # 输出 -3 ← 可能和你想的不一样

# 英寸转厘米：1 inch = 2.54 cm

# 一个标准尺子的长度
inches = 12

# 用乘法做转换
cm = inches * 2.54

# 输出结果（自动发现 cm 是浮点数）
print(f"{inches} 英寸 = {cm} 厘米")

# 反过来算：厘米 → 英寸（用除法）
cm_value = 30
inches_value = cm_value / 2.54
print(f"{cm_value} 厘米 = {inches_value:.2f} 英寸")

# 试试取余和整除——12 英寸里有多少个 5 英寸？
count = 12 // 5   # 整除：2 个
remainder = 12 % 5  # 取余：剩下 2 英寸
print(f"12 英寸可以分成 {count} 个 5 英寸，还多 {remainder} 英寸")

12 英寸 = 30.48 厘米
30 厘米 = 11.81 英寸
12 英寸可以分成 2 个 5 英寸，还多 2 英寸

age = 18
print(age == 18)     # True（刚好18岁）
print(age != 18)     # False（并不是"不等于18"）
print(age > 21)      # False（还没到美国合法饮酒年龄）
print(age >= 18)     # True（恰好成年，符合大于等于的条件）

x = 15
print(10 < x < 20)   # True（相当于 10 < x and x < 20）
print(0 < x < 10)    # False

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)     # True（里面装的东西一样）
print(a is b)     # False（但不是同一个盒子）
print(a is c)     # True（c 只是 a 的别名，指向同一个盒子）

# 百米赛跑的分组规则
# 年龄 12~15 岁 → 少年组
# 年龄 16~20 岁 → 青年组

participant_age = 14

# 用比较运算符判断属于哪个组
is_teen_group = 12 <= participant_age <= 15    # 链式比较
is_youth_group = participant_age >= 16 and participant_age <= 20

print(f"参赛者年龄：{participant_age}")
print(f"少年组（12~15）：{is_teen_group}")
print(f"青年组（16~20）：{is_youth_group}")

# == 和 != 的用法
age_verified = True
print(f"年龄已验证：{age_verified == True}")
print(f"年龄未验证：{age_verified != True}")

参赛者年龄：14
少年组（12~15）：True
青年组（16~20）：False
年龄已验证：True
年龄未验证：False

age = 20
has_id_card = True

# and：两个条件都满足
print(age >= 18 and has_id_card)   # True（既成年又有身份证）

# or：至少满足一个
print(age >= 18 or has_id_card)    # True（其实两个都满足）

# not：取反
print(not has_id_card)             # False（not True = False）

# 对于 and：如果左边已经是 False，右边就不执行了
def say_yes():
    print("say_yes 被调用了")
    return True

print(False and say_yes())   # 输出 False——say_yes 根本没被执行
print(True and say_yes())    # 输出 "say_yes 被调用了" 和 True

# 对于 or：如果左边已经是 True，右边就不执行了
print(True or say_yes())     # 输出 True——say_yes 没被执行

# 只有用户存在时，才获取他的用户名——避免 None.get() 报错
user = None
username = user and user.get("name")   # user 是 None（假值），短路，username = None
print(username)                        # None

user = {"name": "Charlie"}
username = user and user.get("name")   # user 是真值，继续执行右边，username = "Charlie"
print(username)                        # Charlie

# 判断一个数字是不是"特殊数字"
# 定义：在 10~99 之间，并且是 7 的倍数或者包含数字 7

num = 49

# 条件1：在 10~99 之间（链式比较）
in_range = 10 <= num <= 99

# 条件2：是 7 的倍数（取余 + 比较）
multiple_of_7 = num % 7 == 0

# 条件3：包含数字 7（简单判断——十位是7或个位是7）
tens_digit = num // 10    # 提取十位
ones_digit = num % 10     # 提取个位
contains_7 = (tens_digit == 7) or (ones_digit == 7)

# 用逻辑运算符组合所有条件
is_special = in_range and (multiple_of_7 or contains_7)

print(f"数字：{num}")
print(f"在范围内（10~99）：{in_range}")
print(f"是7的倍数：{multiple_of_7}")
print(f"包含数字7：{contains_7}")
print(f"是否特殊数字：{is_special}")     # True——49是7的倍数

# 再用短路求值验证——如果第一个条件不满足，后面的根本不会执行
num2 = 200  # 不在范围内
is_special2 = (10 <= num2 <= 99) and (num2 % 7 == 0)
print(f"\n数字 {num2}：第一个条件就是 False，第二个条件不会执行——{is_special2}")

数字：49
在范围内（10~99）：True
是7的倍数：True
包含数字7：False
是否特殊数字：True

数字 200：第一个条件就是 False，第二个条件不会执行——False

x = 10         # 基本赋值
x += 3         # 等价于 x = x + 3，结果是 13
x -= 2         # 等价于 x = x - 2，结果是 11
x *= 2         # 等价于 x = x * 2，结果是 22
x /= 4         # 等价于 x = x / 4，结果是 5.5
x //= 2        # 等价于 x = x // 2，结果是 2.0
x %= 2         # 等价于 x = x % 2，结果是 0.0
x **= 3        # 等价于 x = x ** 3，结果是 0.0

# 自增在循环中的典型用法
score = 0
score += 10      # 加 10 分
score += 20      # 再加 20 分
score += 15      # 再加 15 分
print(f"最终得分：{score}")   # 45

# 字符串也可以用复合赋值
message = "Hello"
message += " "   # 加一个空格
message += "World"
print(message)               # "Hello World"

# 字符串拼接
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(full_name)              # 输出 "Alice"

# 字符串重复——画分割线非常实用
line = "=" * 30
print(line)                   # 输出 30 个等号

# 成员判断（in / not in）
text = "Hello, Python!"
print("Python" in text)       # True——"Python" 是 text 的一部分
print("Java" in text)         # False——text 里没有 "Java"
print("Java" not in text)     # True——确实是"不在里面"

# 用字符串运算生成一张简单的名片

name = "李明"
title = "Python 工程师"
company = "科技有限公司"

# 用 + 拼接名片内容
card_line1 = "姓名：" + name
card_line2 = "职位：" + title
card_line3 = "公司：" + company

# 用 * 生成分割线
separator = "-" * 25

# 组合成完整名片
business_card = separator + "\n" + card_line1 + "\n" + card_line2 + "\n" + card_line3 + "\n" + separator

print("生成的名片：")
print(business_card)

# 用 in 检查是否包含特定信息
search_term = "Python"
print(f'\n名片中是否包含 "{search_term}"：{search_term in business_card}')

# 用 not in 排除某些信息
print(f'名片中不包含 "Manager"：{"Manager" not in business_card}')

生成的名片：
-------------------------
姓名：李明
职位：Python 工程师
公司：科技有限公司
-------------------------

名片中是否包含 "Python"：True
名片中不包含 "Manager"：True

# 先乘除后加减
result = 2 + 3 * 4
print(result)                # 14（3*4=12，再+2）

# 比较优先级低于算术——先算完算术再比较
print(2 + 3 * 4 > 10)        # True（14 > 10）

# 逻辑优先级最低——先做比较，再组合逻辑
age = 20
print(age > 18 and age < 60)  # True（先算 age>18 和 age<60，再做 and）

# 幂运算是右结合
print(2 ** 3 ** 2)            # 512（先算 3²=9，再算 2⁹=512）
print((2 ** 3) ** 2)          # 64（加了括号，先算 2³=8，再算 8²=64）

# 括号改变优先级——跟数学一样
result = (2 + 3) * 4
print(result)                 # 20（先算括号内的 2+3=5，再×4）

# 计算房贷月供（等额本息）
# 公式：月供 = 贷款总额 × 月利率 × (1 + 月利率)^还款月数 ÷ [(1 + 月利率)^还款月数 - 1]

# 假设贷款 100 万，年利率 4.5%，贷 30 年
loan_amount = 1_000_000    # 贷款总额（用下划线分隔数字，Python 3.6+ 支持，不影响计算）
annual_rate = 0.045        # 年利率
years = 30
months = years * 12        # 还款月数
monthly_rate = annual_rate / 12   # 月利率

# 一步步拆开算——先算最复杂的部分
rate_power = (1 + monthly_rate) ** months         # (1 + 月利率)^还款月数
numerator = loan_amount * monthly_rate * rate_power   # 分子
denominator = rate_power - 1                          # 分母

monthly_payment = numerator / denominator

print(f"贷款金额：{loan_amount:,} 元")
print(f"年利率：{annual_rate * 100}%")
print(f"贷款年限：{years} 年")
print(f"每月还款：{monthly_payment:.2f} 元")
print(f"总还款额：{monthly_payment * months:,.2f} 元")
print(f"利息总额：{monthly_payment * months - loan_amount:,.2f} 元")

贷款金额：1,000,000 元
年利率：4.5%
贷款年限：30 年
每月还款：5,066.85 元
总还款额：1,824,066.95 元
利息总额：824,066.95 元

print(0.1 + 0.2)                     # 输出 0.30000000000000004
print(0.3)                           # 输出 0.3
print(0.1 + 0.2 == 0.3)              # 输出 False ← 这竟然不是相等的！

# 正确的浮点数比较方式
result = 0.1 + 0.2
epsilon = 1e-10     # 一个非常小的数，相当于 0.0000000001
print(abs(result - 0.3) < epsilon)   # 输出 True

print(f"{0.1 + 0.2:.2f}")   # 输出 0.30

# 一个实际例子：累加 0.1 十次
total = 0.0
for i in range(10):
    total += 0.1
print(f"累加结果：{total}")          # 0.9999999999999999
print(f"精确值：{total == 1.0}")      # False
print(f"格式化后：{total:.2f}")       # 1.00——显示没问题，别担心

# int → float
print(float(3))             # 输出 3.0

# float → int（直接截断小数部分，不是四舍五入）
print(int(3.14))            # 输出 3
print(int(-2.8))            # 输出 -2（向零取整）

# 字符串 → 数字（前提是字符串里确实是个数字）
print(int("42"))            # 输出 42
print(float("3.14"))        # 输出 3.14

# 数字 → 字符串
print(str(3.14))            # 输出 "3.14"

# int() 还可以指定进制
print(int("FF", 16))        # 输出 255（把十六进制的 FF 转成十进制）
print(int("1010", 2))       # 输出 10（把二进制的 1010 转成十进制）

# 模拟用户输入（实际用 input()，这里用变量模拟）
user_input = "25"       # 注意：这是字符串，不是数字

# 不转换就做加法会怎样？
# print(user_input + 5)  ← 去掉注释会报错：不能把字符串和数字相加

# 正确做法：先用 int() 转换
age = int(user_input)

# 现在可以正常做算术了
age_next_year = age + 1
print(f"你输入了：{user_input}（类型：{type(user_input)}）")
print(f"转换后：{age}（类型：{type(age)}）")
print(f"明年你就 {age_next_year} 岁了")

# 反过来：把计算结果转回字符串，准备输出
output_message = "你已经 " + str(age) + " 岁了"
print(output_message)

你输入了：25（类型：<class 'str'>）
转换后：25（类型：<class 'int'>）
明年你就 26 岁了
你已经 25 岁了