Python基础指南之三元表达式简化if-else的完整教学

# 这种代码你每天写多少遍？
if score >= 60:
    result = "及格"
else:
    result = "不及格"

if is_admin:
    redirect_url = "/admin"
else:
    redirect_url = "/home"

# 一行搞定！
result = "及格" if score >= 60 else "不及格"
redirect_url = "/admin" if is_admin else "/home"

# Python三元表达式的语法（注意：和其他语言不同！）
# value_if_true if condition else value_if_false

# 对应的if-else：
# if condition:
#     result = value_if_true
# else:
#     result = value_if_false

# 基础示例
age = 20
status = "成年" if age >= 18 else "未成年"
print(status)    # 成年

score = 55
result = "通过" if score >= 60 else "不通过"
print(result)    # 不通过

# 其他语言（C/Java/JavaScript）的写法：
# result = condition ? value_if_true : value_if_false

# Python的写法：
# result = value_if_true if condition else value_if_false

# Python把"条件"放在中间，前面是"真的值"，后面是"假的值"
# 读起来更自然：
# "给result赋值为'及格'，如果score>=60，否则赋值为'不及格'"
result = "及格" if score >= 60 else "不及格"

# 这种设计让代码更接近自然语言的顺序

# 三元表达式也有短路求值特性
# 条件为True时：计算value_if_true，不计算value_if_false
# 条件为False时：计算value_if_false，不计算value_if_true

def get_expensive_value():
    print("  计算了昂贵的值")
    return "昂贵的结果"

def get_default_value():
    print("  计算了默认值")
    return "默认结果"

# 条件为True：不会计算get_default_value()
print("x > 0 时：")
result = get_expensive_value() if True else get_default_value()
print(f"  结果: {result}")

# 条件为False：不会计算get_expensive_value()
print("\nx < 0 时：")
result = get_expensive_value() if False else get_default_value()
print(f"  结果: {result}")

# 这与and/or的短路特性一致，可以安全使用
user_input = ""
name = user_input if user_input else "匿名用户"  # 默认值

# 1. 根据条件选择值
discount = 0.8 if is_vip else 1.0
shipping_fee = 0 if total >= 99 else 10

# 2. 处理None
username = user.get("name") if user else "游客"

# 3. 根据计算结果选择
result = "偶数" if n % 2 == 0 else "奇数"

# 4. 根据存在性选择
first_item = items[0] if items else None

# 5. 根据类型选择
value = int(user_input) if user_input.isdigit() else 0

# 直接在三元表达式中作为参数
def send_message(content, priority="normal"):
    print(f"[{priority}] {content}")

is_urgent = True
send_message("服务器宕机！", priority="urgent" if is_urgent else "normal")

# 计算修饰过的参数
items = ["apple", "banana", "orange", "grape"]
max_items = 3
display_items = items[:max_items] if len(items) > max_items else items

# 作为sorted的key
data = [3, -1, 5, -2, 4]
# 负数排在正数后面
sorted_data = sorted(data, key=lambda x: (0 if x > 0 else 1, x))
print(sorted_data)  # [3, 4, 5, -2, -1]

# 在列表推导式中使用三元表达式
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
labels = ["偶数" if n % 2 == 0 else "奇数" for n in numbers]
print(labels)
# ['奇数', '偶数', '奇数', '偶数', '奇数', '偶数', '奇数', '偶数', '奇数', '偶数']

# 结合过滤和转换
scores = [85, 45, 92, 30, 78, 55, 95]
# 只保留及格分数，并转换为"及格/不及格"
graded = ["及格" if s >= 60 else "不及格" for s in scores if s > 0]
print(graded)

# 数据清洗与转换
raw_data = ["123", "abc", "456", "", "789", "xyz"]
cleaned = [int(x) if x.isdigit() else 0 for x in raw_data]
print(cleaned)  # [123, 0, 456, 0, 789, 0]

# 注意：列表推导式中三元表达式的顺序
# [true_value if condition else false_value for item in iterable]
#         ↑ 三元表达式部分 ↑        ↑ for循环部分 ↑

# 构建字典时
config = {
    "host": "0.0.0.0",
    "port": 443 if use_https else 80,
    "debug": True if env == "development" else False,
}

# 字典推导式
numbers = range(10)
parity = {n: "偶数" if n % 2 == 0 else "奇数" for n in numbers}
print(parity)
# {0: '偶数', 1: '奇数', 2: '偶数', ...}

# 集合推导式
values = [1, 2, 3, 4, 5, 6]
modified = {x * 2 if x % 2 == 0 else x * 3 for x in values}
print(modified)  # {3, 4, 9, 8, 15, 12}

# 在f-string中使用三元表达式
name = "张三"
is_vip = True
print(f"欢迎{name}！您是{'VIP会员' if is_vip else '普通用户'}")

score = 85
print(f"成绩: {score} ({'优秀' if score >= 90 else '良好' if score >= 80 else '一般'})")

# ⚠️ f-string中的三元表达式要用引号区别
# f-string外部用双引号时，内部用单引号，反之亦然

# 三元表达式可以嵌套，但要非常小心可读性
# 语法：a if cond1 else b if cond2 else c if cond3 else d

score = 85
grade = "优秀" if score >= 90 else "良好" if score >= 80 else "中等" if score >= 70 else "及格" if score >= 60 else "不及格"
print(grade)    # 良好

# 上面的嵌套等价于：
# if score >= 90:
#     grade = "优秀"
# elif score >= 80:
#     grade = "良好"
# elif score >= 70:
#     grade = "中等"
# elif score >= 60:
#     grade = "及格"
# else:
#     grade = "不及格"

# ⚠️ 嵌套三元表达式的阅读顺序
# a if cond1 else b if cond2 else c
# 等价于：
# a if cond1 else (b if cond2 else c)
# 三元表达式是右结合的

# ✅ 可以接受：2层嵌套
label = "高温" if temp > 35 else "适中" if temp > 15 else "低温"

# ⚠️ 需要慎重：3层嵌套
category = "超大型" if size > 1000 else "大型" if size > 100 else "中型" if size > 10 else "小型"

# ❌ 不可接受：4层以上
# 这种情况下应该使用 if-elif-else 或字典映射
# result = a if c1 else b if c2 else c if c3 else d if c4 else e

# 💡 一个判断标准：
# 如果嵌套三元表达式超过一行（79字符），就该改用if-elif-else

# 如果必须使用嵌套三元，至少格式化好
# 方式1：多行缩进
grade = (
    "优秀" if score >= 90
    else "良好" if score >= 80
    else "中等" if score >= 70
    else "及格" if score >= 60
    else "不及格"
)

# 方式2：对齐条件（更容易看清逻辑）
grade = ("优秀" if score >= 90 else
         "良好" if score >= 80 else
         "中等" if score >= 70 else
         "及格" if score >= 60 else
         "不及格")

# 但即使格式化了，对于这么长的链，if-elif-else仍然更清晰

# 方式1：三元表达式（推荐用于值选择）
result = a if condition else b

# 方式2：逻辑运算符（老式Python风格，不推荐）
result = condition and a or b
# ⚠️ 有bug！当a为假值（如0、""、[]）时，即使condition为True，也会返回b！

# 验证bug
a = 0      # 假值
b = 10
condition = True

print(condition and a or b)   # 10 —— 错误！condition为True但返回了b
print(a if condition else b)  # 0  —— 正确！

# 场景：提供默认值

# 方式1：三元表达式（精确—只有None才用默认值）
value = x if x is not None else default

# 方式2：or 运算符（简洁—但0、""、[]等也触发默认值）
value = x or default

# 方式3：Python 3.10+ 的 or 与 None 专用写法
# x ?? default  # 可惜Python没有这个运算符

# 选择指南
def get_limit(limit):
    # 如果0是合法的limit值，用三元表达式
    return limit if limit is not None else 100

def get_name(name):
    # 如果只需要处理空字符串和None，用or更简洁
    return name or "匿名用户"

# 三元表达式：适合简单的二选一赋值
status = "在线" if user.is_online else "离线"

# if-elif-else：适合多分支、需要执行多行代码
if user.is_banned:
    status = "已封禁"
    send_notification(user, "您的账号已被封禁")
elif not user.is_active:
    status = "未激活"
else:
    status = "正常"

# ⚠️ 三元表达式中不要放有副作用的操作
# ❌ 坏味道：三元表达式中调用print
result = print("True") if condition else print("False")

# ✅ 好：三元表达式只负责值的选择
print("True" if condition else "False")

# ❌ 另一个坏例子
# value = db.query() if use_cache else api.fetch()
# 如果两个操作有不同的副作用，三元表达式隐藏了重要逻辑

# ❌ 三元表达式中的条件太复杂
label = "通过✅" if (score >= 60 and not is_cheating and attempts <= 3 and 
                     (is_retake or is_first_attempt)) else "不通过❌"

# ✅ 把复杂条件提取为变量或函数
can_pass = (score >= 60 and not is_cheating and attempts <= 3 and 
            (is_retake or is_first_attempt))
label = "通过✅" if can_pass else "不通过❌"

# 有一种利用bool可做索引的"奇技淫巧"
# (false_value, true_value)[condition]

result = ("不及格", "及格")[score >= 60]

# ❌ 不要用！问题：
# 1. 两个值都会被计算（没有短路求值）
# 2. 可读性差
# 3. 容易搞错true_value和false_value的顺序

# 演示短路缺失的问题
def expensive_true():
    print("计算了expensive_true")
    return "真"

def expensive_false():
    print("计算了expensive_false")
    return "假"

# 元组方式：两个函数都执行了！
result = (expensive_false(), expensive_true())[True]

# 三元表达式：只执行需要的那个
result = expensive_true() if True else expensive_false()

# 不是所有的if-else都应该改成三元表达式

# ✅ 合适改：简单的值选择
color = "green" if status == "active" else "red"

# ❌ 不合适改：包含复杂逻辑
# 原本：
if user.is_premium:
    discount = calculate_premium_discount(cart, user)
else:
    discount = calculate_normal_discount(cart)

# 改成三元后难以阅读：
# discount = calculate_premium_discount(cart, user) if user.is_premium else calculate_normal_discount(cart)

class DataFormatter:
    """数据格式化器 —— 三元表达式的集中应用"""
    
    @staticmethod
    def format_amount(amount, currency="CNY"):
        """格式化金额"""
        symbol = "¥" if currency == "CNY" else "$" if currency == "USD" else "€"
        sign = "-" if amount < 0 else ""
        abs_amount = abs(amount)
        
        return f"{sign}{symbol}{abs_amount:,.2f}"
    
    @staticmethod
    def format_file_size(bytes_size):
        """格式化文件大小"""
        if bytes_size < 1024:
            return f"{bytes_size} B"
        
        kb = bytes_size / 1024
        if kb < 1024:
            return f"{kb:.1f} KB"
        
        mb = kb / 1024
        if mb < 1024:
            return f"{mb:.1f} MB"
        
        gb = mb / 1024
        return f"{gb:.2f} GB"
    
    @staticmethod
    def format_status(status):
        """格式化状态显示"""
        icon = "✅" if status == "success" else "❌" if status == "fail" else "⏳"
        color = "green" if status == "success" else "red" if status == "fail" else "yellow"
        return f'<span style="color:{color}">{icon} {status}</span>'
    
    @staticmethod
    def format_date(date_obj, fmt=None):
        """格式化日期，提供智能默认"""
        fmt = fmt if fmt else (
            "%Y-%m-%d %H:%M" if date_obj.hour or date_obj.minute else "%Y-%m-%d"
        )
        return date_obj.strftime(fmt)

# 测试
fmt = DataFormatter()
print(fmt.format_amount(1234.5))            # ¥1,234.50
print(fmt.format_amount(-99.9, "USD"))      # -$99.90
print(fmt.format_file_size(1024000))        # 1000.0 KB
print(fmt.format_status("success"))         # <span style="color:green">✅ success</span>

import os

class ConfigManager:
    """配置管理器 —— 三元表达式处理默认值的典型应用"""
    
    DEFAULTS = {
        "host": "localhost",
        "port": 8080,
        "debug": False,
        "timeout": 30,
        "max_connections": 100,
        "log_level": "INFO",
    }
    
    def __init__(self):
        self._env_overrides = {}
        self._file_overrides = {}
        self._runtime_overrides = {}
    
    def get(self, key, default=None):
        """获取配置值，优先级：运行时 > 环境变量 > 文件 > 默认值"""
        # 三元表达式链清晰表达了优先级
        return (
            self._runtime_overrides[key] if key in self._runtime_overrides
            else self._env_overrides[key] if key in self._env_overrides
            else self._file_overrides[key] if key in self._file_overrides
            else self.DEFAULTS[key] if key in self.DEFAULTS
            else default
        )
    
    def get_int(self, key, default=0):
        value = self.get(key)
        return int(value) if value is not None and str(value).lstrip('-').isdigit() else default
    
    def get_bool(self, key, default=False):
        value = self.get(key)
        if isinstance(value, bool):
            return value
        return str(value).lower() in ("true", "1", "yes") if value is not None else default
    
    def load_from_env(self, prefix="APP_"):
        """从环境变量加载配置"""
        for key in self.DEFAULTS:
            env_key = f"{prefix}{key.upper()}"
            env_value = os.environ.get(env_key)
            if env_value is not None:
                self._env_overrides[key] = env_value

# 使用
config = ConfigManager()
print(f"host: {config.get('host')}")                # localhost
print(f"port: {config.get_int('port')}")            # 8080
print(f"debug: {config.get_bool('debug')}")         # False
print(f"unknown: {config.get('unknown', 'N/A')}")   # N/A