# 基础数据类型
# 数字类型
integer_num = 42
float_num = 3.14159
complex_num = 1 + 2j

# 字符串
single_quote = 'Hello'
double_quote = "World"
triple_quote = """Multi-line
string content"""

# 布尔类型
is_true = True
is_false = False

# 空值
nothing = None

# 动态类型
x = 10          # int
x = "Python"    # str
x = [1, 2, 3]   # list

# 类型检查
print(type(x))              # <class 'list'>
print(isinstance(x, list))  # True

# 类型转换
str_num = "123"
int_num = int(str_num)      # 123
float_num = float(str_num)  # 123.0
str_back = str(int_num)     # "123"

# 多重赋值
a, b, c = 1, 2, 3
x = y = z = 0

# 解包
numbers = [1, 2, 3, 4, 5]
first, *middle, last = numbers
print(first)    # 1
print(middle)   # [2, 3, 4]
print(last)     # 5

# 字符串定义
name = "Python Programming"
greeting = f"Hello, {name}!"  # f-string
template = "Hello, {}!".format(name)  # format method
old_style = "Hello, %s!" % name  # % formatting

# 字符串方法
text = "  Python Programming  "

# 基础操作
print(len(text))                    # 长度
print(text.strip())                 # 去除首尾空格
print(text.lower())                 # 转小写
print(text.upper())                 # 转大写
print(text.title())                 # 标题格式
print(text.replace("Python", "Go")) # 替换

# 查找和检查
print(text.find("Python"))          # 查找位置
print(text.count("o"))              # 计数
print(text.startswith("  Py"))      # 检查开头
print(text.endswith("ing  "))       # 检查结尾
print("Python" in text)             # 包含检查

# 分割和连接
words = text.strip().split()         # 分割为列表
joined = " ".join(words)             # 连接列表
lines = "line1\nline2\nline3".splitlines()  # 按行分割

# 字符串切片
s = "Python"
print(s[0])      # 'P' - 第一个字符
print(s[-1])     # 'n' - 最后一个字符
print(s[0:3])    # 'Pyt' - 切片
print(s[:3])     # 'Pyt' - 从开头切片
print(s[3:])     # 'hon' - 切到末尾
print(s[::-1])   # 'nohtyP' - 反转

# 字符串格式化
name = "Alice"
age = 30
score = 95.5

# f-string (Python 3.6+)
message1 = f"Name: {name}, Age: {age}, Score: {score:.1f}"

# format method
message2 = "Name: {}, Age: {}, Score: {:.1f}".format(name, age, score)
message3 = "Name: {name}, Age: {age}, Score: {score:.1f}".format(
    name=name, age=age, score=score)

# % formatting
message4 = "Name: %s, Age: %d, Score: %.1f" % (name, age, score)

print(message1)  # Name: Alice, Age: 30, Score: 95.5

# 列表 (List) - 可变、有序
fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

# 列表操作
fruits.append("grape")              # 添加元素
fruits.insert(1, "kiwi")           # 插入元素
fruits.remove("banana")            # 删除元素
popped = fruits.pop()              # 弹出最后一个元素
fruits.extend(["mango", "pear"])   # 扩展列表
fruits.sort()                      # 排序
fruits.reverse()                   # 反转

# 列表推导式
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
matrix = [[i*j for j in range(3)] for i in range(3)]

print(squares)      # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(even_squares) # [0, 4, 16, 36, 64]

# 元组 (Tuple) - 不可变、有序
point = (3, 4)
colors = ("red", "green", "blue")
single_item = (42,)  # 注意逗号

# 元组解包
x, y = point
r, g, b = colors

# 命名元组
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # 1 2

# 字典 (Dictionary) - 可变、无序（Python 3.7+ 保持插入顺序）
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# 字典操作
person["email"] = "alice@example.com"    # 添加
person["age"] = 31                       # 修改
del person["city"]                       # 删除
age = person.get("age", 0)              # 安全获取
keys = list(person.keys())              # 获取键
values = list(person.values())          # 获取值
items = list(person.items())            # 获取键值对

# 字典推导式
squared_dict = {x: x**2 for x in range(5)}
filtered_dict = {k: v for k, v in person.items() if len(str(v)) > 5}

print(squared_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 集合 (Set) - 可变、无序、唯一
unique_numbers = {1, 2, 3, 4, 5}
fruits_set = {"apple", "banana", "orange"}

# 集合操作
fruits_set.add("grape")                 # 添加元素
fruits_set.remove("banana")             # 删除元素（不存在会报错）
fruits_set.discard("kiwi")              # 删除元素（不存在不报错）

# 集合运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

union = set1 | set2              # 并集: {1, 2, 3, 4, 5, 6}
intersection = set1 & set2       # 交集: {3, 4}
difference = set1 - set2         # 差集: {1, 2}
symmetric_diff = set1 ^ set2     # 对称差集: {1, 2, 5, 6}

# 集合推导式
even_squares_set = {x**2 for x in range(10) if x % 2 == 0}

# if-elif-else 语句
score = 85

if score >= 90:
    grade = "A"
    print("Excellent!")
elif score >= 80:
    grade = "B"
    print("Good job!")
elif score >= 70:
    grade = "C"
    print("Average")
elif score >= 60:
    grade = "D"
    print("Below average")
else:
    grade = "F"
    print("Failed")

print(f"Your grade is: {grade}")

# 三元运算符
status = "pass" if score >= 60 else "fail"
max_value = a if a > b else b

# 多条件判断
age = 25
has_license = True
has_car = False

if age >= 18 and has_license:
    print("Can drive")

if has_license or has_car:
    print("Has transportation option")

if not has_car:
    print("Needs a car")

# 链式比较
x = 15
if 10 < x < 20:
    print("x is between 10 and 20")

# 检查成员资格
user_role = "admin"
allowed_roles = ["admin", "moderator", "editor"]

if user_role in allowed_roles:
    print("Access granted")

# 检查类型
value = "42"
if isinstance(value, str):
    print("Value is a string")

# 检查空值
data = []
if not data:  # 空列表、空字符串、None、0 都被认为是 False
    print("Data is empty")

# 使用 match-case (Python 3.10+)
def handle_status_code(code):
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case code if 400 <= code < 500:
            return "Client Error"
        case code if 500 <= code < 600:
            return "Server Error"
        case _:
            return "Unknown Status"

print(handle_status_code(404))  # Not Found

# for 循环
# 遍历列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(f"I like {fruit}")

# 遍历字符串
for char in "Python":
    print(char)

# 使用 range()
for i in range(5):          # 0, 1, 2, 3, 4
    print(i)

for i in range(1, 6):       # 1, 2, 3, 4, 5
    print(i)

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(i)

# 使用 enumerate() 获取索引
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 遍历字典
person = {"name": "Alice", "age": 30, "city": "NY"}

for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# 并行遍历多个序列
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["NY", "LA", "Chicago"]

for name, age, city in zip(names, ages, cities):
    print(f"{name}, {age}, {city}")

# while 循环
count = 0
while count < 5:
    print(f"Count: {count}")
    count += 1

# 无限循环与 break
while True:
    user_input = input("Enter 'quit' to exit: ")
    if user_input.lower() == 'quit':
        break
    print(f"You entered: {user_input}")

# continue 语句
for i in range(10):
    if i % 2 == 0:
        continue  # 跳过偶数
    print(f"Odd number: {i}")

# else 子句（循环正常结束时执行）
for i in range(5):
    print(i)
    if i == 10:  # 这个条件永远不会满足
        break
else:
    print("Loop completed normally")  # 会被执行

# 嵌套循环
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

for row in matrix:
    for element in row:
        print(element, end=" ")
    print()  # 换行

# 循环推导式
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 列表推导式
squares = [x**2 for x in numbers]
even_numbers = [x for x in numbers if x % 2 == 0]
pairs = [(x, y) for x in range(3) for y in range(3)]

# 字典推导式
square_dict = {x: x**2 for x in numbers}

# 集合推导式
unique_squares = {x**2 for x in numbers}

# 生成器表达式
squares_gen = (x**2 for x in numbers)

print(list(squares_gen))  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 基本函数定义
def greet(name):
    """简单的问候函数"""
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # Hello, Alice!

# 带默认参数的函数
def greet_with_title(name, title="Mr."):
    """带默认参数的问候函数"""
    return f"Hello, {title} {name}!"

print(greet_with_title("Smith"))           # Hello, Mr. Smith!
print(greet_with_title("Smith", "Dr."))    # Hello, Dr. Smith!

# 可变参数函数
def sum_all(*args):
    """接受任意数量参数的求和函数"""
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 15

def print_info(**kwargs):
    """接受任意关键字参数的函数"""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="NY")

# 混合参数类型
def complex_function(required_arg, default_arg="default", *args, **kwargs):
    """演示各种参数类型的函数"""
    print(f"Required: {required_arg}")
    print(f"Default: {default_arg}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

complex_function("hello", "world", 1, 2, 3, name="Alice", age=30)

# 多返回值
def calculate_stats(numbers):
    """计算统计信息"""
    total = sum(numbers)
    count = len(numbers)
    average = total / count if count > 0 else 0
    return total, count, average

total, count, avg = calculate_stats([1, 2, 3, 4, 5])
print(f"Total: {total}, Count: {count}, Average: {avg}")

# 函数作为参数
def apply_operation(numbers, operation):
    """对数字列表应用操作函数"""
    return [operation(x) for x in numbers]

def square(x):
    return x ** 2

def cube(x):
    return x ** 3

numbers = [1, 2, 3, 4, 5]
squares = apply_operation(numbers, square)
cubes = apply_operation(numbers, cube)

print(f"Squares: {squares}")  # [1, 4, 9, 16, 25]
print(f"Cubes: {cubes}")      # [1, 8, 27, 64, 125]

# Lambda 函数
# 简单的 lambda 函数
double = lambda x: x * 2
add = lambda x, y: x + y

print(double(5))    # 10
print(add(3, 4))    # 7

# 在高阶函数中使用 lambda
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# map() 函数
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# filter() 函数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4, 6, 8, 10]

# sorted() 函数
students = [("Alice", 85), ("Bob", 90), ("Charlie", 78)]
sorted_by_grade = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_by_grade)  # [('Bob', 90), ('Alice', 85), ('Charlie', 78)]

# 递归函数
def factorial(n):
    """计算阶乘的递归函数"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

def fibonacci(n):
    """计算斐波那契数列"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# 生成斐波那契数列
fib_sequence = [fibonacci(i) for i in range(10)]
print(fib_sequence)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# 带缓存的递归（避免重复计算）
from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_cached(n):
    """带缓存的斐波那契函数"""
    if n <= 1:
        return n
    return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)

print(fibonacci_cached(50))  # 很快就能计算出结果

# 闭包
def outer_function(x):
    """外部函数"""
    def inner_function(y):
        """内部函数，形成闭包"""
        return x + y
    return inner_function

add_10 = outer_function(10)
print(add_10(5))  # 15

# 更复杂的闭包示例
def make_counter():
    """创建计数器的工厂函数"""
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

counter1 = make_counter()
counter2 = make_counter()

print(counter1())  # 1
print(counter1())  # 2
print(counter2())  # 1
print(counter1())  # 3

# 基础装饰器
def my_decorator(func):
    """基础装饰器示例"""
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完成")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")
    return f"Greeted {name}"

result = say_hello("Alice")

# 计时装饰器
import time
from functools import wraps

def timer(func):
    """计算函数执行时间的装饰器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time:.4f} 秒")
        return result
    return wrapper

@timer
def slow_function():
    """模拟耗时操作"""
    time.sleep(1)
    return "操作完成"

slow_function()

# 带参数的装饰器
def repeat(times):
    """重复执行函数的装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Bob")  # 会打印3次

# 类装饰器
class CountCalls:
    """统计函数调用次数的类装饰器"""
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"{self.func.__name__} 被调用了 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_hi():
    print("Hi!")

say_hi()  # say_hi 被调用了 1 次
say_hi()  # say_hi 被调用了 2 次

# 缓存装饰器
def memoize(func):
    """缓存函数结果的装饰器"""
    cache = {}

    @wraps(func)
    def wrapper(*args, **kwargs):
        # 创建缓存键
        key = str(args) + str(sorted(kwargs.items()))

        if key not in cache:
            cache[key] = func(*args, **kwargs)
            print(f"计算并缓存: {key}")
        else:
            print(f"从缓存获取: {key}")

        return cache[key]
    return wrapper

@memoize
def expensive_calculation(n):
    """模拟耗时计算"""
    time.sleep(1)
    return n ** 2

print(expensive_calculation(5))  # 计算并缓存
print(expensive_calculation(5))  # 从缓存获取

# 多个装饰器组合
@timer
@repeat(2)
def combined_example():
    print("执行任务")

combined_example()

## 🏗️ 面向对象编程

### 1. 类和对象

```python
# 基础类定义
class Person:
    """人员类示例"""

    # 类变量（所有实例共享）
    species = "Homo sapiens"

    def __init__(self, name, age, email):
        """构造函数"""
        self.name = name        # 实例变量
        self.age = age
        self.email = email
        self._private_var = "私有变量"  # 约定的私有变量
        self.__very_private = "很私有的变量"  # 名称修饰

    def introduce(self):
        """实例方法"""
        return f"Hi, I'm {self.name}, {self.age} years old."

    def have_birthday(self):
        """增加年龄"""
        self.age += 1
        print(f"Happy birthday! Now {self.age} years old.")

    @staticmethod
    def is_adult(age):
        """静态方法 - 不需要访问实例或类"""
        return age >= 18

    @classmethod
    def create_baby(cls, name):
        """类方法 - 访问类本身"""
        return cls(name, 0, "")

    def __str__(self):
        """字符串表示"""
        return f"Person(name='{self.name}', age={self.age})"

    def __repr__(self):
        """开发者字符串表示"""
        return f"Person('{self.name}', {self.age}, '{self.email}')"

# 创建和使用对象
person1 = Person("Alice", 25, "alice@example.com")
person2 = Person("Bob", 30, "bob@example.com")

print(person1.introduce())  # Hi, I'm Alice, 25 years old.
person1.have_birthday()     # Happy birthday! Now 26 years old.

print(Person.is_adult(17))  # False
print(Person.is_adult(25))  # True

baby = Person.create_baby("Charlie")
print(baby)  # Person(name='Charlie', age=0)

# 属性访问
print(person1.name)         # Alice
print(person1._private_var) # 仍可访问，但不推荐
# print(person1.__very_private)  # 会报错，需要用 _Person__very_private

# 基础继承
class Employee(Person):
    """员工类，继承自Person"""

    def __init__(self, name, age, email, employee_id, salary):
        super().__init__(name, age, email)  # 调用父类构造函数
        self.employee_id = employee_id
        self.salary = salary
        self.department = None

    def introduce(self):
        """重写父类方法"""
        base_intro = super().introduce()
        return f"{base_intro} I work here as employee #{self.employee_id}."

    def work(self):
        """员工特有的方法"""
        return f"{self.name} is working..."

    def get_annual_salary(self):
        """计算年薪"""
        return self.salary * 12

class Manager(Employee):
    """经理类，继承自Employee"""

    def __init__(self, name, age, email, employee_id, salary, team_size):
        super().__init__(name, age, email, employee_id, salary)
        self.team_size = team_size
        self.team_members = []

    def introduce(self):
        """再次重写方法"""
        base_intro = super().introduce()
        return f"{base_intro} I manage a team of {self.team_size} people."

    def hire(self, employee):
        """雇佣员工"""
        self.team_members.append(employee)
        employee.department = f"Team led by {self.name}"
        print(f"{employee.name} hired to {self.name}'s team")

    def hold_meeting(self):
        """举行会议"""
        return f"{self.name} is holding a team meeting with {len(self.team_members)} members."

# 使用继承
emp = Employee("John", 28, "john@company.com", "E001", 5000)
mgr = Manager("Sarah", 35, "sarah@company.com", "M001", 8000, 5)

print(emp.introduce())
print(mgr.introduce())

mgr.hire(emp)
print(mgr.hold_meeting())

# 检查继承关系
print(isinstance(emp, Employee))  # True
print(isinstance(emp, Person))    # True
print(isinstance(mgr, Manager))   # True
print(isinstance(mgr, Employee))  # True

print(issubclass(Manager, Employee))  # True
print(issubclass(Employee, Person))   # True

class Vector:
    """向量类，演示特殊方法"""

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        """用户友好的字符串表示"""
        return f"Vector({self.x}, {self.y})"

    def __repr__(self):
        """开发者字符串表示"""
        return f"Vector({self.x!r}, {self.y!r})"

    def __add__(self, other):
        """向量加法"""
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __sub__(self, other):
        """向量减法"""
        if isinstance(other, Vector):
            return Vector(self.x - other.x, self.y - other.y)
        return NotImplemented

    def __mul__(self, scalar):
        """标量乘法"""
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented

    def __rmul__(self, scalar):
        """右侧标量乘法"""
        return self.__mul__(scalar)

    def __eq__(self, other):
        """相等比较"""
        if isinstance(other, Vector):
            return self.x == other.x and self.y == other.y
        return False

    def __len__(self):
        """向量的模长"""
        return int((self.x**2 + self.y**2)**0.5)

    def __getitem__(self, index):
        """支持索引访问"""
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError("Vector index out of range")

    def __setitem__(self, index, value):
        """支持索引赋值"""
        if index == 0:
            self.x = value
        elif index == 1:
            self.y = value
        else:
            raise IndexError("Vector index out of range")

# 使用特殊方法
v1 = Vector(2, 3)
v2 = Vector(1, 4)

print(v1)           # Vector(2, 3)
print(v1 + v2)      # Vector(3, 7)
print(v1 - v2)      # Vector(1, -1)
print(v1 * 3)       # Vector(6, 9)
print(2 * v1)       # Vector(4, 6)
print(v1 == v2)     # False
print(len(v1))      # 3
print(v1[0], v1[1]) # 2 3

v1[0] = 5
print(v1)           # Vector(5, 3)

class Temperature:
    """温度类，演示属性使用"""

    def __init__(self, celsius=0):
        self._celsius = celsius

    @property
    def celsius(self):
        """摄氏度属性"""
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        """设置摄氏度"""
        if value < -273.15:
            raise ValueError("Temperature cannot be below absolute zero")
        self._celsius = value

    @property
    def fahrenheit(self):
        """华氏度属性（只读）"""
        return self._celsius * 9/5 + 32

    @property
    def kelvin(self):
        """开尔文温度属性（只读）"""
        return self._celsius + 273.15

    def __str__(self):
        return f"{self._celsius}°C"

# 使用属性
temp = Temperature(25)
print(temp.celsius)     # 25
print(temp.fahrenheit)  # 77.0
print(temp.kelvin)      # 298.15

temp.celsius = 30
print(temp.fahrenheit)  # 86.0

# temp.celsius = -300    # 会抛出 ValueError

# 描述符示例
class Descriptor:
    """简单的描述符"""

    def __init__(self, name):
        self.name = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)

    def __set__(self, obj, value):
        if not isinstance(value, str):
            raise TypeError(f"{self.name} must be a string")
        obj.__dict__[self.name] = value.upper()

class MyClass:
    """使用描述符的类"""
    name = Descriptor('name')

    def __init__(self, name):
        self.name = name

obj = MyClass("alice")
print(obj.name)  # ALICE
obj.name = "bob"
print(obj.name)  # BOB

# 导入模块的不同方式
import math
import datetime as dt
from collections import defaultdict, Counter
from itertools import *

# 使用导入的模块
print(math.sqrt(16))        # 4.0
print(math.pi)              # 3.141592653589793

now = dt.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

# collections 模块
dd = defaultdict(list)
dd['fruits'].append('apple')
dd['fruits'].append('banana')
print(dd)  # defaultdict(<class 'list'>, {'fruits': ['apple', 'banana']})

counter = Counter(['a', 'b', 'c', 'a', 'b', 'a'])
print(counter)  # Counter({'a': 3, 'b': 2, 'c': 1})
print(counter.most_common(2))  # [('a', 3), ('b', 2)]

# itertools 模块
from itertools import combinations, permutations, product

print(list(combinations('ABC', 2)))     # [('A', 'B'), ('A', 'C'), ('B', 'C')]
print(list(permutations('ABC', 2)))     # [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
print(list(product('AB', '12')))        # [('A', '1'), ('A', '2'), ('B', '1'), ('B', '2')]

# 创建自定义模块
# 文件: mymodule.py
"""
def greet(name):
    return f"Hello, {name}!"

def calculate_area(radius):
    import math
    return math.pi * radius ** 2

PI = 3.14159

class SimpleCalculator:
    def add(self, a, b):
        return a + b

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

# 使用自定义模块
# import mymodule
# print(mymodule.greet("World"))
# print(mymodule.calculate_area(5))
# calc = mymodule.SimpleCalculator()
# print(calc.add(2, 3))

# 包结构示例
"""
mypackage/
    __init__.py
    math_utils/
        __init__.py
        basic.py
        advanced.py
    string_utils/
        __init__.py
        formatters.py
        validators.py
"""

# mypackage/__init__.py
"""
__version__ = "1.0.0"
__author__ = "Your Name"

from .math_utils import add, multiply
from .string_utils import format_name
"""

# mypackage/math_utils/__init__.py
"""
from .basic import add, subtract
from .advanced import power, logarithm
"""

# mypackage/math_utils/basic.py
"""
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

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

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b
"""

# mypackage/string_utils/formatters.py
"""
def format_name(first_name, last_name):
    return f"{last_name}, {first_name}"

def capitalize_words(text):
    return ' '.join(word.capitalize() for word in text.split())
"""

# 使用包
# from mypackage import add, multiply, format_name
# from mypackage.math_utils.advanced import power
# from mypackage.string_utils.validators import is_email

# 相对导入（在包内部使用）
# from .basic import add          # 从同级模块导入
# from ..string_utils import format_name  # 从父级包导入
# from ...other_package import something  # 从更高级包导入

# 基础文件读写
# 写入文件
with open('example.txt', 'w', encoding='utf-8') as file:
    file.write("Hello, World!\n")
    file.write("This is a test file.\n")
    file.writelines(["Line 1\n", "Line 2\n", "Line 3\n"])

# 读取文件
with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()  # 读取全部内容
    print(content)

# 逐行读取
with open('example.txt', 'r', encoding='utf-8') as file:
    for line_number, line in enumerate(file, 1):
        print(f"Line {line_number}: {line.strip()}")

# 读取所有行到列表
with open('example.txt', 'r', encoding='utf-8') as file:
    lines = file.readlines()
    print(f"Total lines: {len(lines)}")

# 追加内容
with open('example.txt', 'a', encoding='utf-8') as file:
    file.write("Appended line\n")

# 二进制文件处理
# 复制文件
def copy_file(source, destination):
    """复制文件"""
    with open(source, 'rb') as src, open(destination, 'wb') as dst:
        while True:
            chunk = src.read(1024)  # 每次读取1KB
            if not chunk:
                break
            dst.write(chunk)

# 文件信息
import os
import stat
from pathlib import Path

file_path = 'example.txt'

# 使用 os 模块
if os.path.exists(file_path):
    print(f"File size: {os.path.getsize(file_path)} bytes")
    print(f"Last modified: {os.path.getmtime(file_path)}")
    print(f"Is file: {os.path.isfile(file_path)}")
    print(f"Is directory: {os.path.isdir(file_path)}")

# 使用 pathlib (推荐)
path = Path(file_path)
if path.exists():
    print(f"File size: {path.stat().st_size} bytes")
    print(f"Last modified: {path.stat().st_mtime}")
    print(f"Is file: {path.is_file()}")
    print(f"Parent directory: {path.parent}")
    print(f"File extension: {path.suffix}")
    print(f"File name: {path.name}")
    print(f"File stem: {path.stem}")

# 目录操作
import glob

# 创建目录
os.makedirs('test_dir/sub_dir', exist_ok=True)

# 列出目录内容
for item in os.listdir('.'):
    print(item)

# 使用 pathlib
current_dir = Path('.')
for item in current_dir.iterdir():
    if item.is_file():
        print(f"File: {item.name}")
    elif item.is_dir():
        print(f"Directory: {item.name}")

# 查找文件
# 使用 glob
python_files = glob.glob('*.py')
all_txt_files = glob.glob('**/*.txt', recursive=True)

# 使用 pathlib
python_files = list(Path('.').glob('*.py'))
all_txt_files = list(Path('.').rglob('*.txt'))

print(f"Python files: {python_files}")

import json
import csv
import pickle
from dataclasses import dataclass, asdict
import tempfile
import shutil

# JSON 文件处理
data = {
    "name": "Alice",
    "age": 30,
    "skills": ["Python", "Java", "Go"],
    "is_active": True
}

# 写入 JSON
with open('data.json', 'w', encoding='utf-8') as file:
    json.dump(data, file, indent=2, ensure_ascii=False)

# 读取 JSON
with open('data.json', 'r', encoding='utf-8') as file:
    loaded_data = json.load(file)
    print(loaded_data)

# CSV 文件处理
# 写入 CSV
employees = [
    ['Name', 'Age', 'Department', 'Salary'],
    ['Alice', 30, 'Engineering', 75000],
    ['Bob', 25, 'Marketing', 55000],
    ['Charlie', 35, 'Engineering', 85000]
]

with open('employees.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerows(employees)

# 读取 CSV
with open('employees.csv', 'r', encoding='utf-8') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

# 使用字典读取 CSV
with open('employees.csv', 'r', encoding='utf-8') as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(f"{row['Name']}: ${row['Salary']}")

# 序列化对象 (Pickle)
@dataclass
class Person:
    name: str
    age: int
    skills: list

person = Person("Alice", 30, ["Python", "Go"])

# 保存对象
with open('person.pkl', 'wb') as file:
    pickle.dump(person, file)

# 加载对象
with open('person.pkl', 'rb') as file:
    loaded_person = pickle.load(file)
    print(loaded_person)

# 临时文件
# 创建临时文件
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as temp_file:
    temp_file.write("Temporary content")
    temp_filename = temp_file.name

print(f"Temporary file: {temp_filename}")

# 创建临时目录
with tempfile.TemporaryDirectory() as temp_dir:
    print(f"Temporary directory: {temp_dir}")
    # 在这里使用临时目录
    temp_file_path = Path(temp_dir) / "temp_file.txt"
    temp_file_path.write_text("Content in temp directory")

# 文件操作工具
# 复制文件和目录
shutil.copy2('example.txt', 'backup_example.txt')  # 复制文件和元数据
shutil.copytree('source_dir', 'destination_dir')   # 复制整个目录树

# 移动/重命名
shutil.move('old_name.txt', 'new_name.txt')

# 删除
os.remove('file_to_delete.txt')        # 删除文件
shutil.rmtree('directory_to_delete')   # 删除目录树

# 文件监控
import time

def monitor_file_changes(file_path, interval=1):
    """监控文件变化"""
    last_modified = os.path.getmtime(file_path)

    while True:
        time.sleep(interval)
        current_modified = os.path.getmtime(file_path)

        if current_modified != last_modified:
            print(f"File {file_path} has been modified")
            last_modified = current_modified

# 批量文件处理
def process_text_files(directory, operation):
    """批量处理文本文件"""
    path = Path(directory)

    for txt_file in path.rglob('*.txt'):
        try:
            content = txt_file.read_text(encoding='utf-8')
            processed_content = operation(content)

            # 备份原文件
            backup_path = txt_file.with_suffix('.txt.bak')
            shutil.copy2(txt_file, backup_path)

            # 写入处理后的内容
            txt_file.write_text(processed_content, encoding='utf-8')
            print(f"Processed: {txt_file}")

        except Exception as e:
            print(f"Error processing {txt_file}: {e}")

# 使用示例
def uppercase_content(content):
    return content.upper()

# process_text_files('.', uppercase_content)

## ⚠️ 异常处理

### 1. 基础异常处理

```python
# 基本的 try-except 结构
try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except ValueError:
    print("Invalid input! Please enter a valid number.")
except ZeroDivisionError:
    print("Cannot divide by zero!")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
else:
    print("Operation completed successfully!")
finally:
    print("This always executes.")

# 捕获多种异常
try:
    file = open('nonexistent.txt', 'r')
    data = file.read()
    number = int(data)
except (FileNotFoundError, ValueError) as e:
    print(f"Error: {e}")

# 异常链
try:
    try:
        x = 1 / 0
    except ZeroDivisionError as e:
        raise ValueError("Value error occurred") from e
except ValueError as e:
    print(f"Caught: {e}")
    print(f"Original cause: {e.__cause__}")

# 重新抛出异常
def risky_operation():
    try:
        # 一些可能失败的操作
        result = 10 / 0
        return result
    except ZeroDivisionError:
        print("Logging the error...")
        raise  # 重新抛出相同的异常

try:
    risky_operation()
except ZeroDivisionError:
    print("Handled in outer scope")

# 自定义异常类
class CustomError(Exception):
    """基础自定义异常"""
    pass

class ValidationError(CustomError):
    """验证错误"""
    def __init__(self, field, value, message="Validation failed"):
        self.field = field
        self.value = value
        self.message = message
        super().__init__(f"{message}: {field}='{value}'")

class BusinessLogicError(CustomError):
    """业务逻辑错误"""
    def __init__(self, message, error_code=None):
        self.message = message
        self.error_code = error_code
        super().__init__(message)

# 使用自定义异常
def validate_age(age):
    """验证年龄"""
    if not isinstance(age, int):
        raise ValidationError("age", age, "Age must be an integer")
    if age < 0:
        raise ValidationError("age", age, "Age cannot be negative")
    if age > 150:
        raise ValidationError("age", age, "Age seems unrealistic")
    return True

def transfer_money(from_account, to_account, amount):
    """转账操作"""
    if from_account.balance < amount:
        raise BusinessLogicError(
            f"Insufficient funds. Available: {from_account.balance}, Required: {amount}",
            error_code="INSUFFICIENT_FUNDS"
        )

    # 执行转账逻辑
    from_account.balance -= amount
    to_account.balance += amount

# 使用示例
try:
    validate_age(-5)
except ValidationError as e:
    print(f"Validation failed: {e}")
    print(f"Field: {e.field}, Value: {e.value}")

# 上下文管理器与异常
class DatabaseConnection:
    """数据库连接上下文管理器"""

    def __init__(self, db_name):
        self.db_name = db_name
        self.connection = None

    def __enter__(self):
        print(f"Connecting to {self.db_name}")
        self.connection = f"Connection to {self.db_name}"
        return self.connection

    def __exit__(self, exc_type, exc_value, traceback):
        print(f"Closing connection to {self.db_name}")
        if exc_type is not None:
            print(f"An exception occurred: {exc_type.__name__}: {exc_value}")
            # 返回 False 表示不抑制异常
            return False
        return True

# 使用上下文管理器
try:
    with DatabaseConnection("mydb") as conn:
        print(f"Using {conn}")
        # raise ValueError("Something went wrong")
        print("Operations completed")
except ValueError as e:
    print(f"Caught exception: {e}")

# 函数装饰器用于异常处理
from functools import wraps
import logging

def exception_handler(logger=None, reraise=True):
    """异常处理装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                if logger:
                    logger.error(f"Exception in {func.__name__}: {e}")
                else:
                    print(f"Exception in {func.__name__}: {e}")

                if reraise:
                    raise
                return None
        return wrapper
    return decorator

@exception_handler(reraise=False)
def risky_function():
    """可能出错的函数"""
    return 10 / 0

result = risky_function()  # 不会抛出异常，返回 None

# 安装: pip install flask

from flask import Flask, request, jsonify, render_template
from datetime import datetime
import json

app = Flask(__name__)

# 基础路由
@app.route('/')
def home():
    return '<h1>Hello, Flask!</h1>'

@app.route('/about')
def about():
    return '<h1>About Page</h1>'

# 动态路由
@app.route('/user/<username>')
def show_user(username):
    return f'<h1>User: {username}</h1>'

@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'<h1>Post ID: {post_id}</h1>'

# HTTP 方法
@app.route('/submit', methods=['GET', 'POST'])
def submit():
    if request.method == 'POST':
        username = request.form['username']
        return f'<h1>Hello, {username}!</h1>'
    return '''
        <form method="post">
            <input type="text" name="username" placeholder="Enter your name">
            <input type="submit" value="Submit">
        </form>
    '''

# JSON API
users = [
    {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'},
    {'id': 2, 'name': 'Bob', 'email': 'bob@example.com'}
]

@app.route('/api/users')
def get_users():
    return jsonify(users)

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    user = next((u for u in users if u['id'] == user_id), None)
    if user:
        return jsonify(user)
    return jsonify({'error': 'User not found'}), 404

@app.route('/api/users', methods=['POST'])
def create_user():
    new_user = request.get_json()
    new_user['id'] = len(users) + 1
    users.append(new_user)
    return jsonify(new_user), 201

# 错误处理
@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    return jsonify({'error': 'Internal server error'}), 500

# 运行应用
if __name__ == '__main__':
    app.run(debug=True)

# Flask 应用结构示例
"""
myapp/
    app.py
    requirements.txt
    templates/
        base.html
        index.html
        user.html
    static/
        css/
            style.css
        js/
            main.js
    models/
        user.py
        post.py
    views/
        auth.py
        main.py
"""

# 模板使用 (Jinja2)
# templates/base.html
"""
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My App{% endblock %}</title>
</head>
<body>
    <nav>
        <a href="/">Home</a>
        <a href="/about">About</a>
    </nav>
    <main>
        {% block content %}{% endblock %}
    </main>
</body>
</html>
"""

# templates/index.html
"""
{% extends "base.html" %}

{% block title %}Home - My App{% endblock %}

{% block content %}
<h1>Welcome, {{ name }}!</h1>
<p>Current time: {{ current_time }}</p>

<ul>
{% for item in items %}
    <li>{{ item }}</li>
{% endfor %}
</ul>
{% endblock %}
"""

@app.route('/template-demo')
def template_demo():
    return render_template('index.html',
                         name='Alice',
                         current_time=datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                         items=['Python', 'Flask', 'Web Development'])

# Django 项目结构
"""
myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py
        asgi.py
    myapp/
        __init__.py
        admin.py
        apps.py
        models.py
        views.py
        urls.py
        migrations/
        templates/
        static/
"""

# models.py - 数据模型
from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone

class Category(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        verbose_name_plural = "Categories"

    def __str__(self):
        return self.name

class Post(models.Model):
    STATUS_CHOICES = [
        ('draft', 'Draft'),
        ('published', 'Published'),
    ]

    title = models.CharField(max_length=200)
    slug = models.SlugField(unique=True)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    published_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        ordering = ['-created_at']

    def __str__(self):
        return self.title

    def save(self, *args, **kwargs):
        if self.status == 'published' and not self.published_at:
            self.published_at = timezone.now()
        super().save(*args, **kwargs)

# views.py - 视图
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse
from django.views.generic import ListView, DetailView
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from .models import Post, Category

def home(request):
    """首页视图"""
    recent_posts = Post.objects.filter(status='published')[:5]
    return render(request, 'blog/home.html', {
        'recent_posts': recent_posts
    })

def post_detail(request, slug):
    """文章详情视图"""
    post = get_object_or_404(Post, slug=slug, status='published')
    return render(request, 'blog/post_detail.html', {
        'post': post
    })

class PostListView(ListView):
    """文章列表类视图"""
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 10

    def get_queryset(self):
        return Post.objects.filter(status='published')

class PostDetailView(DetailView):
    """文章详情类视图"""
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'

@login_required
def create_post(request):
    """创建文章视图"""
    if request.method == 'POST':
        # 处理表单提交
        pass
    return render(request, 'blog/create_post.html')

# API 视图
from django.views.decorators.csrf import csrf_exempt
import json

@csrf_exempt
def api_posts(request):
    """文章 API"""
    if request.method == 'GET':
        posts = Post.objects.filter(status='published').values(
            'id', 'title', 'slug', 'created_at'
        )
        return JsonResponse(list(posts), safe=False)

    elif request.method == 'POST':
        data = json.loads(request.body)
        post = Post.objects.create(
            title=data['title'],
            content=data['content'],
            author=request.user
        )
        return JsonResponse({
            'id': post.id,
            'title': post.title,
            'slug': post.slug
        })

# urls.py - URL 配置
from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.home, name='home'),
    path('posts/', views.PostListView.as_view(), name='post_list'),
    path('post/<slug:slug>/', views.PostDetailView.as_view(), name='post_detail'),
    path('create/', views.create_post, name='create_post'),
    path('api/posts/', views.api_posts, name='api_posts'),
]

# 项目主 urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),
]

# admin.py - 管理后台
from django.contrib import admin
from .models import Category, Post

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ['name', 'created_at']
    search_fields = ['name']

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ['title', 'author', 'category', 'status', 'created_at']
    list_filter = ['status', 'category', 'created_at']
    search_fields = ['title', 'content']
    prepopulated_fields = {'slug': ('title',)}
    date_hierarchy = 'created_at'

# 安装: pip install numpy
import numpy as np

# 创建数组
arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])

# 特殊数组
zeros = np.zeros((3, 4))          # 全零数组
ones = np.ones((2, 3))            # 全一数组
identity = np.eye(3)              # 单位矩阵
range_arr = np.arange(0, 10, 2)   # 范围数组: [0, 2, 4, 6, 8]
linspace = np.linspace(0, 1, 5)   # 线性空间: [0. 0.25 0.5 0.75 1.]

# 随机数组
random_arr = np.random.random((3, 3))        # [0,1) 均匀分布
normal_arr = np.random.normal(0, 1, (3, 3))  # 正态分布
randint_arr = np.random.randint(1, 10, (3, 3))  # 随机整数

# 数组操作
print(f"Shape: {arr2.shape}")        # (2, 3)
print(f"Size: {arr2.size}")          # 6
print(f"Dtype: {arr2.dtype}")        # int64

# 重塑数组
reshaped = arr2.reshape(3, 2)         # 重塑为 3x2
flattened = arr2.flatten()            # 展平为一维

# 数组运算
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

addition = a + b                      # [5, 7, 9]
multiplication = a * b                # [4, 10, 18]
power = a ** 2                        # [1, 4, 9]

# 矩阵运算
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])

matrix_mult = np.dot(matrix_a, matrix_b)  # 矩阵乘法
# 或使用 @ 操作符
matrix_mult = matrix_a @ matrix_b

# 统计函数
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(f"Mean: {np.mean(data)}")           # 5.5
print(f"Median: {np.median(data)}")       # 5.5
print(f"Std: {np.std(data)}")             # 2.87
print(f"Min: {np.min(data)}")             # 1
print(f"Max: {np.max(data)}")             # 10
print(f"Sum: {np.sum(data)}")             # 55

# 数组索引和切片
arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

print(arr[0, :])        # 第一行: [1 2 3 4]
print(arr[:, 1])        # 第二列: [2 6 10]
print(arr[1:, 2:])      # 子数组

# 布尔索引
mask = data > 5
filtered = data[mask]   # [6, 7, 8, 9, 10]

# 条件操作
result = np.where(data > 5, data, 0)  # 大于5的保留，否则为0

# 安装: pip install pandas
import pandas as pd
import numpy as np

# 创建 Series
s1 = pd.Series([1, 2, 3, 4, 5])
s2 = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])

# 创建 DataFrame
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'age': [25, 30, 35, 28],
    'city': ['NY', 'LA', 'Chicago', 'Houston'],
    'salary': [70000, 80000, 90000, 75000]
}

df = pd.DataFrame(data)
print(df.head())

# 从文件读取数据
# df = pd.read_csv('data.csv')
# df = pd.read_excel('data.xlsx')
# df = pd.read_json('data.json')

# 基本信息
print(df.info())
print(df.describe())
print(df.shape)
print(df.columns)
print(df.dtypes)

# 数据选择
print(df['name'])                    # 选择列
print(df[['name', 'age']])          # 选择多列
print(df.iloc[0])                   # 按位置选择行
print(df.loc[df['age'] > 30])       # 按条件选择行

# 数据过滤
young_people = df[df['age'] < 30]
high_earners = df[df['salary'] > 75000]
ny_people = df[df['city'] == 'NY']

# 多条件过滤
filtered = df[(df['age'] > 25) & (df['salary'] > 70000)]

# 数据操作
# 添加新列
df['bonus'] = df['salary'] * 0.1
df['age_group'] = df['age'].apply(lambda x: 'Young' if x < 30 else 'Experienced')

# 数据排序
sorted_by_age = df.sort_values('age')
sorted_by_multiple = df.sort_values(['city', 'age'], ascending=[True, False])

# 分组操作
grouped = df.groupby('city')
print(grouped['salary'].mean())     # 按城市计算平均薪资
print(grouped.agg({
    'salary': ['mean', 'max', 'min'],
    'age': 'mean'
}))

# 数据透视表
pivot_table = df.pivot_table(
    values='salary',
    index='city',
    columns='age_group',
    aggfunc='mean'
)

# 缺失值处理
# 创建带缺失值的数据
df_with_nan = df.copy()
df_with_nan.loc[1, 'salary'] = np.nan
df_with_nan.loc[2, 'age'] = np.nan

print(df_with_nan.isnull().sum())           # 统计缺失值
df_cleaned = df_with_nan.dropna()           # 删除含缺失值的行
df_filled = df_with_nan.fillna(0)           # 用0填充缺失值
df_filled_mean = df_with_nan.fillna(df_with_nan.mean())  # 用均值填充

# 字符串操作
df['name_upper'] = df['name'].str.upper()
df['name_length'] = df['name'].str.len()
df['is_alice'] = df['name'].str.contains('Alice')

# 日期时间处理
dates = pd.date_range('2024-01-01', periods=4, freq='D')
df['join_date'] = dates
df['year'] = df['join_date'].dt.year
df['month'] = df['join_date'].dt.month

# 数据合并
df1 = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie']
})

df2 = pd.DataFrame({
    'id': [1, 2, 4],
    'salary': [70000, 80000, 75000]
})

# 内连接
merged = pd.merge(df1, df2, on='id', how='inner')
# 左连接
left_merged = pd.merge(df1, df2, on='id', how='left')

# 数据导出
# df.to_csv('output.csv', index=False)
# df.to_excel('output.xlsx', index=False)
# df.to_json('output.json')