Python条件判断语句的种类及使用详解

# 基本 if 语句
age = 18
if age >= 18:
    print("你已经成年了")
    print("可以投票了")
 
# if-else 语句
temperature = 25
if temperature > 30:
    print("天气很热")
else:
    print("天气适中")
 
# if-elif-else 多分支判断
score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"
print(f"成绩等级: {grade}")

# 正确的缩进
if True:
    print("这一行属于 if 代码块")
    print("这一行也属于 if 代码块")
print("这一行不属于 if 代码块")
 
# 错误的缩进会导致 IndentationError
# if True:
# print("缩进错误")

# 传统写法
if x > y:
    max_value = x
else:
    max_value = y
 
# 条件表达式写法
max_value = x if x > y else y
 
# 更多实用示例
status = "在线" if is_connected else "离线"
message = "通过" if score >= 60 else "未通过"
result = "偶数" if number % 2 == 0 else "奇数"
 
# 嵌套条件表达式（谨慎使用）
value = "A" if score >= 90 else "B" if score >= 80 else "C"

# 好的实践 - 简单明了
def get_discount_rate(vip_level):
    return 0.9 if vip_level == "gold" else 0.95 if vip_level == "silver" else 1.0
 
# 避免过度嵌套 - 可读性差
# price = base_price * 0.9 if member else base_price * 0.95 if student else base_price
 
# 更好的替代方案
def calculate_price(base_price, member=False, student=False):
    if member:
        return base_price * 0.9
    elif student:
        return base_price * 0.95
    return base_price

# 基本用法
age = 25
income = 50000
if age >= 18 and income >= 30000:
    print("符合贷款条件")
 
# 链式使用
if x > 0 and y > 0 and z > 0:
    print("所有坐标都为正")
 
# 短路特性
def check_division(x, y):
    # 如果 y 为 0，不会执行 x/y
    if y != 0 and x/y > 2:
        return True
    return False

# 基本用法
weekend = True
holiday = False
if weekend or holiday:
    print("今天可以休息")
 
# 默认值设置
def get_config_value(key, default=None):
    return config.get(key) or default or "未设置"
 
# 多条件判断
if status == "error" or status == "failed" or status == "exception":
    print("操作失败")

# 基本用法
is_empty = False
if not is_empty:
    print("列表不为空")
 
# 与 in 运算符结合
if "admin" not in username:
    print("非管理员用户")
 
# 复杂条件简化
if not (age < 18 or status != "active"):
    print("用户符合要求")

# 优先级：not > and > or
# 建议使用括号提高可读性
if (age >= 18 and has_id) or (parent_consent and age >= 16):
    print("可以注册")
 
# 复杂条件示例
def can_access_resource(user, resource):
    return (user.is_authenticated and 
            (user.has_permission(resource) or 
             user.is_admin or
             (resource.is_public and not resource.is_restricted)))

# 列表成员检测
fruits = ["apple", "banana", "orange"]
if "apple" in fruits:
    print("有苹果")
 
# 字符串子串检测
email = "user@example.com"
if "@" in email and "." in email:
    print"有效的邮箱格式")
 
# 字典键检测
user_scores = {"张三": 90, "李四": 85}
if "张三" in user_scores:
    print(f"张三的成绩：{user_scores['张三']}")
 
# 范围检测
if 1 <= month <= 12:
    print("有效的月份")

# 身份检测 - 比较对象身份
a = [1, 2, 3]
b = a
c = [1, 2, 3]
 
if a is b:
    print("a 和 b 是同一个对象")  # 会执行
 
if a is c:
    print("a 和 c 是同一个对象")  # 不会执行
 
if a == c:
    print("a 和 c 的值相等")  # 会执行
 
# None 检测（推荐使用 is）
def process_data(data):
    if data is None:
        return "无数据"
    return f"处理 {len(data)} 条数据"

# 不好的做法 - 深层嵌套
if user:
    if user.is_active:
        if user.has_permission:
            if not user.is_banned:
                process_user(user)
 
# 好的做法 - 提前返回
def process_user_safe(user):
    if not user:
        return "用户不存在"
    
    if not user.is_active:
        return "用户未激活"
    
    if not user.has_permission:
        return "权限不足"
    
    if user.is_banned:
        return "用户被封禁"
    
    return process_user(user)

# 卫语句让代码更扁平
def calculate_shipping(order):
    # 前置条件检查
    if not order.items:
        return 0
    
    if order.total_weight <= 0:
        return 0
    
    if order.destination is None:
        raise ValueError("目的地不能为空")
    
    # 主要逻辑
    base_rate = get_base_rate(order.destination)
    weight_factor = calculate_weight_factor(order.total_weight)
    
    return base_rate * weight_factor

# 直接检查布尔值，不需要 == True
if is_valid:  # 好
    pass
 
if is_valid == True:  # 不好
    pass
 
# 检查空值
if items:  # 好 - 自动检查是否为空
    pass
 
if len(items) > 0:  # 冗余
    pass
 
# 检查 None
if data is None:  # 好
    pass
 
if data == None:  # 不好
    pass

# 复杂条件
def can_access_premium_content(user, content):
    return (user.is_premium and 
            user.subscription_active and 
            content.premium_only and 
            user.region in content.allowed_regions)
 
# 分解为更清晰的函数
def can_access_premium_content(user, content):
    if not user.is_premium:
        return False
    
    if not user.subscription_active:
        return False
    
    if not content.premium_only:
        return True  # 非高级内容总是可以访问
    
    return user.region in content.allowed_regions
 
# 或者使用辅助函数
def has_active_premium_subscription(user):
    return user.is_premium and user.subscription_active
 
def is_content_available_in_region(content, region):
    return region in content.allowed_regions
 
def can_access_premium_content(user, content):
    if not has_active_premium_subscription(user):
        return False
    
    if content.premium_only:
        return is_content_available_in_region(content, user.region)
    
    return True

class PermissionChecker:
    def __init__(self, user):
        self.user = user
    
    def can_edit_post(self, post):
        """检查用户是否可以编辑帖子"""
        if not self.user.is_authenticated:
            return False
        
        if self.user.is_admin:
            return True
        
        if post.author == self.user:
            # 检查是否在编辑时间窗口内
            if post.created_within(hours=24):
                return True
            
            # 检查是否有特殊权限
            if self.user.has_permission("edit_old_posts"):
                return True
        
        return False
    
    def can_delete_comment(self, comment):
        """检查用户是否可以删除评论"""
        if not self.user.is_authenticated:
            return False
        
        # 管理员可以删除任何评论
        if self.user.is_admin:
            return True
        
        # 评论作者可以删除自己的评论
        if comment.author == self.user:
            return True
        
        # 帖子作者可以删除自己帖子下的评论
        if comment.post.author == self.user:
            return True
        
        return False

class DataValidator:
    @staticmethod
    def validate_email(email):
        """验证邮箱格式"""
        if not email:
            return False, "邮箱不能为空"
        
        if "@" not in email:
            return False, "邮箱必须包含 @ 符号"
        
        if email.count("@") != 1:
            return False, "邮箱只能包含一个 @ 符号"
        
        local_part, domain = email.split("@")
        
        if not local_part or not domain:
            return False, "邮箱的本地部分和域名都不能为空"
        
        if "." not in domain:
            return False, "邮箱域名必须包含点"
        
        if len(email) > 254:  # RFC 5321 规定
            return False, "邮箱长度不能超过 254 个字符"
        
        return True, "邮箱格式正确"
    
    @staticmethod
    def validate_password(password):
        """验证密码强度"""
        if not password:
            return False, "密码不能为空"
        
        if len(password) < 8:
            return False, "密码长度至少为 8 位"
        
        has_upper = any(c.isupper() for c in password)
        has_lower = any(c.islower() for c in password)
        has_digit = any(c.isdigit() for c in password)
        has_special = any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password)
        
        if not (has_upper and has_lower):
            return False, "密码必须包含大小写字母"
        
        if not has_digit:
            return False, "密码必须包含数字"
        
        if not has_special:
            return False, "密码必须包含特殊字符"
        
        return True, "密码强度合格"

class DiscountEngine:
    def __init__(self):
        self.rules = []
    
    def add_rule(self, condition, discount):
        """添加折扣规则"""
        self.rules.append((condition, discount))
    
    def calculate_discount(self, order):
        """计算订单折扣"""
        total_discount = 0
        
        for condition, discount in self.rules:
            if condition(order):
                total_discount += discount(order)
        
        return min(total_discount, order.total_amount * 0.5)  # 最多 50% 折扣
 
# 使用示例
def create_discount_engine():
    engine = DiscountEngine()
    
    # 新用户首单优惠
    engine.add_rule(
        lambda order: order.user.is_new_user and order.user.order_count == 0,
        lambda order: order.total_amount * 0.15
    )
    
    # 满减优惠
    engine.add_rule(
        lambda order: order.total_amount >= 200,
        lambda order: 20
    )
    
    # VIP 用户额外折扣
    engine.add_rule(
        lambda order: order.user.vip_level == "gold",
        lambda order: order.total_amount * 0.1
    )
    
    # 节假日特殊优惠
    engine.add_rule(
        lambda order: is_holiday(order.order_date),
        lambda order: order.total_amount * 0.05
    )
    
    return engine

# 常见错误
x = 5
if x = 10:  # SyntaxError: invalid syntax
    print("x 是 10")
 
# 正确写法
if x == 10:
    print("x 是 10")
 
# Python 允许的链式比较
if 0 < x < 10:  # 检查 x 是否在 0 和 10 之间
    print("x 在 0 和 10 之间")

# 错误的做法
def add_item(item, list=[]):  # 危险！
    list.append(item)
    return list
 
# 正确的做法
def add_item(item, list=None):
    if list is None:
        list = []
    list.append(item)
    return list

import math
 
# 错误的做法
if 0.1 + 0.2 == 0.3:  # False!
    print("相等")
 
# 正确的做法 - 使用容差
if abs(0.1 + 0.2 - 0.3) < 1e-10:
    print("在容差范围内相等")
 
# 或者使用 math.isclose
if math.isclose(0.1 + 0.2, 0.3):
    print("math.isclose 认为相等")

# 使用断言调试
def complex_condition(a, b, c):
    result = (a > 0 and b > 0) or (c < 0 and not a == b)
    
    # 添加调试信息
    print(f"a={a}, b={b}, c={c}")
    print(f"a>0: {a>0}, b>0: {b>0}")
    print(f"c<0: {c<0}, a==b: {a==b}")
    print(f"not a==b: {not a==b}")
    print(f"最终结果: {result}")
    
    return result
 
# 使用日志记录
import logging
 
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
 
def validate_input(data):
    logger.debug(f"验证输入数据: {data}")
    
    if not data:
        logger.warning("输入数据为空")
        return False
    
    if not isinstance(data, dict):
        logger.error(f"期望字典类型，得到 {type(data)}")
        return False
    
    required_fields = ["name", "email", "age"]
    missing_fields = [field for field in required_fields if field not in data]
    
    if missing_fields:
        logger.error(f"缺少必填字段: {missing_fields}")
        return False
    
    logger.info("输入数据验证通过")
    return True

# 利用 and 的短路特性
expensive_result = expensive_computation()
if condition and expensive_result:
    # 如果 condition 为 False，不会执行 expensive_computation
    pass
 
# 更高效的写法
def get_expensive_result():
    print("执行耗时计算...")
    return expensive_computation()
 
if condition and get_expensive_result():
    pass
 
# 利用 or 的短路特性提供默认值
def get_user_preference(user_id):
    # 如果缓存中有，直接返回；否则查询数据库
    return (cache.get(f"user_pref_{user_id}") or 
            database.get_user_preference(user_id) or 
            get_default_preference())

# 将最可能发生的条件放在前面
if status == "success":  # 假设 80% 的情况是 success
    handle_success()
elif status == "pending":  # 15% 的情况
    handle_pending()
elif status == "failed":  # 5% 的情况
    handle_failed()
 
# 使用字典替代多重 if-elif
status_handlers = {
    "success": handle_success,
    "pending": handle_pending,
    "failed": handle_failed,
    "cancelled": handle_cancelled
}
 
handler = status_handlers.get(status, handle_unknown)
handler()
 
# 使用 any/all 处理集合条件
def has_any_permission(user, permissions):
    return any(user.has_permission(p) for p in permissions)
 
def has_all_permissions(user, permissions):
    return all(user.has_permission(p) for p in permissions)

# 字符串比较优化
# 不好的做法
if user_input.lower() == "yes" or user_input.lower() == "y":
    pass
 
# 好的做法
if user_input.lower() in ("yes", "y"):
    pass
 
# 列表非空检查
# 不好的做法
if len(my_list) != 0:
    pass
 
# 好的做法
if my_list:  # 更 Pythonic
    pass
 
# 字典 get 方法的使用
# 传统做法
if key in my_dict:
    value = my_dict[key]
else:
    value = default_value
 
# 更好的做法
value = my_dict.get(key, default_value)

# 输入部分条件，TRAE IDE 会智能补全
if user.is_  # TRAE IDE 提示: authenticated, active, admin...
 
# 根据上下文推荐合适的条件判断
# 当你处理用户输入时，TRAE IDE 会推荐：
if not user_input:  # 推荐先检查空值
    return "输入不能为空"
 
if len(user_input) < min_length:  # 推荐长度检查
    return f"输入长度至少为 {min_length}"

# TRAE IDE 会实时高亮潜在问题
def check_conditions(a, b, c):
    if a and b or c:  # TRAE IDE 警告：考虑添加括号明确优先级
        pass
    
    if x < y < z:  # TRAE IDE 提示：这是链式比较，不是 x < y and y < z
        pass
    
    if items == []:  # TRAE IDE 建议：使用 if not items:
        pass

# TRAE IDE 会建议将复杂条件提取为函数
# 重构前
if (user.is_authenticated and user.has_paid and 
    not user.is_suspended and user.role in ["admin", "moderator"]):
    allow_access()
 
# TRAE IDE 重构建议
if user_can_access_admin_panel(user):
    allow_access()
 
def user_can_access_admin_panel(user):
    return (user.is_authenticated and user.has_paid and 
            not user.is_suspended and user.role in ["admin", "moderator"])