Python编程三十五个必学核心语法案例，含详细注释和解析！

本文链接：https://blog.csdn.net/cultivationman/article/details/149591977

Python编程三十五个必学核心语法案例，含详细注释和解析！

1. 变量交换

# 交换两个变量的值
a = 5
b = 10
print(f"交换前: a={a}, b={b}")

# 经典交换方式
temp = a
a = b
b = temp

# Pythonic交换方式
a, b = b, a

print(f"交换后: a={a}, b={b}")

'''
解析：
1. 展示了两种变量交换方式
2. Python特有的元组解包交换（a, b = b, a）
3. 避免了使用临时变量的需要
'''

2. 多重赋值

# 同时为多个变量赋值
x, y, z = 10, 20, 30
print(f"x={x}, y={y}, z={z}")

# 链式赋值
a = b = c = 100
print(f"a={a}, b={b}, c={c}")

# 变量值互换
x, y = y, x
print(f"交换后: x={x}, y={y}")

'''
解析：
1. 高效的多变量赋值方式
2. 链式赋值让多个变量共享相同值
3. 注意：当值是可变对象（如列表）时，链式赋值会共享引用
'''

3. 数字类型转换

# 不同数字类型间的转换
num_int = 10
num_float = 3.14

# 整数转浮点数
int_to_float = float(num_int)
print(f"整数转浮点数: {int_to_float} ({type(int_to_float)})")

# 浮点数转整数（截断小数部分）
float_to_int = int(num_float)
print(f"浮点数转整数: {float_to_int} ({type(float_to_int)})")

# 字符串转数字
str_num = "123"
str_to_int = int(str_num)
print(f"字符串转整数: {str_to_int} ({type(str_to_int)})")

'''
解析：
1. 使用int(), float()进行显式类型转换
2. 浮点转整型会丢失小数部分（非四舍五入）
3. 字符串转数字时需确保字符串是有效数字格式
'''

4. 字符串格式化

name = "Alice"
age = 25
score = 95.5

# 方法1: %格式化
print("姓名: %s, 年龄: %d, 分数: %.1f" % (name, age, score))

# 方法2: str.format()
print("姓名: {}, 年龄: {}, 分数: {:.1f}".format(name, age, score))

# 方法3: f-string (Python 3.6+)
print(f"姓名: {name}, 年龄: {age}, 分数: {score:.1f}")

# 方法4: 模板字符串
from string import Template
t = Template("姓名: $name, 年龄: $age")
print(t.substitute(name=name, age=age))

'''
解析：
1. 展示四种字符串格式化方法
2. f-string是最新且推荐的方式
3. 模板字符串适合用户提供的格式化字符串
'''

5. 列表切片技巧

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 基本切片
print("前5个元素:", my_list[:5])
print("后3个元素:", my_list[-3:])

# 步长切片
print("奇数索引元素:", my_list[1::2])
print("反转列表:", my_list[::-1])

# 修改多个元素
my_list[2:5] = [20, 30, 40]
print("修改后:", my_list)

'''
解析：
1. 切片语法 [start:stop:step]
2. start默认为0，stop默认为结尾，step默认为1
3. 切片创建新列表，不改变原列表（除非赋值）
'''

6. 列表推导式

# 创建0-9的平方列表
squares = [x**2 for x in range(10)]
print("平方列表:", squares)

# 带条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print("偶数的平方:", even_squares)

# 嵌套循环的列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print("扁平化矩阵:", flattened)

'''
解析：
1. 列表推导式是创建列表的简洁方式
2. 语法: [expression for item in iterable if condition]
3. 比传统for循环更高效且易读
'''

7. 字典操作

# 创建字典
student = {"name": "Alice", "age": 20, "major": "CS"}

# 添加/修改元素
student["gpa"] = 3.8  # 添加
student["age"] = 21   # 修改

# 安全获取元素
print("姓名:", student.get("name"))
print("地址:", student.get("address", "未知"))

# 遍历字典
print("\n键值对:")
for key, value in student.items():
    print(f"{key}: {value}")

# 字典推导式
squares_dict = {x: x*x for x in range(1, 6)}
print("\n平方字典:", squares_dict)

'''
解析：
1. 字典是键值对的无序集合
2. get()方法避免KeyError异常
3. items()方法同时获取键值对
'''

8. 集合操作

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print("并集:", A | B)    # 或 A.union(B)
print("交集:", A & B)    # 或 A.intersection(B)
print("差集(A-B):", A - B) # 或 A.difference(B)
print("对称差集:", A ^ B) # 或 A.symmetric_difference(B)

# 集合推导式
words = ["apple", "banana", "cherry", "date"]
first_letters = {word[0] for word in words}
print("首字母集合:", first_letters)

'''
解析：
1. 集合是无序不重复元素集
2. 支持数学集合运算
3. 常用于去重和成员测试
'''

9. 元组拆包

# 基本元组拆包
point = (3, 4)
x, y = point
print(f"坐标: x={x}, y={y}")

# 函数返回多个值
def get_user():
    return "Alice", 25, "alice@example.com"

name, age, email = get_user()
print(f"用户: {name}, {age}岁, 邮箱: {email}")

# 使用*收集多余元素
first, *middle, last = [1, 2, 3, 4, 5]
print(f"第一个: {first}, 中间: {middle}, 最后: {last}")

'''
解析：
1. 元组拆包可以同时赋值多个变量
2. 函数返回多个值实际上是返回元组
3. *操作符用于收集多余的值
'''

10. 条件表达式

# 传统条件语句
score = 85
if score >= 60:
    result = "及格"
else:
    result = "不及格"

# 条件表达式（三元运算符）
result = "及格" if score >= 60 else "不及格"

print(f"分数 {score}: {result}")

# 复杂示例
grade = 'A' if score >= 90 else 'B' if score >= 80 else 'C' if score >= 70 else 'D' if score >= 60 else 'F'
print(f"等级: {grade}")

'''
解析：
1. 条件表达式：value_if_true if condition else value_if_false
2. 比完整if语句更简洁
3. 可嵌套但不宜过度复杂化
'''

11. for-else结构

# 在for循环中查找元素
numbers = [2, 4, 6, 8, 10]
search_for = 5

for num in numbers:
    if num == search_for:
        print(f"找到 {search_for}")
        break
else:
    # 仅当循环完整执行（未break）时执行
    print(f"未找到 {search_for}")

'''
解析：
1. for-else结构不常见但很有用
2. else块在循环正常完成（未break）时执行
3. 适用于搜索场景：找到时break，未找到时执行else
'''

12. 函数参数类型

# 位置参数、默认参数、可变参数
def register(name, age, country="中国", *hobbies):
    print(f"\n姓名: {name}")
    print(f"年龄: {age}")
    print(f"国家: {country}")
    if hobbies:
        print("爱好:", ", ".join(hobbies))

# 调用函数
register("张三", 20)
register("李四", 22, "美国", "篮球", "音乐")
register("王五", 25, "阅读", "旅行")  # 注意：country会被赋值为"阅读"

# 关键字参数
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="北京")

'''
解析：
1. 位置参数：必须按顺序传递
2. 默认参数：可省略，有默认值
3. *args：收集多余位置参数为元组
4. **kwargs：收集关键字参数为字典
'''

13. lambda函数

# 简单的lambda函数
add = lambda x, y: x + y
print(f"3 + 5 = {add(3, 5)}")

# 在排序中使用
students = [("Alice", 22), ("Bob", 19), ("Charlie", 21)]
students.sort(key=lambda s: s[1])  # 按年龄排序
print("按年龄排序:", students)

# 在map中使用
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print("平方:", squared)

'''
解析：
1. lambda创建匿名函数
2. 语法：lambda 参数: 表达式
3. 适用于简单操作，不宜复杂逻辑
'''

14. 闭包

def make_multiplier(factor):
    """创建乘法器闭包"""
    def multiplier(x):
        return x * factor
    return multiplier

# 创建闭包
double = make_multiplier(2)
triple = make_multiplier(3)

print(f"双倍 10: {double(10)}")
print(f"三倍 10: {triple(10)}")

'''
解析：
1. 闭包是内部函数，记住并访问外部函数作用域
2. factor是闭包捕获的外部变量
3. 闭包保持状态，即使外部函数已执行完毕
'''

15. 生成器函数

def count_down(n):
    """倒计时生成器"""
    print("开始倒计时!")
    while n > 0:
        yield n
        n -= 1
    print("发射!")

# 使用生成器
for i in count_down(5):
    print(i)

# 手动使用
gen = count_down(3)
print(next(gen))  # 3
print(next(gen))  # 2
print(next(gen))  # 1
print(next(gen))  # StopIteration

'''
解析：
1. yield使函数变为生成器
2. 生成器惰性产生值，节省内存
3. 每次调用next()执行到下一个yield
'''

16. 装饰器基础

def simple_decorator(func):
    """简单装饰器"""
    def wrapper():
        print("-- 函数执行前 --")
        func()
        print("-- 函数执行后 --")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello World!")

# 调用被装饰的函数
say_hello()

'''
解析：
1. 装饰器修改或增强函数行为
2. @语法糖等价于 say_hello = simple_decorator(say_hello)
3. wrapper函数包裹原始函数调用
'''

17. 带参数的装饰器

def repeat(num_times):
    """带参数的装饰器工厂"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}!")

greet("Alice")

'''
解析：
1. 三层嵌套实现带参装饰器
2. 外层接收装饰器参数
3. 中层接收被装饰函数
4. 内层实现装饰逻辑
'''

18. 类与对象

class Dog:
    # 类属性
    species = "Canis familiaris"
    
    # 初始化方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def description(self):
        return f"{self.name} is {self.age} years old"
    
    def speak(self, sound):
        return f"{self.name} says {sound}"

# 创建实例
my_dog = Dog("Buddy", 5)
print(my_dog.description())
print(my_dog.speak("Woof!"))

'''
解析：
1. __init__方法在创建实例时初始化
2. self表示实例本身
3. 类属性被所有实例共享
4. 实例方法第一个参数总是self
'''

19. 继承与多态

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# 多态示例
animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:
    print(animal.speak())

'''
解析：
1. 子类继承父类的属性和方法
2. 方法重写实现多态
3. 不同子类对象对同一方法调用产生不同行为
'''

20. 静态方法与类方法

class MyClass:
    class_attr = "类属性"
    
    def __init__(self, value):
        self.value = value
    
    @staticmethod
    def static_method():
        print("这是静态方法，不访问类或实例属性")
    
    @classmethod
    def class_method(cls):
        print(f"这是类方法，访问类属性: {cls.class_attr}")
        # 可以创建类的新实例
        return cls("新实例")
    
    def instance_method(self):
        print(f"这是实例方法，访问实例属性: {self.value}")

# 使用静态方法
MyClass.static_method()

# 使用类方法
new_instance = MyClass.class_method()
new_instance.instance_method()

# 使用实例方法
obj = MyClass(42)
obj.instance_method()

'''
解析：
1. 静态方法：与类和实例无关，相当于普通函数
2. 类方法：第一个参数是类本身(cls)，可访问类属性
3. 实例方法：第一个参数是实例本身(self)
'''

21. 属性装饰器

class Circle:
    def __init__(self, radius):
        self._radius = radius  # 保护属性
    
    @property
    def radius(self):
        """获取半径（只读属性）"""
        return self._radius
    
    @property
    def diameter(self):
        """直径属性（计算属性）"""
        return 2 * self._radius
    
    @property
    def area(self):
        """面积属性（计算属性）"""
        return 3.14 * self._radius ** 2
    
    @radius.setter
    def radius(self, value):
        if value > 0:
            self._radius = value
        else:
            raise ValueError("半径必须为正数")

# 使用
c = Circle(5)
print(f"半径: {c.radius}, 直径: {c.diameter}, 面积: {c.area}")

c.radius = 10  # 使用setter方法
print(f"新半径: {c.radius}, 新面积: {c.area}")

'''
解析：
1. @property将方法转为只读属性
2. @属性名.setter定义设置方法
3. 保护类内部实现细节
4. 验证输入值的有效性
'''

22. 上下文管理器

# 自定义上下文管理器
class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()
        # 如果返回True，则抑制异常
        return False

# 使用
with FileManager("example.txt", "w") as f:
    f.write("Hello, Context Manager!")
    # 这里不需要手动关闭文件

print("文件已自动关闭")

'''
解析：
1. __enter__ 进入上下文时调用，返回资源对象
2. __exit__ 退出上下文时调用，处理清理工作
3. with语句确保资源正确释放
4. 可用于文件、网络连接、数据库连接等资源管理
'''

23. 枚举类型

from enum import Enum, auto

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

class Status(Enum):
    PENDING = auto()
    RUNNING = auto()
    COMPLETED = auto()
    FAILED = auto()

# 使用枚举
print(Color.RED)          # Color.RED
print(Color.RED.name)     # 'RED'
print(Color.RED.value)    # 1

# 比较
if Status.PENDING == Status.PENDING:
    print("状态为待处理")

# 遍历
print("所有颜色:")
for color in Color:
    print(color)

'''
解析：
1. 枚举定义一组命名常量
2. 比直接使用数字或字符串更安全、可读
3. auto()自动分配值
4. 防止无效值，支持类型检查
'''

24. 异常处理

try:
    num = int(input("请输入整数: "))
    result = 10 / num
    print(f"10/{num} = {result}")
except ValueError:
    print("输入的不是整数!")
except ZeroDivisionError:
    print("不能除以0!")
except Exception as e:
    print(f"未知错误: {e}")
else:
    print("计算成功!")
finally:
    print("程序执行完毕")

# 自定义异常
class MyCustomError(Exception):
    """自定义异常类"""
    def __init__(self, message):
        super().__init__(message)

# 触发自定义异常
try:
    raise MyCustomError("发生自定义错误")
except MyCustomError as e:
    print(f"捕获自定义异常: {e}")

'''
解析：
1. try-except捕获并处理异常
2. else块在没有异常时执行
3. finally块总是执行，用于清理工作
4. 自定义异常继承Exception类
'''

25. 类型提示

# 基本类型提示
def greet(name: str, age: int) -> str:
    return f"{name} is {age} years old"

# 复杂类型提示
from typing import List, Tuple, Dict, Union, Optional

def process_data(
    data: List[Union[int, float]], 
    config: Optional[Dict[str, str]] = None
) -> Tuple[int, float]:
    total = sum(data)
    avg = total / len(data)
    return (total, avg)

# 类型别名
Vector = List[float]

def scale_vector(v: Vector, scalar: float) -> Vector:
    return [x * scalar for x in v]

# 使用
print(greet("Alice", 25))
result = process_data([1, 2.5, 3, 4.5])
print(f"总和: {result[0]}, 平均值: {result[1]}")

'''
解析：
1. Python 3.5+支持类型提示
2. 提高代码可读性和可维护性
3. 使用typing模块支持复杂类型
4. 类型提示不强制类型检查，需配合mypy等工具
'''

26. 数据类

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float
    z: float = 0.0  # 默认值
    
    def distance_to_origin(self) -> float:
        return (self.x**2 + self.y**2 + self.z**2) ** 0.5

# 使用数据类
p1 = Point(3, 4)
print(p1)  # 自动实现__repr__
print(f"到原点的距离: {p1.distance_to_origin()}")

p2 = Point(3, 4)
print(f"p1 == p2? {p1 == p2}")  # 自动实现__eq__

'''
解析：
1. @dataclass自动生成__init__、__repr__等方法
2. 减少样板代码
3. 支持类型提示和默认值
4. 适用于主要存储数据的类
'''

27. 迭代器协议

class CountDown:
    """倒计时迭代器"""
    def __init__(self, start):
        self.current = start
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        else:
            num = self.current
            self.current -= 1
            return num

# 使用迭代器
for i in CountDown(5):
    print(i, end=" ")  # 5 4 3 2 1

# 手动使用
cd = CountDown(3)
print(next(cd))  # 3
print(next(cd))  # 2
print(next(cd))  # 1
print(next(cd))  # StopIteration

'''
解析：
1. __iter__返回迭代器对象
2. __next__返回下一个值，没有时抛出StopIteration
3. for循环自动处理迭代器协议
'''

28. 生成器表达式

# 列表推导式（立即计算）
squares_list = [x**2 for x in range(10000)]
print(f"列表大小: {len(squares_list)} 内存使用高")

# 生成器表达式（惰性计算）
squares_gen = (x**2 for x in range(10000))
print(f"生成器大小: 固定 内存使用低")

# 使用生成器
for i, square in enumerate(squares_gen):
    if i >= 5:
        break
    print(square)

# 生成器作为函数参数
total = sum(x**2 for x in range(10000))
print(f"前10000个平方数的和: {total}")

'''
解析：
1. 生成器表达式语法: (expression for item in iterable)
2. 惰性求值，节省内存
3. 适用于大数据集处理
4. 只能迭代一次
'''

29. 深拷贝与浅拷贝

import copy

# 原始列表
original = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 浅拷贝
shallow = copy.copy(original)
shallow[0][0] = 100
print("浅拷贝修改后:")
print("Original:", original)  # 第一层被修改
print("Shallow:", shallow)

# 深拷贝
deep = copy.deepcopy(original)
deep[0][0] = 999
print("\n深拷贝修改后:")
print("Original:", original)  # 不受影响
print("Deep:", deep)

'''
解析：
1. 浅拷贝只复制最外层容器
2. 深拷贝递归复制所有嵌套对象
3. 对于包含可变对象的嵌套结构，应使用深拷贝
4. copy模块提供copy()和deepcopy()函数
'''

30. 函数缓存

import functools
import time

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    """计算斐波那契数列项（带缓存）"""
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 测试
start = time.time()
print(f"fib(35) = {fibonacci(35)}")
end = time.time()
print(f"耗时: {end - start:.4f}秒")

# 再次计算（缓存命中）
start = time.time()
print(f"fib(35) = {fibonacci(35)}")
end = time.time()
print(f"缓存后耗时: {end - start:.8f}秒")

'''
解析：
1. @lru_cache实现最近最少使用缓存
2. 显著提高递归函数性能
3. maxsize限制缓存大小
4. 适用于纯函数（同样输入总是同样输出）
'''

31. 路径操作

from pathlib import Path

# 创建Path对象
current_dir = Path.cwd()
home_dir = Path.home()

print(f"当前目录: {current_dir}")
print(f"主目录: {home_dir}")

# 路径拼接
file_path = current_dir / "data" / "test.txt"
print(f"文件路径: {file_path}")

# 检查路径
print(f"存在? {file_path.exists()}")
print(f"是文件? {file_path.is_file()}")
print(f"是目录? {file_path.is_dir()}")

# 创建目录和文件
new_dir = current_dir / "new_folder"
new_dir.mkdir(exist_ok=True)

(new_dir / "example.txt").write_text("Hello Pathlib!")

# 遍历目录
print("\n目录内容:")
for item in new_dir.iterdir():
    print(f" - {item.name}")

'''
解析：
1. pathlib提供面向对象的路径操作
2. 比os.path更现代和易用
3. 自动处理不同操作系统的路径差异
4. 支持路径拼接、检查、文件操作等
'''

32. 时间日期

import datetime

# 当前时间
now = datetime.datetime.now()
print(f"当前时间: {now}")

# 格式化时间
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"格式化时间: {formatted}")

# 解析字符串
dt_str = "2023-10-01 12:30:45"
parsed_dt = datetime.datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
print(f"解析时间: {parsed_dt}")

# 时间运算
one_day = datetime.timedelta(days=1)
tomorrow = now + one_day
print(f"明天: {tomorrow.date()}")

# 时区处理 (需要pytz)
try:
    import pytz
    utc_now = datetime.datetime.now(pytz.utc)
    beijing_tz = pytz.timezone('Asia/Shanghai')
    beijing_time = utc_now.astimezone(beijing_tz)
    print(f"北京时间: {beijing_time}")
except ImportError:
    print("请安装pytz库以使用时区功能")

'''
解析：
1. datetime模块处理日期和时间
2. strftime格式化时间输出
3. strptime解析时间字符串
4. timedelta表示时间间隔
5. pytz库处理时区转换
'''

33. 正则表达式

import re

text = "联系我: 电话 138-0013-8000 或 邮箱 contact@example.com"

# 查找电话号码
phone_pattern = r'\d{3}-\d{4}-\d{4}'
phones = re.findall(phone_pattern, text)
print(f"找到的电话号码: {phones}")

# 查找邮箱
email_pattern = r'[\w\.-]+@[\w\.-]+'
emails = re.findall(email_pattern, text)
print(f"找到的邮箱: {emails}")

# 替换文本
masked_text = re.sub(phone_pattern, "***-****-****", text)
print(f"脱敏文本: {masked_text}")

# 验证邮箱格式
def is_valid_email(email):
    pattern = r'^[\w\.-]+@[\w\.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

print("\n邮箱验证:")
print("contact@example.com:", is_valid_email("contact@example.com"))
print("invalid_email:", is_valid_email("invalid_email"))

'''
解析：
1. re模块提供正则表达式操作
2. findall查找所有匹配
3. sub替换匹配文本
4. match验证字符串格式
5. 正则表达式是强大的文本处理工具
'''

34. JSON处理

import json

# Python对象
data = {
    "name": "Alice",
    "age": 25,
    "courses": ["Math", "Physics"],
    "graduated": False
}

# 转换为JSON字符串
json_str = json.dumps(data, indent=2)
print("JSON字符串:")
print(json_str)

# 写入JSON文件
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

# 从JSON字符串解析
parsed_data = json.loads(json_str)
print("\n解析后的数据:")
print(parsed_data)

# 从JSON文件读取
with open("data.json") as f:
    file_data = json.load(f)
print("\n文件数据:")
print(file_data)

'''
解析：
1. json模块处理JSON数据
2. dumps将Python对象转为JSON字符串
3. dump将Python对象写入JSON文件
4. loads将JSON字符串转为Python对象
5. load从JSON文件读取数据
'''

35. 虚拟环境

"""
虽然无法直接执行虚拟环境操作，但以下是常用命令：

# 创建虚拟环境
python -m venv myenv

# 激活虚拟环境
# Windows:
myenv\Scripts\activate
# Linux/macOS:
source myenv/bin/activate

# 安装包
pip install requests

# 冻结依赖
pip freeze > requirements.txt

# 从requirements.txt安装
pip install -r requirements.txt

# 停用虚拟环境
deactivate

解析：
1. 虚拟环境隔离项目依赖
2. 避免不同项目间的包冲突
3. venv是Python内置虚拟环境工具
4. 激活后安装的包仅在当前环境有效
"""

这些案例涵盖了Python核心语法的关键知识点，包括：