print("Hello World")  # 输出字符串
print(2025)           # 输出数字
print([1, 2, 3])      # 输出列表

name = "Alice"
age = 25
print(name, "年龄", age, sep="->")  # 输出：Alice->年龄->25

pi = 3.1415926
print(f"圆周率：{pi:.3f}")  # 输出：圆周率：3.142

print("坐标：({x}, {y})".format(x=10, y=20))

print("CPU使用率：%.1f%%" % 75.5)

print("Loading", end='')
print("...", end='')  # 输出：Loading...

import time
for i in range(5):
    print(".", end='', flush=True)
    time.sleep(1)  # 每秒输出一个点

print('''
第一行
第二行
第三行
''')

print("换行符：\\n")  # 输出：换行符：\n
print(r"原始字符串：C:\new_dir")  # 使用r前缀不转义

data = {"status": 200}
print(f"{data=}")  # 输出：data={'status': 200}

user_input = input("请输入内容：")
print(f"您输入的是：{user_input}（类型：{type(user_input)}）")

# 必须显式转换类型
age = int(input("请输入年龄："))  # 输入25 → 类型int
price = float(input("请输入价格："))  # 输入19.9 → 类型float

# 解包赋值（需保证输入格式）
x, y = map(int, input("输入两个数字（空格分隔）：").split())
print(f"x+y={x+y}")  # 输入"10 20" → 输出30

while True:
    try:
        num = int(input("请输入整数："))
        break
    except ValueError:
        print("输入无效，请重新输入！")

print("输入多行内容（空行结束）：")
lines = []
while (line := input()) != '':
    lines.append(line)
print(f"总行数：{len(lines)}")

from getpass import getpass
password = getpass("输入密码：")  # 输入时无回显

n = len(data)
if n > 10:
    print(n)

if (n := len(data)) > 10:
    print(n)

# 读取文件直到空行
lines = []
while (line := input()) != '':
    lines.append(line)

# 等效传统写法
while True:
    line = input()
    if line == '': break
    lines.append(line)

# 避免重复计算
data = [1, 2, 3, 4, 5]
doubled = [y for x in data if (y := x*2) < 8]
# 结果：[2, 4, 6]

import re
text = "2025-04-06更新日志"
if (match := re.search(r'\d{4}-\d{2}-\d{2}', text)):
    print(f"找到日期：{match.group()}")

  graph TD    A[表达式开始] --> B[执行右侧运算]    B --> C[赋值给左侧变量]    C --> D[返回赋值结果]    D --> E[参与表达式运算]

num = 42
print(type(num))  # <class 'int'>

lst = [1,2,3]
print(type(lst))  # <class 'list'>

Dog = type('Dog', (), {'bark': lambda self: print("Woof!")})
d = Dog()
d.bark()  # 输出: Woof!

# 类型检查
num = 3.14
print(isinstance(num, float))  # True
print(isinstance(num, (int, float)))  # True

class Animal: pass
class Dog(Animal): pass

d = Dog()
print(isinstance(d, Animal))  # True

# 安全类型检查
def safe_divide(a, b):
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise TypeError("参数必须是数字类型")
    return a / b

  flowchart TD    A((22))    A --> B((18))    A --> C((26))    B --> D((16))    B --> E((20))    D --> F((15))    D --> G((17))    E --> N((19))    E --> O((21))    C --> H((24))    C --> I((28))    H --> J((23))    H --> K((25))    I --> L((27))    I --> M((29))

s = "Python切片特性"
print(s[2:5])    # 输出: tho
print(s[::2])    # 输出: Pto切性

s = "ABCDE"
print(s[::-1])  # 输出: EDCBA（根据2024 Stack Overflow票选最佳技巧）

matrix = [[1,2,3], [4,5,6], [7,8,9]]
print(matrix[1:][::-1])  # 输出：[[7,8,9], [4,5,6]]

# 标准切片语法
sequence[start:end:step]

# 超出索引自动截断（2025 PyCon展示案例）
s = "Python"
print(s[2:100])  # 输出"thon"（实际end=5）

# 元组转列表（Django模型数据处理）
coordinates = (116.40, 39.91)
coord_list = list(coordinates)  # [116.4, 39.91]

# 字典键值转换（2025数据处理新技巧）
data_dict = {"A":1, "B":2}
keys_list = list(data_dict)      # ['A', 'B']（仅保留键）

# 验证地址相同
a = 100
b = 100
print(id(a) == id(b))  # True

# 超出范围地址不同
x = 300
y = 300
print(id(x) == id(y))  # False（交互式环境可能为True）

# Python（无此运算符）
i += 1  # 只能使用复合赋值

# Java（支持++/--）
i++;  // 等效i = i + 1

# Python（明确区分）
5 / 2   # 2.5（真除法）
5 // 2  # 2（整除）

# Java（统一行为）
5 / 2   // 2（自动取整）
(double)5 / 2 // 2.5

# Python特有语法
if 'a' in ['a', 'b', 'c']: ...

# Java需手动实现
List<String> list = Arrays.asList("a", "b", "c");
if (list.contains("a")) { ... }

if 条件1:    # 必须包含冒号
    代码块1  # 4空格缩进强制要求
elif 条件2:  # 可多个elif分支
    代码块2
else:       # 最终兜底分支
    代码块3

match status_code:
    case 200:
        print("Success")
    case 404:
        print("Not Found")
    case _:  # 默认分支
        print("Unknown Status")

# Python 3.10+ 类型匹配方案
def format_value(obj) -> str:
    match obj:
        case int(i):  # 匹配整型并解包值
            return f"int {i}"
        case str(s):  # 匹配字符串并解包值
            return f"String {s}"
        case _:       # 通配符匹配其他类型
            return "Unknown type"

# Java 模式匹配（21+）
String formatted = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case String s -> String.format("String %s", s);
    default -> "Unknown type";
};

# 遍历可迭代对象
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"当前水果：{fruit}")

# 结合range函数
for i in range(5, 10, 2):  # 5-9，步长2
    print(f"步长循环：{i}")

# 带else子句（循环正常结束时执行）
for x in range(3):
    print(x)
else:
    print("循环正常结束")

# 基础条件循环
count = 0
while count < 5:
    print(f"计数：{count}")
    count += 1

# 避免死循环模板
timeout = 10
start_time = time.time()
while time.time() - start_time < timeout:
    # 超时自动退出
    pass

# break示例（立即终止循环）
for num in range(10):
    if num == 5:
        print("检测到5，终止循环")
        break
    print(num)

# continue示例（跳过当前迭代）
for num in range(10):
    if num % 2 == 0:
        continue
    print(f"奇数：{num}")

# 字典遍历优化
user_info = {"name": "John", "age": 30, "city": "NY"}
for key, value in user_info.items():
    print(f"{key}: {value}")

# 多维数据处理
matrix = [[1, 2], [3, 4], [5, 6]]
for row in matrix:
    for num in row:
        print(num * 2)

# 实时数据监控模式（2025推荐）
import random
threshold = 0.8
while True:
    value = random.random()
    if value > threshold:
        print(f"警报！数值超标：{value:.2f}")
        break

# 2025验证案例
lst = [1, 2, 3]
lst[1] = "two"  # [1, 'two', 3]

complex_list = [2025, "AI", [3.14, True], {"key": "value"}]

# 高级切片技巧
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[1:3][0][::-1])  # 输出[6,5,4]

# Python 3.13+ 并行排序
import bisect
data = [5, 2, 8, 1]
bisect.insort(data, 4)  # 插入后自动保持有序 → [1,2,4,5,8]

# 生成5x5矩阵
matrix = [[i*5 + j for j in range(5)] for i in range(5)]

# 带异常处理的推导式
nums = [1, '2', 3, 'four', 5]
clean = [int(x) for x in nums if isinstance(x, (int, str)) and str(x).isdigit()]

# 内存优化方案（生成器表达式）
large_data = (x**2 for x in range(10**6) if x%3 ==0)

coordinates = (39.9042, 116.4074)
coordinates[0] = 40  # 引发TypeError

person = ("张三", 28, 175.5, ["Python", "Java"])
print(person[3][0])  # 输出"Python"

# 解包操作（Python 3.13增强）
name, age, *details = ("李四", 30, 180, "Engineer")
print(details)  # [180, 'Engineer']

# 模式匹配（Python 3.10+）
match ("A", 2025):
    case (_, y) if y > 2000:
        print(f"未来数据: {y}")

# 复数步长生成坐标序列
coords = range(0+0j, 5+5j, 1+1j)
print(list(coords))  # [(0+0j), (1+1j), (2+2j), (3+3j), (4+4j)]

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

import numpy as np
float_range = np.arange(1.5, 5.5, 0.5)  # [1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0]

# 安全范围检查
def safe_range(start, end):
    return range(max(0, start), min(1000000, end))

# 错误案例：空序列
empty = range(5, 2)  # 不报错但生成空序列

# 正确验证方法
if len(range(a, b)) > 0:
    do_something()

# 步长0异常处理
try:
    invalid = range(1,5,0)
except ValueError:
    print("步长不能为0")

# 标准创建
d1 = {"name": "Alice", "age": 30}

# 字典推导式（Python 3.13增强）
squares = {x: x**2 for x in range(10**6) if x%2 ==0}

# 类型构造器
d2 = dict([("height", 175), ("weight", 68)])

user_config = {"theme": "dark", "font_size": 14}

# 安全获取配置项，不存在时返回默认值
timeout = user_config.get("request_timeout", 30)  # 返回30
notifications = user_config.get("notifications", True)

# 合并操作符 |（Python 3.9+）
config = {"mode": "prod"} | {"debug": False}  # {'mode':'prod', 'debug':False}

# 批量更新
d.update([("temp", 26), ("humidity", 65)])

# 词频统计应用
text = "apple banana apple cherry banana apple"
word_counts = {}

for word in text.split():
    word_counts.setdefault(word, 0)  # 初始化计数器
    word_counts[word] += 1

print(word_counts)
# 输出：{'apple':3, 'banana':2, 'cherry':1}

# 实时交易系统（Python 3.13优化版）
price_data = {
    "AAPL": 189.3, 
    "TSLA": 245.6,
    "NVDA": 675.2
}

def get_price(symbol):
    try:
        return price_data[symbol] * 1.001  # 含手续费
    except KeyError:
        log_error(f"无效股票代码: {symbol}")
        return None

# 高频调用验证（已知存在的键）
%timeit -n 1000000 get_price("AAPL")
# 输出：118 ns ± 1.8 ns per loop

# 错误处理效率对比
%timeit -n 1000000 price_data.get("INVALID", 0)  # 210 ns
%timeit -n 1000000 try-except方式处理错误      # 仅触发时耗时

dict1 = {
    "name": "John",
    "age": 30,
    "city": "New York",
    "has_job": False
}

for k,v in dict1.items():
    print(f"键：{k},值：{v}")

# 多层结构
employees = {
    1001: {"name": "王伟", "dept": "研发", "skills": ["Python", "AI"]},
    1002: {"name": "李娜", "dept": "市场", "projects": {"2024": 3, "2025": 5}}
}

# 安全访问链
print(employees.get(1002, {}).get("projects", {}).get("2025"))  # 5

# 内存高效迭代
for k, v in d.items():
    process_data(k, v)

from typing import Dict, Union
UserProfile = Dict[str, Union[str, int, list]]

def validate_profile(data: UserProfile) -> bool:
    return "name" in data and "age" in data

# 使用collections.ChainMap
from collections import ChainMap
safe_config = ChainMap(user_settings, default_settings)

# 使用__slots__的字典子类
class OptimizedDict(dict):
    __slots__ = ()
    # 节省每个实例的内存开销（Python 3.13+）

try:
    # 可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"错误捕获：{e}")
else:
    print("正常执行时运行")
finally:
    print("无论是否异常都执行")

try:
    user_input = int("abc")
except (ValueError, TypeError) as e:
    print(f"输入类型错误：{e.__class__.__name__}")

try:
    open("non_exist.txt")
except FileNotFoundError as e:
    raise RuntimeError("文件操作失败") from e

with open("data.txt") as f:
    content = f.read()  # 自动处理文件关闭

try:
    a = int(input("Enter a number: "))
    b = int(input("Enter another number: "))
    print(a/b)
except ValueError:
    print("Invalid input")  # 控制台输出Invalid input
    raise
except ZeroDivisionError:
    raise Exception("Cannot divide by zero")  # 控制台输出Cannot divide by zero

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 ├── Exception
 │    ├── ValueError
 │    ├── TypeError
 │    ├── FileNotFoundError
 │    └── 40+其他异常...

class PasswordStrengthError(Exception):
    """2025密码安全标准异常"""
    def __init__(self, length):
        super().__init__(f"密码长度不足8位（当前：{length}）")
        self.required_length = 8

# 使用示例
try:
    if len(input_pwd) < 8:
        raise PasswordStrengthError(len(input_pwd))
except PasswordStrengthError as e:
    print(f"安全告警：{e}")

// 必须包含在类中
public class Calculator {
    // 显式返回类型
    public static int add(int a, int b) {
        return a + b;
    }
}

# 独立函数定义（2023新增类型提示）
def add(a: int, b: int) -> int:
    return a + b

# 多返回值示例
def get_user():
    return "Alice", 25, "alice@example.com"  # 返回元组

void modifyList(List<String> list) {
    list.add("new");  // 修改引用副本指向的对象
    list = new ArrayList<>();  // 不影响原始引用
}

public static void main(String[] args) {
    List<String> data = new ArrayList<>();
    modifyList(data);
    System.out.println(data);  // 输出 [new]
}

def modify_list(lst):
    lst.append("new")    # 修改原列表
    lst = [1, 2, 3]      # 新建局部变量

data = []
modify_list(data)
print(data)  # 输出 ['new']

def calculate_scores(name: str, *scores, **course_info):
    """
    计算学生成绩的多种统计值

    参数：
        name - 学生姓名（固定参数）
        *scores - 任意数量的考试成绩（可变位置参数）
        **course_info - 课程相关信息（可变关键字参数）
    """
    total = sum(scores)
    avg = total / len(scores) if scores else 0

    print(f"学生 {name}：")
    print(f"▪ 共参加 {len(scores)} 门考试")
    print(f"▪ 总分：{total} 平均分：{avg:.1f}")

    if course_info:
        print("课程详情：")
        for key, value in course_info.items():
            print(f"  - {key}: {value}")

calculate_scores("John", 80, 95, 72, 88, 100,
                  math=90, english=85, science=100)

def register_user(
        name: str,
        age: int,
        city: str = "北京",  # 缺省参数（2025最新推荐写法）
        membership: bool = False
) -> dict:
    """
    用户注册函数（支持缺省参数）

    参数：
        name - 必填姓名（位置参数）
        age  - 必填年龄（位置参数）
        city - 居住城市（默认北京）
        membership - 会员状态（默认非会员）

    返回：
        包含完整用户信息的字典
    """
    return {
        "name": name,
        "age": age,
        "city": city,
        "vip": membership,
        "reg_date": "2025-04-10"  # 模拟注册时间
    }

print("案例1：使用所有默认值")
user1 = register_user("张三", 25)
print(user1)

print("\n案例2：覆盖部分默认参数")
user2 = register_user("李四", 30, city="上海")
print(user2)

print("\n案例3：跳过默认参数指定")
user3 = register_user("王五", 28, membership=True)  # 显式使用参数名
print(user3)

public void demoScope() {
    int x = 10;
    if (true) {
        int y = 20;  // 仅在此块内有效
    }
    // System.out.println(y); 编译错误
}

def demo_scope():
    x = 10
    if True:
        y = 20  # 整个函数可见
    print(y)  # 正常输出20

# 全局变量处理
total = 0
def increment():
    global total
    total += 1

# 全局作用域变量
global_x = 10

def modify_global_without_keyword():
    """⚠️ 危险操作：尝试修改全局变量未声明global"""
    # 此处会创建新的局部变量，导致后续访问全局变量失败
    print("[错误尝试] 试图访问全局变量:", global_x)  # 会触发UnboundLocalError
    global_x = 50  # 实际创建新的局部变量

def show_local_scope():
    """✅ 正确局部变量使用"""
    local_y = 20
    print("[局部变量] 函数内访问:", local_y)

    # 代码块内的变量提升
    if True:
        block_z = 30
    print("[代码块变量] 跨块访问:", block_z)  # 仍然可见

def safely_modify_global():
    """✅ 正确修改全局变量"""
    global global_x  # 明确声明
    print("[修改前] 全局变量值:", global_x)
    global_x = 50
    print("[修改后] 全局变量值:", global_x)

# 初始状态验证
print("[初始状态] 全局变量:", global_x)

# 错误操作演示
try:
    modify_global_without_keyword()
except UnboundLocalError as e:
    print(f"❌ 错误捕获：{type(e).__name__} - 未声明global时不能修改全局变量")
    print("[安全恢复] 全局变量保持原值:", global_x)

# 局部变量访问测试
show_local_scope()

try:
    print("[危险操作] 尝试访问局部变量:", local_y)
except NameError as e:
    print(f"❌ 错误捕获：{type(e).__name__} - 局部变量不可外部访问")

# 正确修改全局变量
safely_modify_global()
print("[最终验证] 全局变量最新值:", global_x)

// 编译时类型检查
String concat(String a, int b) {
    return a + b;  // 自动转换b为String
}

def concat(a, b):
    return str(a) + str(b)  # 运行时处理类型

concat("num", 25)     # 正常返回"num25"
concat([1,2], {"k":"v"})  # 返回 "[1, 2]{'k': 'v'}"

List<Integer> nums = Arrays.asList(1, 2, 3);
List<Integer> doubled = nums.stream()
                           .map(n -> n * 2)
                           .collect(Collectors.toList());

# Lambda表达式
nums = [1, 2, 3]
doubled = list(map(lambda x: x*2, nums))

# 函数作为参数
def apply_operation(func, data):
    return [func(x) for x in data]

apply_operation(lambda x: x**3, nums)  # 返回[1, 8, 27]

from typing import Callable

# 通过变量注解实现类型声明
add: Callable[[int, int], int] = lambda x, y: x + y# [int,int]表示的是参数的数据类型，最后一个int表示的是返回值的数据类型

def sum_num(n):
    if n == 1:  # 终止条件
        return 1
    else:
        return n + sum_num(n-1)  # 递推关系

print(sum_num(5))  # 输出：15（计算5+4+3+2+1）

import os

def scan_dir(path, level=0):
    # 打印当前目录（缩进表示层级）
    print('  ' * level + '📁 ' + os.path.basename(path))

    for item in os.listdir(path):
        full_path = os.path.join(path, item)
        if os.path.isdir(full_path):  # 如果是文件夹
            scan_dir(full_path, level+1)  # 递归扫描子目录
        else:
            print('  ' * (level+1) + '📄 ' + item)  # 打印文件

scan_dir('/user/docs')  # 示例路径

map(function, iterable, *iterables) -> map object

def preprocess_01(data: list) -> map:
    return map(lambda x: x * 1.5, filter(lambda x: x>0, data))

list_01 = [0,-1,2,-3,4,-5,6,-7,8,-9]
after_process_01 = preprocess_01(list_01)
print(list(after_process_01))  # [3.0, 6.0, 9.0, 12.0]

def preprocess_02(data_1: list, data_2: list) -> map:
    return map(lambda x,y: x * 1.5 + y * 2.5, filter(lambda x: x>0, data_1), filter(lambda x: x<0, data_2))
list_02 = [0, 1, -2, 3, -4, 5, -6, 7, -8, 9]
after_process_02 = preprocess_02(list_01,list_02)
print(list(after_process_02)) # [-2.0, -4.0, -6.0, -8.0]

filter(function or None, iterable) -> filter object

示例：

# 示例1：基础数值过滤（含2025类型标注）
def filter_even(data: list[int]) -> filter:
    return filter(lambda x: x%2 == 0, data)

nums = [0, -3, 8, 15, 22, -40]
print(list(filter_even(nums)))  # [0, 8, 22, -40]

# 示例2：多阶段数据处理（过滤后转换）
def process_data(data: list[float]) -> map:
    filtered = filter(lambda x: x >= 0 and not x.is_integer(), data)
    return map(lambda x: round(x*10, 2), filtered)

samples = [3.14, -2.71, 5.0, 7.2, 9.999]
print(list(process_data(samples)))  # [31.4, 72.0, 99.99]

# 示例3：跨类型数据清洗（2025优化版）
def clean_mixed_data(data: list) -> filter:
    return filter(
        lambda item: (
            isinstance(item, int) and item > 0 or
            isinstance(item, str) and len(item) > 3
        ), 
        data
    )

mixed = [10, "py", -5, "data", 3.14, "AI"]
print(list(clean_mixed_data(mixed)))  # [10, 'data']

import math
print(math.sqrt(16))  # 4.0

from random import choice
print(choice([1,3,5,7]))  # 随机选一个数字

import pandas as pd
from datetime import datetime as dt

from turtle import *  # 所有函数直接可用
circle(100)          # 无需加模块名前缀

import importlib

# 动态导入数字开头的模块（无需重命名文件）
module = importlib.import_module("01_xxxx")

# 调用模块中的函数/变量
module.hello()

# 文件名：geometry.py
# 计算面积函数
def circle_area(r):
    return 3.14159 * r ** 2

# 判断三角形类型（2025新增类型注解）
def triangle_type(a: int, b: int, c: int) -> str:
    if a + b > c and a + c > b and b + c > a:
        return "Valid"
    return "Invalid"

import geometry

print(geometry.circle_area(3))          # 28.27431
print(geometry.triangle_type(3,4,5))    # Valid

# 查看已加载模块
import sys
print(sys.modules.keys())

# 查看模块位置
print(math.__file__)  # 显示math模块路径

my_project/
├── pyproject.toml         # 构建配置（替代setup.py）
├── src/
│   └── my_package/        # 包代码目录
│       ├── __init__.py
│       ├── core.py
│       └── utils/
│           ├── math.py
│           └── strings.py
├── tests/                 # 测试目录
└── requirements.txt       # 依赖清单

import sys
print(sys.path)  # 查看Python搜索路径

# 添加自定义路径（临时）
sys.path.append("/custom/module/path")

# 永久添加路径（2025新方案）
# 在pyproject.toml中配置：
# [tool.paths]
# package_dirs = ["src"]

# pyproject.toml
[build-system]
requires = ["setuptools>=65.0"]
build-backend = "setuptools.build_meta"

[project]
name = "my_package"
version = "0.1.0"
authors = [{name = "Your Name", email = "you@example.com"}]
description = "My awesome package"
dependencies = ["requests>=2.25"]

# 安装最新构建工具
pip install build twine

# 构建分发包（源码+wheel）
python -m build

# 上传到PyPI
twine upload dist/*

# 可编辑模式安装（代码修改实时生效）
pip install -e .

# my_package/__init__.py
# 空文件，仅标识目录为包

# my_package/__init__.py
print("包已加载！")  # 包导入时自动执行
from . import core  # 导入同级模块 core.py

# my_package/__init__.py
__all__ = ['utils', 'config']  # 定义允许导出的模块
from .utils import *  # 暴露 utils 模块的所有公共成员

# my_package/__init__.py
from .sub_pkg import *  # 导入子包中的所有模块
from .core import main_func  # 直接暴露核心函数

import random

def generate_code(length=6):
    chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    return ''.join(random.choice(chars) for _ in range(length))

print(generate_code())  # 输出如 '3X8T9Y'

data = list(range(10))
random.shuffle(data)  # 原地打乱
print(data)  # 输出如 [7, 2, 5, 0, 9, 1, 3, 8, 4, 6]

options = ['A', 'B', 'C']
weights = [0.2, 0.5, 0.3]  # 权重需总和为1
selected = random.choices(options, weights=weights, k=3)
print(selected)  # 输出如 ['B', 'B', 'C']

import secrets  # Python 3.6+ 专用安全模块

secure_num = secrets.randbelow(100)  # 生成 [0, 99] 的安全随机整数
print(secure_num)  # 输出如 42

r'\d'      # 匹配数字（等价于 [0-9]）
r'\w'      # 匹配字母/数字/下划线（等价于 [a-zA-Z0-9_]）
r'\s'      # 匹配空白符（空格、制表符等）
r'.'       # 匹配除换行外的任意字符
r'^abc'    # 匹配以 abc 开头
r'xyz$'    # 匹配以 xyz 结尾

r'a*'      # 匹配 0 次或多次（贪婪）
r'a+?'     # 匹配 1 次或多次（非贪婪）
r'a{2,5}'  # 匹配 2-5 次
r'a|b'     # 匹配 a 或 b

# 分组捕获
m = re.search(r'(\d{3})-(\d{4})', '电话：010-1234')
print(m.group(1))  # '010'

# 替换引用
re.sub(r'(\d+)/(\d+)', r'\2/\1', '3/14')  # → '14/3'

# 命名分组（2025 推荐写法）
re.search(r'(?P<area>\d{3})-(?P<num>\d{4})', '010-1234').group('area')  # → '010'

email_pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
print(re.match(email_pattern, 'user@example.com') is not None)  # True

text = "联系电话：010-12345678 或 0755-7654321"
phones = re.findall(r'\d{3,4}-\d{7,8}', text)  # → ['010-12345678', '0755-7654321']

html = '<div class="title">Hello World</div>'
content = re.search(r'<div.*?>(.*?)</div>', html).group(1)  # → 'Hello World'

sensitive_words = ['bad', 'danger']
pattern = re.compile('|'.join(sensitive_words), flags=re.IGNORECASE)
text = 'This is a BAD example.'
clean_text = pattern.sub('***', text)  # → 'This is a *** example.'

# 错误：未转义特殊字符
re.search(r'example.com', 'exampleAcom')  # 错误匹配
re.search(r'example\.com', 'example.com') # 正确

# 错误：贪婪模式导致意外匹配
re.search(r'<div>.*</div>', '<div>a</div><div>b</div>').group()  # 匹配整个字符串
re.search(r'<div>.*?</div>', '<div>a</div>...')  # 正确（非贪婪）

import socket

# 1. 创建Socket对象
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 2. 绑定地址和端口
server_socket.bind(('localhost', 8888))

# 3. 开启监听（最大连接数设为5）
server_socket.listen(5)
print("服务端已启动，等待连接...")

try:
    while True:
        # 4. 接受客户端连接（阻塞等待）
        client_socket, addr = server_socket.accept()
        print(f"客户端 {addr} 已连接")

        # 5. 接收数据（最大1024字节）
        data = client_socket.recv(1024)
        print(f"收到数据：{data.decode('utf-8')}")

        # 6. 发送响应
        client_socket.sendall(b'Hello from server!')

        # 7. 关闭当前客户端连接
        client_socket.close()
finally:
    # 8. 关闭服务端Socket
    server_socket.close()

import socket

# 1. 创建Socket对象
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

try:
    # 2. 连接服务器
    client_socket.connect(('localhost', 8888))

    # 3. 发送数据
    client_socket.sendall(b'Hello from client!')

    # 4. 接收响应（最大1024字节）
    response = client_socket.recv(1024)
    print(f"服务器响应：{response.decode('utf-8')}")

finally:
    # 5. 关闭连接
    client_socket.close()

  graph LR    A["Python第三方库分类"] --> B[Web开发]    A --> C[游戏开发]    A --> D[数据科学]    A --> E[机器学习/深度学习]    A --> F[GUI开发]    A --> G[文件处理]    A --> H[自然语言处理]    A --> I[图像处理]    A --> J[实用工具]    %% Web开发（2025年主流框架）    B --> B1("Django (全栈框架)")    B --> B2("Flask (微框架)")    B --> B3("Pyramid (可扩展框架)")    %% 游戏开发（最新游戏引擎支持）    C --> C1("Pygame (2D游戏开发)")    C --> C2("Panda3D (3D游戏引擎)")    C --> C3("cocos2d (移动端游戏)")    %% 数据科学（2025年核心库）    D --> D1("numpy (数值计算)")    D --> D2("pandas (数据分析)")    D --> D3("matplotlib (数据可视化)")    D --> D4("scipy (科学计算)")    D --> D5("mayavi (3D可视化)")    %% 机器学习/深度学习（最新AI工具链）    E --> E1("scikit-learn (传统机器学习)")    E --> E2("Tensorflow (深度学习框架)")    E --> E3("Theano (数值计算)")    %% GUI开发（跨平台解决方案）    F --> F1("PyQT5 (QT界面开发)")    F --> F2("wxPython (跨平台GUI)")    F --> F3("pyGTK (GNOME应用)")    %% 文件处理（2025文档处理方案）    G --> G1("pdfminer (PDF解析)")    G --> G2("openpyxl (Excel操作)")    G --> G3("python-docx (Word处理)")    %% 自然语言处理（NLP工具）    H --> H1("NLTK (自然语言工具包)")    %% 图像处理（最新图形技术）    I --> I1("PIL (图像处理库)")    I --> I2("MyQR (二维码生成)")    %% 实用工具（2025流行工具）    J --> J1("Scrapy (爬虫框架)")    J --> J2("WeRoBot (微信机器人)")    J --> J3("beautifulsoup4 (HTML解析)")    J --> J4("Sympy (符号数学)")

  graph LR    A[Python文件操作] --> B[基础操作]    A --> C[读写模式]    A --> D[上下文管理]    A --> E[异常处理]    A --> F[高级功能]B --> B1["open()函数"]B --> B2[路径处理 os.path]B --> B3[文件元数据]C --> C1[文本模式 r/w/a]C --> C2[二进制模式 rb/wb/ab]C --> C3[读写组合 r+/w+/a+]D --> D1[with语句]D --> D2[自动关闭文件]E --> E1[try-except块]E --> E2[OSError处理]F --> F1[内存映射 mmap]F --> F2[临时文件 tempfile]F --> F3[目录操作 os]

open(
    file, 
    mode='r', 
    buffering=-1, 
    encoding=None, 
    errors=None, 
    newline=None, 
    closefd=True, 
    opener=None
)

from pathlib import Path
file_path = Path("data/2025_log.txt")

# 处理图片/视频等二进制文件
with open("video.mp4", "rb") as f:
    data = f.read()

# 不推荐（使用系统默认编码）
open("file.txt", "r")  
# 正确写法
open("file.txt", "r", encoding="utf-8")

# 处理老旧系统生成的GBK文件
with open("old_file.txt", "r", encoding="gbk", errors="replace") as f:
    content = f.read()

with ContextManager() as resource:
    # 在此使用资源

from pathlib import Path

# 现代路径管理+with语句（2025推荐写法）
log_file = Path("logs/app_2025.log")

with log_file.open("a", encoding="utf-8") as f:
    f.write(f"[{datetime.now().isoformat()}] SYSTEM_OK\n")

# 新型异步数据库连接（2025新特性）
async with aio_db.connect() as conn:
    await conn.execute("UPDATE data SET status=1")

import threading

lock = threading.Lock()
with lock:  # 自动获取和释放锁
    shared_data.append(new_item)

class DatabaseTransaction:
    def __enter__(self):
        self.conn = connect_db()
        self.conn.begin()
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is None:
            self.conn.commit()
        else:
            self.conn.rollback()
        self.conn.close()

# 使用示例
with DatabaseTransaction() as db:
    db.execute("INSERT INTO logs VALUES (...)")

# 同时打开输入输出文件
with (open("source.csv", "r") as src,
      open("processed.parquet", "wb") as dst):
    process_data(src, dst)  # 数据流式处理

from pathlib import Path  # Python 3.4+ 推荐方式

# 使用pathlib（跨平台友好）
current_dir = Path.cwd()# 返回当前目录的绝对路径
all_items = list(current_dir.iterdir())  # 包含文件和目录

# 过滤特定类型文件
py_files = [f for f in current_dir.glob('*.py') if f.is_file()]

from pathlib import Path

file_path = Path('data.txt')
print(f"""
文件存在: {file_path.exists()}
是否为文件: {file_path.is_file()}
文件大小: {file_path.stat().st_size} bytes
最后修改时间: {file_path.stat().st_mtime} (Unix时间戳)
""")

from pathlib import Path

new_file = Path('new_data.txt')
try:
    new_file.touch(exist_ok=False)  # 避免覆盖已有文件
except FileExistsError:
    print("文件已存在！")

from pathlib import Path

new_dir = Path('project/docs/2025')
new_dir.mkdir(parents=True, exist_ok=True)  # 自动创建不存在的父目录

from pathlib import Path

target_file = Path('temp.txt')
if target_file.exists():
    target_file.unlink()  # 等价于 os.remove
else:
    print("文件不存在")

from pathlib import Path
import shutil

def safe_remove_dir(dir_path):
    dir_path = Path(dir_path)
    if dir_path.exists():
        shutil.rmtree(dir_path, onerror=handle_errors)

def handle_errors(func, path, exc_info):
    # 自定义错误处理（如文件被占用时的重试逻辑）
    print(f"删除失败: {path}")

src = Path('old_name.txt')
dst = Path('new_name.txt')

try:
    src.replace(dst)  # 原子操作，跨文件系统自动复制+删除
except FileNotFoundError:
    print("源文件不存在")

with open('data.txt', 'r+', encoding='utf-8') as f:
    content = f.read()
    new_content = content.replace('old', 'new')
    f.seek(0)  # 回到文件开头
    f.write(new_content)
    f.truncate()  # 截断多余内容

config_path = Path('config') / 'app' / 'settings.yaml'  # 自动适配不同系统路径分隔符

from tempfile import NamedTemporaryFile

with NamedTemporaryFile(delete=False) as tmp:
    tmp.write(b'临时数据')
    tmp_path = tmp.name  # 获取临时文件路径
# 结束后手动删除
Path(tmp_path).unlink()

# 需安装：pip install watchfiles
from watchfiles import watch

for changes in watch('./data'):
    print(f'检测到文件变化: {changes}')

# 使用pathlib自动管理资源
file_path = Path("data.txt")
try:
    content = file_path.read_text(encoding="utf-8")
except FileNotFoundError:
    print("文件不存在")
except UnicodeDecodeError:
    print("编码错误")

with open("image.png", "rb") as f:
    while chunk := f.read(4096):  # 分块读取大文件
        process(chunk)

output_path = Path("output.log")
try:
    output_path.write_text("2025年最新数据\n", encoding="utf-8", errors="replace")
except PermissionError:
    print("无写入权限")

with open("app.log", "a", encoding="utf-8") as f:
    f.write(f"[{datetime.now()}] 系统运行正常\n")

file_path = Path("config.ini")
try:
    with file_path.open("r+", encoding="utf-8") as f:
        content = f.read()
        new_content = content.replace("old_value", "new_value")
        f.seek(0)
        f.write(new_content)
        f.truncate()  # 截断多余内容
except IOError as e:
    print(f"修改失败: {e}")

temp_path = Path("temp.txt")
with temp_path.open("w") as tmp:
    tmp.write("新内容")

temp_path.replace("original.txt")

Path("clear.txt").write_text("")  # 安全清空

target = Path("obsolete.dat")
try:
    target.unlink(missing_ok=True)  # 等效于os.remove
except PermissionError:
    print("删除权限不足")

with io.StringIO() as buffer:
    buffer.write("内存临时数据")
    buffer.seek(0)
    print(buffer.read())

with open("large.bin", "rb+") as f:
    f.seek(1024)
    f.write(b"NEW_BLOCK_DATA")  # 直接修改指定位置数据

import aiofiles

async def async_write():
    async with aiofiles.open("async.log", "w") as f:
        await f.write("异步写入内容")

  def deposit(self, amount):  # 公开方法  
      if amount > 0:  
          self.__balance += amount

class Robot:
    def __init__(self, name):
        self.name = name  # 初始化实例属性

robot = Robot("Optimus")  # 自动调用__init__

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

dog = Animal("小黄")
dog.age = 5# 添加了额外属性

class SafeAnimal:
    __slots__ = ("name", "age")  # 白名单限制

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

rabbit = SafeAnimal("Bunny")
rabbit.age = 2  # 允许 ✅
rabbit.weight = 1.5  # AttributeError ❌

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

    def __setattr__(self, name, value):
        if not hasattr(self, name):
            raise AttributeError(f"禁止动态添加属性：{name}")
        super().__setattr__(name, value)

fox = StrictAnimal("Foxy")
fox.age = 3  # AttributeError ❌

class User:
    def __init__(self, name):
        self.name = name  # 存入__dict__

u = User("Alice")
print(u.__dict__)  # 输出：{'name': 'Alice'}

# 动态添加属性
u.__dict__["age"] = 25  # 等价于 u.age = 25
# 动态删除属性
del u.__dict__["name"]  # 等价于 del u.name

import json
# 对象转JSON（需先转为字典）
user_dict = u.__dict__.copy()
user_dict["timestamp"] = 20250421  # 扩展数据
json_data = json.dumps(user_dict)

# 批量修改属性
for key in u.__dict__:
    if isinstance(u.__dict__[key], str):
        u.__dict__[key] = u.__dict__[key].upper()

# 属性访问拦截
class LoggedUser(User):
    def __getattribute__(self, name):
        print(f"访问属性: {name}")
        return super().__getattribute__(name)

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance  # 实例属性

    def deposit(self, amount):  # 必须包含self
        self.balance += amount

class Circle:
    pi = 3.14   # 静态属性

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

    def get_area(self):
        return self.pi * self.radius ** 2

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_str):  # 从"YYYY-MM-DD"字符串创建实例
        year, month, day = map(int, date_str.split("-"))
        return cls(year, month, day)

# 使用类方法创建实例（无需手动解析）
date = Date.from_string("2025-05-01")

class Animal:
    @classmethod
    def create(cls, animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Unknown animal type")

class Dog(Animal): pass
class Cat(Animal): pass

# 通过工厂方法创建对象
pet = Animal.create("dog")

class Logger:
    _log_level = "INFO"

    @classmethod
    def set_log_level(cls, level):
        cls._log_level = level.upper()

# 直接修改类属性
Logger.set_log_level("debug")
print(Logger._log_level)  # 输出: DEBUG

class Car:
    wheels = 4  # 类属性

    def __init__(self, brand):
        self.brand = brand  # 实例属性

    @classmethod
    def change_wheels(cls, num):
        cls.wheels = num    # 修改类属性
        print(f"All cars now have {cls.wheels} wheels.")

# 通过类名调用类方法
Car.change_wheels(6)        # 输出: All cars now have 6 wheels.
print(Car.wheels)           # 输出: 6

# 实例也可调用（但逻辑仍作用于类）
my_car = Car("Tesla")
my_car.change_wheels(8)     # 输出: All cars now have 8 wheels.

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b  # 纯计算逻辑，无类/实例依赖

# 调用方式
print(MathUtils.add(3, 5))  # 输出: 8 (推荐类名调用)
obj = MathUtils()
print(obj.add(2, 3))        # 输出: 5 (通过实例调用，但不推荐)

class Logger:
    pass

def log_message(message):
    print(f"[LOG] {message}")

Logger.log = staticmethod(log_message)  # 动态添加静态方法
Logger.log("System started")  # 输出: [LOG] System started

class DateValidator:
    @staticmethod
    def is_valid_date(year, month, day):
        # 独立于类状态的日期验证逻辑
        try:
            datetime.datetime(year, month, day)
            return True
        except ValueError:
            return False

print(DateValidator.is_valid_date(2025, 13, 1))  # 输出: False

class Geometry:
    @staticmethod
    def circle_area(radius):
        return 3.14159 * radius ** 2  # 无需类/实例数据

print(Geometry.circle_area(3))  # 输出: 28.27431

class StringProcessor:
    @staticmethod
    def reverse(s):
        return s[::-1]  # 逻辑独立，但组织在相关类中

print(StringProcessor.reverse("hello"))  # 输出: olleh

class Dog(Animal):  # 括号内指定父类
    pass

class Dog extends Animal {  // 使用extends关键字
    //...
}

class A:
    def __init__(self):
        print("A")
        super().__init__()

class B:
    def __init__(self):
        print("B")
        super().__init__()

class C(A, B):
    def __init__(self):
        print("C")
        super().__init__()

obj = C()

C → A → B → object

C.mro() = [C, A, B, object]

print(ClassName.__mro__)
# 或
print(ClassName.mro())

class A:
    def __init__(self):
        print("A")  # 未调用super()

class B(A):
    def __init__(self):
        print("B")
        super().__init__()

class C(B, int):  # 继承内置类型
    def __init__(self):
        print("C")
        super().__init__()

obj = C()  # 输出：C → B → A（int未初始化）

class D(Parent1, Parent2):
    def __init__(self):
        Parent2.__init__(self)  # 绕过MRO直接调用
        Parent1.__init__(self)

# 基类定义
class Animal:
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

# 子类重写方法
class Dog(Animal):
    def speak(self):
        return "汪汪！"

class Cat(Animal):
    def speak(self):
        return "喵～"

class Duck:
    # 无继承关系但实现相同方法（鸭子类型）
    def speak(self):
        return "嘎嘎！"

# 统一调用方法
def animal_sound(obj):
    print(obj.speak())

# 测试多态
animal_sound(Dog())    # 输出：汪汪！
animal_sound(Cat())    # 输出：喵～
animal_sound(Duck())   # 输出：嘎嘎！ （无需继承）

from typing import Protocol

# 定义协议（替代抽象基类）
class Shape(Protocol):
    def area(self) -> float: ...

# 不同图形实现
class Circle:
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.1415 * self.radius ** 2

class Rectangle:
    def __init__(self, w: float, h: float):
        self.width = w
        self.height = h

    def area(self) -> float:
        return self.width * self.height

# 统一处理函数
def print_area(obj: Shape):
    print(f"图形面积：{obj.area():.2f}")

# 测试
print_area(Circle(3))      # 输出：28.27
print_area(Rectangle(4,5)) # 输出：20.00

class Account:
    def __init__(self, balance):
        self._balance = balance  # 单下划线约定为"受保护"属性

acc = Account(100)
print(acc._balance)  # 仍可访问（非强制）

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 双下划线触发名称修饰

    def get_balance(self):
        return self.__balance

acc = BankAccount(500)
#print(acc.__balance)         # ❌ 报错：AttributeError
print(acc._BankAccount__balance)  # ✅ 500（了解机制但不要主动使用）

class User:
    def __init__(self, name):
        self.__name = name

    @property                  # Getter方法
    def name(self):
        return self.__name.upper()

    @name.setter               # Setter方法
    def name(self, new_name):
        if len(new_name) >= 3:
            self.__name = new_name
        else:
            print("姓名至少3个字符！")

u = User("Alice")
print(u.name)          # ✅ ALICE
u.name = "Bob"         # ✅ 修改成功
u.name = "A"           # ❌ 输出警告，拒绝修改

class BankAccount:
    def __init__(self, name, initial_balance=0):
        self.__name = name                # 私有属性
        self.__balance = initial_balance  # 私有属性

    # 公开方法（接口）
    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self.__balance += amount
            print(f"存款成功，余额：{self.__balance}")
        else:
            print("存款金额必须大于0")

    def withdraw(self, amount):
        """取款"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"取款成功，余额：{self.__balance}")
        else:
            print("余额不足或金额无效")

    # 通过属性访问器控制数据
    @property
    def balance(self):
        return self.__balance

# 使用示例
acc = BankAccount("张三", 1000)
acc.deposit(500)    # ✅ 存款成功，余额：1500
acc.withdraw(2000)  # ❌ 余额不足
acc.withdraw(800)   # ✅ 取款成功，余额：700
print(acc.balance)  # ✅ 700（只读属性）

class TimeMachine:
    def __new__(cls, year):  # 创建实例（早于__init__执行）
        print(f"🕰️ 正在创建{year}年的时光机...")
        return super().__new__(cls)

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

    def __del__(self):  # 对象销毁时触发
        print(f"💥 {self.year}年的时光机已销毁")

machine = TimeMachine(2025)  # 输出：🕰️ 正在创建2025年的时光机...
del machine                  # 输出：💥 2025年的时光机已销毁

class Vector3D:
    def __init__(self, x, y, z):
        self.x, self.y, self.z = x, y, z

    def __add__(self, other):  # 实现向量加法
        return Vector3D(self.x+other.x, self.y+other.y, self.z+other.z)

    def __str__(self):  # 定义print输出格式
        return f"Vector3D({self.x}, {self.y}, {self.z})"

v1 = Vector3D(1,2,3)
v2 = Vector3D(4,5,6)
print(v1 + v2)  # 输出：Vector3D(5, 7, 9)

class Playlist:
    def __init__(self, songs):
        self.songs = list(songs)

    def __getitem__(self, index):  # 支持下标访问
        return self.songs[index]

    def __len__(self):  # 响应len()函数
        return len(self.songs)

    def __contains__(self, song):  # 支持in运算符
        return song in self.songs

my_list = Playlist(["孤勇者", "晴天"])
print(len(my_list))     # 输出：2
print("晴天" in my_list) # 输出：True

class DatabaseConnection:
    def __enter__(self):
        print("🔗 数据库连接已建立")
        return self  # 返回连接对象

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("🚪 数据库连接已关闭")

with DatabaseConnection() as conn:  # 自动管理资源
    print("执行数据库操作...")