课程 5：Python语法

📝 命名规则

• 字符组成：只能包含字母、数字和下划线，不能以数字开头
• 大小写敏感：区分大小写，name 和 Name 是不同的变量
• 关键字限制：不能使用Python关键字（如 if、for、class 等）
• 命名风格：推荐使用 snake_case 风格，如 user_name、total_score
• 描述性：变量名应具有描述性，避免使用 a、b、temp 等无意义名称

🔢 基本数据类型

• 整数（int）：如 10、-5、1000
• 浮点数（float）：如 3.14、-2.5、1.0
• 字符串（str）：用引号包围，如 "Hello"、'Python'
• 布尔值（bool）：只有 True 和 False 两个值
• 列表（list）：有序可变序列，如 [1, 2, 3]、["a", "b"]

⚡ 动态类型特性

• 无需声明：变量无需预先声明类型
• 自动推断：类型由赋值内容自动推断
• 类型可变：变量可以随时赋予不同类型的值

📐 缩进规则

• 强制缩进：Python使用缩进表示代码块，不使用大括号
• 标准缩进：通常使用4个空格，也可使用Tab（但不推荐混用）
• 一致性：同一代码块内的缩进必须一致
• 嵌套缩进：嵌套代码块需要增加缩进级别
• 错误处理：缩进错误会导致 IndentationError

💬 注释类型

• 单行注释：以 # 开头，如 # 这是一个注释
• 多行注释：用三个单引号或双引号包裹，如 '''多行注释'''
• 文档字符串：函数或类的第一行字符串，用于说明功能
• 行尾注释：在代码行末尾添加注释，如 x = 5 # 设置初始值

⚠️ 常见错误类型

• NameError：变量未定义就使用
• IndentationError：缩进不一致或错误
• TypeError：类型不匹配的操作
• SyntaxError：语法错误
• ValueError：值错误

📝 语句（Statements）

语句是Python程序的基本执行单元，每条语句都会执行一个特定的操作。

• 赋值语句：variable = value - 将值赋给变量
• 表达式语句：print("Hello") - 执行表达式
• 条件语句：if condition: ... - 条件判断
• 循环语句：for item in items: ... - 循环执行
• 函数定义：def function_name(): ... - 定义函数
• 导入语句：import module - 导入模块

📊 完整优先级从高到低

1. 括号：() - 最高优先级
2. 索引、切片、调用：[], [:], ()
3. 属性访问：.
4. 幂运算：**
5. 一元运算符：+x, -x, ~x, not x
6. 乘除模：*, /, //, %
7. 加减：+, -
8. 位移：<<, >>
9. 按位与：&
10. 按位异或：^
11. 按位或：|
12. 比较：==, !=, >, <, >=, <=, is, is not, in, not in
13. 逻辑与：and
14. 逻辑或：or
15. 海象运算符：:=
16. 赋值：=, +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, <<=, >>= - 最低优先级

# 复杂表达式优先级示例
result = 2 + 3 * 4 ** 2 & 5 | 6
# 计算顺序：
# 1. 4 ** 2 = 16 (幂运算)
# 2. 3 * 16 = 48 (乘法)
# 3. 2 + 48 = 50 (加法)
# 4. 50 & 5 = 0 (按位与)
# 5. 0 | 6 = 6 (按位或)

# 使用括号改变优先级
result = (2 + 3) * (4 ** 2) & (5 | 6)
# 计算顺序：
# 1. 2 + 3 = 5 (括号内加法)
# 2. 4 ** 2 = 16 (括号内幂运算)
# 3. 5 | 6 = 7 (括号内按位或)
# 4. 5 * 16 = 80 (乘法)
# 5. 80 & 7 = 0 (按位与)

📝 表达式概述

表达式是Python程序的基本构建块，能够计算并返回一个值。表达式可以包含变量、常量、运算符、函数调用等元素。

🔢 表达式基本类型

表达式是能够计算并返回值的代码片段。

• 算术表达式：2 + 3 * 4 - 数学计算
• 比较表达式：x > 5 - 比较运算
• 逻辑表达式：a and b or c - 逻辑运算
• 函数调用：len("hello") - 函数调用
• 变量引用：variable_name - 变量访问

🔢 基本算术表达式

算术表达式用于数学计算，包含数字、变量和算术运算符。

# 基本算术表达式
a = 10
b = 3

# 加法表达式
sum_result = a + b                    # 13

# 减法表达式
diff_result = a - b                   # 7

# 乘法表达式
product = a * b                       # 30

# 除法表达式（浮点数）
quotient = a / b                      # 3.333...

# 整除表达式
floor_division = a // b               # 3

# 取余表达式
remainder = a % b                     # 1

# 幂运算表达式
power = a ** b                        # 1000

# 复杂算术表达式
complex_expr = (a + b) * 2 - (a / b)  # 使用括号控制优先级

# 数学函数表达式
import math
sqrt_expr = math.sqrt(a)              # 平方根
sin_expr = math.sin(math.pi / 2)      # 正弦函数
log_expr = math.log(a, 2)             # 对数

🔍 比较表达式

比较表达式用于比较两个值，返回布尔值（True或False）。

# 数值比较表达式
x = 10
y = 5

# 相等比较
is_equal = x == y                     # False

# 不等比较
is_not_equal = x != y                 # True

# 大于比较
is_greater = x > y                    # True

# 小于比较
is_less = x < y                       # False

# 大于等于比较
is_greater_equal = x >= y             # True

# 小于等于比较
is_less_equal = x <= y                # False

# 字符串比较表达式
name1 = "Alice"
name2 = "Bob"

# 字符串按字典序比较
name_compare = name1 < name2          # True ("Alice" < "Bob")

# 链式比较表达式
age = 25
is_adult = 18 <= age <= 65            # True (18 <= 25 <= 65)

# 复杂比较表达式
score = 85
is_passing = 60 <= score <= 100 and score != 0  # True

🧠 逻辑表达式

逻辑表达式使用逻辑运算符组合多个条件，返回布尔值。

# 基本逻辑表达式
a = True
b = False

# 逻辑与表达式
logical_and = a and b                 # False

# 逻辑或表达式
logical_or = a or b                   # True

# 逻辑非表达式
logical_not = not a                   # False

# 复杂逻辑表达式
age = 25
has_id = True
is_citizen = True

# 多重条件逻辑表达式
can_vote = age >= 18 and has_id and is_citizen  # True

# 短路求值示例
def expensive_function():
    print("执行昂贵操作")
    return True

# 由于短路求值，expensive_function不会被调用
result = False and expensive_function()  # False，不打印

# 条件逻辑表达式
is_student = True
has_scholarship = False

# 使用or的默认值模式
status = is_student or "非学生"        # True (短路求值)

# 使用and的条件执行
message = has_scholarship and "获得奖学金"  # False (短路求值)

🎯 条件表达式

条件表达式提供了一种简洁的方式来根据条件选择不同的值。

# 基本条件表达式
age = 20
status = "成年" if age >= 18 else "未成年"  # "成年"

# 嵌套条件表达式
score = 85
grade = "优秀" if score >= 90 else "良好" if score >= 80 else "及格" if score >= 60 else "不及格"

# 条件表达式与函数调用
def get_discount(is_member):
    return 0.1 if is_member else 0.0

discount = get_discount(True)  # 0.1

# 条件表达式与列表
numbers = [1, 2, 3, 4, 5]
filtered = [x if x > 2 else 0 for x in numbers]  # [0, 0, 3, 4, 5]

# 条件表达式与字符串格式化
name = "Alice"
greeting = f"你好，{name}！" if name else "你好，陌生人！"

# 条件表达式与类型检查
value = 42
result = "字符串" if isinstance(value, str) else "数字" if isinstance(value, (int, float)) else "其他类型"

# 条件表达式与异常处理
def safe_divide(a, b):
    return a / b if b != 0 else "除数不能为零"

# 条件表达式与字典
user_type = "admin"
permissions = {
    "admin": "完全权限",
    "user": "基本权限",
    "guest": "只读权限"
}
user_permission = permissions.get(user_type, "未知权限")

📞 函数调用表达式

函数调用表达式执行函数并返回结果，是表达式的重要组成部分。

# 基本函数调用表达式
def greet(name):
    return f"你好，{name}！"

# 函数调用表达式
message = greet("Alice")              # "你好，Alice！"

# 内置函数调用表达式
length = len("Python")                # 6
maximum = max(1, 2, 3, 4, 5)          # 5
minimum = min([10, 20, 30])           # 10
sum_result = sum([1, 2, 3, 4, 5])     # 15

# 方法调用表达式
text = "  Hello World  "
cleaned = text.strip()                # "Hello World"
upper_text = text.upper()             # "  HELLO WORLD  "
split_result = text.split()           # ['Hello', 'World']

# 链式函数调用表达式
result = "  hello world  ".strip().upper().replace("WORLD", "PYTHON")

# 函数调用作为参数
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

# 嵌套函数调用表达式
complex_result = multiply(add(2, 3), add(4, 1))  # 5 * 5 = 25

# 带关键字参数的函数调用
def create_user(name, age, email=None):
    return {"name": name, "age": age, "email": email}

user = create_user(name="Alice", age=25, email="alice@example.com")

# 解包参数的函数调用
def calculate_stats(*numbers):
    return {
        "sum": sum(numbers),
        "average": sum(numbers) / len(numbers),
        "count": len(numbers)
    }

stats = calculate_stats(1, 2, 3, 4, 5)

# 匿名函数（lambda）表达式
square = lambda x: x ** 2
square_result = square(5)             # 25

# 高阶函数调用表达式
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))  # [1, 4, 9, 16, 25]
filtered = list(filter(lambda x: x > 2, numbers))  # [3, 4, 5]

🔗 属性访问表达式

属性访问表达式用于访问对象的属性和方法。

# 对象属性访问表达式
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"你好，我是{self.name}"

# 创建对象
person = Person("Alice", 25)

# 属性访问表达式
name = person.name                     # "Alice"
age = person.age                       # 25

# 方法调用表达式
greeting = person.greet()              # "你好，我是Alice"

# 模块属性访问表达式
import math
pi_value = math.pi                     # 3.141592653589793
sqrt_func = math.sqrt                  # 

# 列表属性访问表达式
numbers = [1, 2, 3, 4, 5]
list_length = len(numbers)             # 5
first_element = numbers[0]             # 1

# 字典属性访问表达式
user_info = {"name": "Bob", "age": 30}
user_name = user_info["name"]          # "Bob"
user_age = user_info.get("age", 0)     # 30

# 字符串属性访问表达式
text = "Hello World"
text_length = len(text)                # 11
first_char = text[0]                   # "H"
last_char = text[-1]                   # "d"

# 嵌套属性访问表达式
class Address:
    def __init__(self, city, country):
        self.city = city
        self.country = country

class Employee:
    def __init__(self, name, address):
        self.name = name
        self.address = address

# 创建嵌套对象
address = Address("北京", "中国")
employee = Employee("张三", address)

# 嵌套属性访问
city = employee.address.city           # "北京"
country = employee.address.country     # "中国"

# 条件属性访问
def get_user_info(user):
    return user.name if hasattr(user, 'name') else "未知用户"

# 动态属性访问
attribute_name = "age"
age_value = getattr(person, attribute_name, 0)  # 25

📦 集合表达式

集合表达式用于创建和操作列表、元组、集合、字典等数据结构。

# 列表表达式
numbers = [1, 2, 3, 4, 5]             # 列表字面量
squares = [x**2 for x in numbers]     # 列表推导式
filtered = [x for x in numbers if x > 2]  # 条件列表推导式

# 元组表达式
coordinates = (10, 20)                # 元组字面量
point_3d = (x, y, z) = (1, 2, 3)     # 元组解包

# 集合表达式
unique_numbers = {1, 2, 2, 3, 3, 4}   # 集合字面量（自动去重）
squares_set = {x**2 for x in numbers} # 集合推导式

# 字典表达式
user_dict = {"name": "Alice", "age": 25}  # 字典字面量
squares_dict = {x: x**2 for x in numbers} # 字典推导式

# 生成器表达式
squares_gen = (x**2 for x in numbers) # 生成器表达式（惰性求值）

# 嵌套集合表达式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  # 二维列表
flattened = [item for row in matrix for item in row]  # 展平列表

# 条件集合表达式
even_squares = [x**2 for x in numbers if x % 2 == 0]  # 偶数的平方

# 集合操作表达式
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1 | set2                   # 并集
intersection = set1 & set2            # 交集
difference = set1 - set2              # 差集

# 字典合并表达式（Python 3.9+）
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged = dict1 | dict2                # 字典合并

# 切片表达式
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
first_three = numbers[:3]             # [0, 1, 2]
last_three = numbers[-3:]             # [7, 8, 9]
every_second = numbers[::2]           # [0, 2, 4, 6, 8]
reversed_list = numbers[::-1]         # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 字符串切片表达式
text = "Hello World"
first_word = text[:5]                 # "Hello"
last_word = text[6:]                  # "World"
reversed_text = text[::-1]            # "dlroW olleH"

⚖️ 表达式求值规则

理解表达式的求值规则对于编写正确的代码至关重要。

# 表达式求值示例

# 1. 括号优先
result1 = (2 + 3) * 4                 # 先计算括号：5 * 4 = 20
result2 = 2 + (3 * 4)                 # 先计算括号：2 + 12 = 14

# 2. 运算符优先级
result3 = 2 + 3 * 4                   # 先乘后加：2 + 12 = 14
result4 = 2 ** 3 + 1                  # 先幂后加：8 + 1 = 9

# 3. 左结合性
result5 = 10 - 3 - 2                  # 从左到右：(10 - 3) - 2 = 5
result6 = 2 ** 3 ** 2                 # 从右到左：2 ** (3 ** 2) = 512

# 4. 短路求值
def expensive_operation():
    print("执行昂贵操作")
    return True

# 由于短路求值，expensive_operation不会被调用
result7 = False and expensive_operation()  # False
result8 = True or expensive_operation()    # True

# 5. 复杂表达式求值
complex_expr = (2 + 3) * 4 ** 2 - 10 / 2
# 计算步骤：
# 1. (2 + 3) = 5
# 2. 4 ** 2 = 16
# 3. 5 * 16 = 80
# 4. 10 / 2 = 5
# 5. 80 - 5 = 75

# 6. 条件表达式求值
age = 25
status = "成年" if age >= 18 else "未成年"
# 求值步骤：
# 1. 计算条件：age >= 18 → True
# 2. 选择真值："成年"

# 7. 函数调用表达式求值
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

result9 = multiply(add(2, 3), add(4, 1))
# 求值步骤：
# 1. add(2, 3) = 5
# 2. add(4, 1) = 5
# 3. multiply(5, 5) = 25

✅ Python语法核心要点

• 简洁性：语法接近自然语言，代码可读性强
• 缩进：使用缩进表示代码块，通常4个空格
• 动态类型：无需声明变量类型，自动推断
• 命名规范：snake_case风格，描述性命名
• 注释：单行#，多行'''或"""
• 错误处理：清晰的错误信息，便于调试

⚠️ 常见陷阱与注意事项

• 缩进一致性：同一代码块内缩进必须一致
• 变量作用域：局部变量只在函数内有效
• 类型转换：input()返回字符串，需要手动转换
• 命名冲突：避免与内置函数同名
• 编码规范：遵循PEP 8编码规范

🔢 表达式要点总结

• 表达式类型：算术、比较、逻辑、条件、函数调用、属性访问、集合表达式
• 求值顺序：括号优先 → 运算符优先级 → 左结合性 → 短路求值
• 条件表达式：简洁的三元运算符语法：value_if_true if condition else value_if_false
• 短路求值：逻辑运算符可能跳过部分计算，提高效率
• 链式比较：支持 a <= b <= c 形式的链式比较
• 推导式：列表、集合、字典推导式提供简洁的数据处理方式