# 整数类型 - 无限精度
big_int = 2 ** 1000  # Python支持任意大整数
print(type(big_int))  # <class 'int'="">

# 浮点数类型 - IEEE 754双精度
pi = 3.141592653589793
print(f"浮点数精度：{pi:.15f}")

# 复数类型
z = 3 + 4j
print(f"复数模长：{abs(z)}")  # 5.0

# 布尔值 - 整数子类
print(True + True)  # 2
print(isinstance(True, int))  # True

# 字符串不可变性验证
s1 = "hello"
s2 = s1
s1 += " world"
print(f"s1: {s1}, s2: {s2}")  # s1: hello world, s2: hello
print(f"id相同: {id(s1) == id(s2)}")  # False

# 字符串intern机制
a = "python"
b = "python"
print(f"字符串intern: {a is b}")  # True

# 字符串格式化性能对比
import timeit

# f-string (最快)
def f_string_format():
    name, age = "Alice", 25
    return f"Name: {name}, Age: {age}"

# str.format()
def str_format():
    name, age = "Alice", 25
    return "Name: {}, Age: {}".format(name, age)

# % 格式化
def percent_format():
    name, age = "Alice", 25
    return "Name: %s, Age: %d" % (name, age)

print("f-string 性能最优")

# 列表与元组性能对比
import sys

list_obj = [1, 2, 3, 4, 5]
tuple_obj = (1, 2, 3, 4, 5)

print(f"列表内存占用: {sys.getsizeof(list_obj)} bytes")
print(f"元组内存占用: {sys.getsizeof(tuple_obj)} bytes")

# 字典内部结构演示
class HashDict:
    """简化的字典实现，展示哈希表原理"""
    def __init__(self, size=8):
        self.size = size
        self.buckets = [[] for _ in range(size)]

    def _hash(self, key):
        return hash(key) % self.size

    def put(self, key, value):
        bucket = self.buckets[self._hash(key)]
        for i, (k, v) in enumerate(bucket):
            if k == key:
                bucket[i] = (key, value)
                return
        bucket.append((key, value))

    def get(self, key):
        bucket = self.buckets[self._hash(key)]
        for k, v in bucket:
            if k == key:
                return v
        raise KeyError(key)

# 演示哈希冲突
hash_dict = HashDict(4)
hash_dict.put("a", 1)
hash_dict.put("b", 2)
print(f"获取值: {hash_dict.get('a')}")

# 三元运算符
result = "positive" if x > 0 else "non-positive"

# 链式比较
if 0 < x < 10:
    print("x在0到10之间")

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

# 只有当condition为False时才会执行expensive_function
condition = True
result = condition or expensive_function()

# match-case语句 (Python 3.10+)
def handle_data(data):
    match data:
        case int() if data > 0:
            return f"正整数: {data}"
        case int() if data < 0:
            return f"负整数: {data}"
        case 0:
            return "零"
        case str() if len(data) > 0:
            return f"非空字符串: {data}"
        case []:
            return "空列表"
        case [x] if isinstance(x, int):
            return f"单元素整数列表: {x}"
        case [x, y]:
            return f"双元素列表: {x}, {y}"
        case {"name": str(name), "age": int(age)}:
            return f"人员信息: {name}, {age}岁"
        case _:
            return "未知类型"

# 测试match-case
print(handle_data(42))  # 正整数: 42
print(handle_data([1, 2]))  # 双元素列表: 1, 2
print(handle_data({"name": "Alice", "age": 25}))  # 人员信息: Alice, 25岁

# enumerate获取索引和值
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")

# zip并行迭代
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['New York', 'London', 'Tokyo']

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

# zip_longest处理不等长序列
from itertools import zip_longest

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c', 'd', 'e']

for num, letter in zip_longest(list1, list2, fillvalue=0):
    print(f"{num} - {letter}")

# 列表推导式的高级用法
# 带条件的列表推导式
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)]

# 字典推导式
word_lengths = {word: len(word) for word in ['python', 'java', 'go']}

# 集合推导式
unique_lengths = {len(word) for word in ['python', 'java', 'go', 'rust']}

# 生成器表达式（内存友好）
large_squares = (x**2 for x in range(1000000))

# 参数类型完整示例
def complex_function(
    pos_only, /,                    # 仅位置参数
    pos_or_kw,                      # 位置或关键字参数
    *args,                          # 可变位置参数
    kw_only,                        # 仅关键字参数
    kw_with_default="default",      # 带默认值的关键字参数
    **kwargs                        # 可变关键字参数
):
    print(f"pos_only: {pos_only}")
    print(f"pos_or_kw: {pos_or_kw}")
    print(f"args: {args}")
    print(f"kw_only: {kw_only}")
    print(f"kw_with_default: {kw_with_default}")
    print(f"kwargs: {kwargs}")

# 调用示例
complex_function(
    1,                              # pos_only
    2,                              # pos_or_kw
    3, 4, 5,                        # args
    kw_only="required",             # kw_only
    extra1="value1",                # kwargs
    extra2="value2"                 # kwargs
)

# 函数注解与类型提示
from typing import List, Dict, Optional, Union, Callable

def process_data(
    data: List[int],
    multiplier: float = 1.0,
    formatter: Optional[Callable[[float], str]] = None
) -> Dict[str, Union[int, float, str]]:
    """
    处理数据并返回统计信息

    Args:
        data: 整数列表
        multiplier: 乘数因子
        formatter: 可选的格式化函数

    Returns:
        包含统计信息的字典
    """
    total = sum(data) * multiplier
    avg = total / len(data) if data else 0

    result = {
        "count": len(data),
        "total": total,
        "average": avg
    }

    if formatter:
        result["formatted_total"] = formatter(total)

    return result

# 使用示例
numbers = [1, 2, 3, 4, 5]
stats = process_data(numbers, 2.0, lambda x: f"${x:.2f}")
print(stats)

# LEGB作用域演示
builtin_name = "内置"  # 这实际上会覆盖内置作用域

global_var = "全局变量"

def outer_function():
    enclosing_var = "闭包变量"

    def inner_function():
        local_var = "局部变量"

        # 演示作用域查找顺序
        print(f"局部: {local_var}")
        print(f"闭包: {enclosing_var}")
        print(f"全局: {global_var}")

        # 使用nonlocal修改闭包变量
        nonlocal enclosing_var
        enclosing_var = "修改后的闭包变量"

        # 使用global修改全局变量
        global global_var
        global_var = "修改后的全局变量"

    inner_function()
    print(f"外层函数中的闭包变量: {enclosing_var}")
    return inner_function

# 闭包示例
def create_multiplier(factor):
    """创建一个乘法器闭包"""
    def multiplier(x):
        return x * factor
    return multiplier

double = create_multiplier(2)
triple = create_multiplier(3)

print(f"double(5) = {double(5)}")  # 10
print(f"triple(5) = {triple(5)}")  # 15

# 查看闭包变量
print(f"double的闭包变量: {double.__closure__[0].cell_contents}")  # 2

# 模块搜索路径
import sys
print("Python模块搜索路径:")
for path in sys.path:
    print(f"  {path}")

# 动态导入模块
import importlib

def dynamic_import(module_name, function_name):
    """动态导入模块中的函数"""
    try:
        module = importlib.import_module(module_name)
        function = getattr(module, function_name)
        return function
    except (ImportError, AttributeError) as e:
        print(f"导入失败: {e}")
        return None

# 模块重新加载
def reload_module(module):
    """重新加载模块（开发时有用）"""
    return importlib.reload(module)

# 相对导入和绝对导入
# 包结构示例：
# myproject/
#   __init__.py
#   main.py
#   utils/
#     __init__.py
#     helpers.py
#     math_utils.py

# 在 myproject/main.py 中：
# 绝对导入
# from myproject.utils.helpers import some_function

# 相对导入
# from .utils.helpers import some_function
# from ..other_package import other_function

# __init__.py 文件的高级用法
# mypackage/__init__.py

# 控制 from mypackage import * 的行为
__all__ = ['PublicClass', 'public_function']

# 包级别的初始化代码
print(f"正在初始化包: {__name__}")

# 延迟导入，避免循环依赖
def get_heavy_module():
    """延迟导入重型模块"""
    import heavy_module
    return heavy_module

# 版本信息
__version__ = "1.0.0"
__author__ = "Your Name"

# 子模块的便捷访问
from .submodule import important_function

class PublicClass:
    """包的公共类"""
    pass

def public_function():
    """包的公共函数"""
    pass

# 包的命名空间包（PEP 420）
# 不需要 __init__.py 文件，允许分布式包结构

myproject/
├── README.md
├── setup.py
├── requirements.txt
├── myproject/
│   ├── __init__.py
│   ├── main.py
│   ├── config.py
│   ├── core/
│   │   ├── __init__.py
│   │   ├── models.py
│   │   └── services.py
│   ├── utils/
│   │   ├── __init__.py
│   │   ├── helpers.py
│   │   └── validators.py
│   └── tests/
│       ├── __init__.py
│       ├── test_core.py
│       └── test_utils.py
└── docs/
    └── api.md

import os
import platform
from pathlib import Path

# 获取环境变量
path_var = os.environ.get('PATH', '')
home_dir = os.environ.get('HOME') or os.environ.get('USERPROFILE')
username = os.environ.get('USER') or os.environ.get('USERNAME')
temp_dir = os.environ.get('TEMP') or os.environ.get('TMP') or '/tmp'

print(f"当前用户: {username}")
print(f"用户主目录: {home_dir}")
print(f"临时目录: {temp_dir}")

# 设置环境变量（仅当前进程有效）
os.environ['CUSTOM_VAR'] = 'my_value'
print(f"自定义变量: {os.environ.get('CUSTOM_VAR')}")

# 检查常见开发环境变量
dev_vars = ['PYTHON_PATH', 'JAVA_HOME', 'NODE_PATH']
for var in dev_vars:
    value = os.environ.get(var, '未设置')
    print(f"{var}: {value}")

# 路径操作基础
current_dir = os.getcwd()  # 获取当前工作目录
script_dir = os.path.dirname(os.path.abspath(__file__))  # 脚本所在目录

# 路径拼接和分解
sample_path = os.path.join(current_dir, 'data', 'sample.txt')
dirname, filename = os.path.split(sample_path)
name, ext = os.path.splitext(filename)

print(f"拼接路径: {sample_path}")
print(f"目录: {dirname}, 文件名: {name}, 扩展名: {ext}")

# 路径检查
print(f"路径存在: {os.path.exists(current_dir)}")
print(f"是否目录: {os.path.isdir(current_dir)}")
print(f"是否文件: {os.path.isfile(current_dir)}")

# 列出目录内容
try:
    items = os.listdir(current_dir)
    files = [item for item in items if os.path.isfile(os.path.join(current_dir, item))]
    dirs = [item for item in items if os.path.isdir(os.path.join(current_dir, item))]
    print(f"目录包含 {len(items)} 个项目")
except PermissionError:
    print("没有权限访问目录")

# 文件基本操作
sample_file = 'example.txt'

# 创建和写入文件
with open(sample_file, 'w', encoding='utf-8') as f:
    f.write("Hello, World!\n")
    f.write("这是中文内容\n")

# 读取文件
with open(sample_file, 'r', encoding='utf-8') as f:
    content = f.read()
    print(f"文件内容:\n{content}")

# 文件信息获取
if os.path.exists(sample_file):
    file_stat = os.stat(sample_file)
    print(f"文件大小: {file_stat.st_size} 字节")
    print(f"修改时间: {file_stat.st_mtime}")
    
    # 清理文件
    os.remove(sample_file)
    print("文件已删除")

from pathlib import Path

# Path对象创建
current_path = Path.cwd()
home_path = Path.home()
config_path = home_path / '.config' / 'myapp' / 'settings.json'

# 路径属性访问
sample_path = Path('data/files/document.txt')
print(f"父目录: {sample_path.parent}")
print(f"文件名: {sample_path.name}")
print(f"文件主名: {sample_path.stem}")
print(f"扩展名: {sample_path.suffix}")

# 路径操作
print(f"绝对路径: {sample_path.resolve()}")
print(f"是否存在: {sample_path.exists()}")

# 文件操作
test_file = Path('test.txt')
test_file.write_text('Hello, pathlib!', encoding='utf-8')
content = test_file.read_text(encoding='utf-8')
print(f"文件内容: {content}")
test_file.unlink()  # 删除文件

import subprocess
import sys
import os

# run()方法 - 推荐使用
# 简单命令执行
result = subprocess.run(['ls', '-la'], capture_output=True, text=True)
print(f"返回码: {result.returncode}")
print(f"标准输出: {result.stdout}")
print(f"标准错误: {result.stderr}")

# Windows兼容性
if sys.platform.startswith('win'):
    result = subprocess.run(['dir'], shell=True, capture_output=True, text=True)
else:
    result = subprocess.run(['ls', '-la'], capture_output=True, text=True)

# 带错误处理的执行
try:
    result = subprocess.run(
        ['python', '--version'], 
        capture_output=True, 
        text=True, 
        check=True  # 如果返回码非0则抛出异常
    )
    print(f"Python版本: {result.stdout.strip()}")
except subprocess.CalledProcessError as e:
    print(f"命令执行失败: {e}")
    print(f"错误输出: {e.stderr}")

# Popen类 - 更高级的进程控制
proc = subprocess.Popen(
    ['ping', 'google.com'], 
    stdout=subprocess.PIPE, 
    stderr=subprocess.PIPE,
    text=True
)

# 非阻塞方式检查进程状态
print(f"进程ID: {proc.pid}")
print(f"进程状态: {proc.poll()}")

# 等待进程完成并获取输出
stdout, stderr = proc.communicate(timeout=10)
print(f"输出: {stdout[:200]}...")  # 只显示前200个字符

# 进程超时处理
try:
    result = subprocess.run(
        ['sleep', '5'], 
        timeout=3,  # 3秒超时
        capture_output=True
    )
except subprocess.TimeoutExpired:
    print("命令执行超时")

# 管道操作 - 将一个命令的输出传给另一个命令
if not sys.platform.startswith('win'):
    # Unix/Linux系统
    p1 = subprocess.Popen(['ls', '-la'], stdout=subprocess.PIPE)
    p2 = subprocess.Popen(['grep', 'py'], stdin=p1.stdout, stdout=subprocess.PIPE, text=True)
    p1.stdout.close()  # 允许p1在p2退出时接收到SIGPIPE
    output, _ = p2.communicate()
    print(f"Python文件: {output}")
else:
    # Windows系统
    result = subprocess.run(
        'dir | findstr ".py"', 
        shell=True, 
        capture_output=True, 
        text=True
    )
    print(f"Python文件: {result.stdout}")

# 输出重定向到文件
with open('output.txt', 'w') as f:
    subprocess.run(['echo', 'Hello, World!'], stdout=f, text=True)

# 从文件输入
with open('input.txt', 'w') as f:
    f.write('line1\nline2\nline3\n')

with open('input.txt', 'r') as f:
    result = subprocess.run(['sort'], stdin=f, capture_output=True, text=True)
    print(f"排序结果: {result.stdout}")

# 清理文件
for file in ['output.txt', 'input.txt']:
    if os.path.exists(file):
        os.remove(file)

# 设置环境变量
my_env = os.environ.copy()
my_env['CUSTOM_VAR'] = 'my_value'

result = subprocess.run(
    ['python', '-c', 'import os; print(os.environ.get("CUSTOM_VAR"))'],
    env=my_env,
    capture_output=True,
    text=True
)
print(f"环境变量值: {result.stdout.strip()}")

# 设置工作目录
temp_dir = '/tmp' if not sys.platform.startswith('win') else os.environ.get('TEMP')
result = subprocess.run(
    ['pwd'] if not sys.platform.startswith('win') else ['cd'],
    cwd=temp_dir,
    capture_output=True,
    text=True,
    shell=sys.platform.startswith('win')
)
print(f"当前目录: {result.stdout.strip()}")

def run_command(cmd, timeout=30, cwd=None, env=None):
    """安全执行系统命令的通用函数"""
    try:
        if isinstance(cmd, str):
            # 字符串命令需要shell=True
            result = subprocess.run(
                cmd,
                shell=True,
                capture_output=True,
                text=True,
                timeout=timeout,
                cwd=cwd,
                env=env
            )
        else:
            # 列表命令更安全
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                timeout=timeout,
                cwd=cwd,
                env=env
            )
        
        return {
            'success': result.returncode == 0,
            'returncode': result.returncode,
            'stdout': result.stdout,
            'stderr': result.stderr
        }
    
    except subprocess.TimeoutExpired:
        return {
            'success': False,
            'returncode': -1,
            'stdout': '',
            'stderr': 'Command timed out'
        }
    except Exception as e:
        return {
            'success': False,
            'returncode': -1,
            'stdout': '',
            'stderr': str(e)
        }

# 使用示例
result = run_command(['python', '--version'])
if result['success']:
    print(f"命令成功: {result['stdout']}")
else:
    print(f"命令失败: {result['stderr']}")

import json
from datetime import datetime
from decimal import Decimal

# Python对象转JSON字符串
data = {
    'name': '张三',
    'age': 25,
    'city': '北京',
    'skills': ['Python', 'JavaScript', 'SQL'],
    'is_active': True,
    'score': 95.5,
    'address': None
}

# 序列化（Python -> JSON）
json_string = json.dumps(data, ensure_ascii=False, indent=2)
print(f"JSON字符串:\n{json_string}")

# 反序列化（JSON -> Python）
parsed_data = json.loads(json_string)
print(f"\n解析后的数据: {parsed_data}")
print(f"数据类型: {type(parsed_data)}")

# 类型映射关系
type_mapping = {
    'Python dict': '→ JSON object',
    'Python list': '→ JSON array',
    'Python str': '→ JSON string',
    'Python int/float': '→ JSON number',
    'Python True/False': '→ JSON true/false',
    'Python None': '→ JSON null'
}
print("\n类型映射:")
for py_type, json_type in type_mapping.items():
    print(f"  {py_type} {json_type}")

# 写入JSON文件
config_data = {
    'database': {
        'host': 'localhost',
        'port': 5432,
        'name': 'myapp',
        'credentials': {
            'username': 'admin',
            'password': 'secret123'
        }
    },
    'logging': {
        'level': 'INFO',
        'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    },
    'features': {
        'enable_cache': True,
        'max_connections': 100,
        'timeout': 30.0
    }
}

# 保存到文件
with open('config.json', 'w', encoding='utf-8') as f:
    json.dump(config_data, f, ensure_ascii=False, indent=4)
print("配置文件已保存")

# 从文件读取
with open('config.json', 'r', encoding='utf-8') as f:
    loaded_config = json.load(f)

print(f"\n加载的配置: {loaded_config['database']['host']}")
print(f"日志级别: {loaded_config['logging']['level']}")

# 清理文件
import os
if os.path.exists('config.json'):
    os.remove('config.json')

# 参数详解
sample_data = {
    'chinese': '中文测试',
    'numbers': [1, 2, 3],
    'nested': {'key': 'value'}
}

# ensure_ascii参数
print("不同编码方式:")
print(f"ASCII编码: {json.dumps(sample_data, ensure_ascii=True)}")
print(f"UTF-8编码: {json.dumps(sample_data, ensure_ascii=False)}")

# indent参数控制缩进
print(f"\n无缩进: {json.dumps(sample_data, ensure_ascii=False)}")
print(f"\n2个空格缩进:\n{json.dumps(sample_data, ensure_ascii=False, indent=2)}")
print(f"\nTab缩进:\n{json.dumps(sample_data, ensure_ascii=False, indent='\t')}")

# separators参数控制分隔符
compact = json.dumps(sample_data, separators=(',', ':'), ensure_ascii=False)
print(f"\n紧凑格式: {compact}")

# sort_keys参数排序
print(f"\n键排序: {json.dumps(sample_data, sort_keys=True, ensure_ascii=False)}")

# JSON解析错误处理
invalid_json_samples = [
    '{"name": "John", "age": 25,}',  # 末尾逗号
    '{"name": "John", age: 25}',      # 键名没有引号
    '{"name": "John", "age": undefined}',  # undefined值
    '{"data": [1, 2, 3}',           # 缺少右方括号
]

for i, invalid_json in enumerate(invalid_json_samples, 1):
    try:
        result = json.loads(invalid_json)
        print(f"样本{i}解析成功: {result}")
    except json.JSONDecodeError as e:
        print(f"样本{i}解析失败: {e}")
        print(f"  错误位置: 第{e.lineno}行, 第{e.colno}列")
        print(f"  错误信息: {e.msg}")

# JSON有效性检查函数
def is_valid_json(json_string):
    """检查JSON字符串是否有效"""
    try:
        json.loads(json_string)
        return True
    except json.JSONDecodeError:
        return False

# 测试有效性
test_strings = [
    '{"name": "valid"}',
    '{"name": "invalid",}',
    'null',
    'true',
    '123',
    '"string"'
]

for test_str in test_strings:
    print(f"'{test_str}' 是否有效: {is_valid_json(test_str)}")

# 自定义编码器处理特殊类型
class CustomJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        elif isinstance(obj, Decimal):
            return float(obj)
        elif isinstance(obj, set):
            return list(obj)
        elif hasattr(obj, '__dict__'):
            return obj.__dict__
        return super().default(obj)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.created_at = datetime.now()

# 测试数据
complex_data = {
    'person': Person('李四', 30),
    'timestamp': datetime.now(),
    'price': Decimal('99.99'),
    'tags': {'python', 'json', 'tutorial'},
    'count': 42
}

# 使用自定义编码器
custom_json = json.dumps(complex_data, cls=CustomJSONEncoder, ensure_ascii=False, indent=2)
print(f"自定义编码结果:\n{custom_json}")

# 自定义解码器
def custom_decoder(dct):
    """自定义JSON解码器"""
    # 尝试将ISO格式字符串转为日期
    for key, value in dct.items():
        if isinstance(value, str) and 'T' in value and value.endswith('Z'):
            try:
                dct[key] = datetime.fromisoformat(value.replace('Z', '+00:00'))
            except ValueError:
                pass
    return dct

# 使用自定义解码器
json_with_dates = '{"event": "meeting", "start_time": "2024-03-15T14:30:00Z"}'
parsed_with_dates = json.loads(json_with_dates, object_hook=custom_decoder)
print(f"\n解码结果: {parsed_with_dates}")
print(f"日期类型: {type(parsed_with_dates['start_time'])}")

from datetime import datetime, date, time, timedelta, timezone
import time as time_module
import calendar

# 获取当前时间
now = datetime.now()
today = date.today()
current_time = time_module.time()

print(f"当前日期时间: {now}")
print(f"今天日期: {today}")
print(f"时间戳: {current_time}")

# 创建特定日期时间
specific_date = date(2024, 3, 15)
specific_datetime = datetime(2024, 3, 15, 14, 30, 0)
specific_time = time(14, 30, 0)

print(f"指定日期: {specific_date}")
print(f"指定日期时间: {specific_datetime}")
print(f"指定时间: {specific_time}")

# 从时间戳创建datetime对象
timestamp = 1710505800
from_timestamp = datetime.fromtimestamp(timestamp)
print(f"从时间戳创建: {from_timestamp}")

# 常用格式化方式
now = datetime.now()

print(f"标准格式: {now.strftime('%Y-%m-%d %H:%M:%S')}")
print(f"中文格式: {now.strftime('%Y年%m月%d日 %H时%M分')}")
print(f"ISO格式: {now.isoformat()}")
print(f"美式格式: {now.strftime('%m/%d/%Y %I:%M %p')}")
print(f"欧式格式: {now.strftime('%d.%m.%Y %H:%M')}")
print(f"详细格式: {now.strftime('%A, %B %d, %Y at %I:%M %p')}")

# 常用格式化符号
format_codes = {
    '%Y': '四位数年份 (2024)',
    '%y': '两位数年份 (24)',
    '%m': '月份(01-12)',
    '%B': '完整月份名 (March)',
    '%b': '简写月份名 (Mar)',
    '%d': '日期(01-31)',
    '%H': '小时(00-23)',
    '%I': '小时(01-12)',
    '%M': '分钟(00-59)',
    '%S': '秒数(00-59)',
    '%A': '完整星期名 (Monday)',
    '%a': '简写星期名 (Mon)',
    '%p': 'AM/PM'
}

print("\n常用格式化符号:")
for code, desc in format_codes.items():
    example = now.strftime(code)
    print(f"  {code}: {desc} -> {example}")

# 字符串解析为日期时间
date_strings = [
    ('2024-03-15 14:30:00', '%Y-%m-%d %H:%M:%S'),
    ('15/03/2024', '%d/%m/%Y'),
    ('Mar 15, 2024', '%b %d, %Y'),
    ('2024-03-15T14:30:00', '%Y-%m-%dT%H:%M:%S'),
    ('March 15, 2024 2:30 PM', '%B %d, %Y %I:%M %p')
]

print("日期字符串解析:")
for date_str, format_str in date_strings:
    try:
        parsed = datetime.strptime(date_str, format_str)
        print(f"  '{date_str}' -> {parsed}")
    except ValueError as e:
        print(f"  '{date_str}' 解析失败: {e}")

# 日期时间计算
now = datetime.now()

# 加减时间
future = now + timedelta(days=7, hours=3, minutes=30, seconds=45)
past = now - timedelta(weeks=2, days=3)

print(f"\n时间计算:")
print(f"当前时间: {now}")
print(f"7天3小时30分45秒后: {future}")
print(f"2周3天前: {past}")

# 时间间隔计算
time_diff = future - now
print(f"时间间隔: {time_diff}")
print(f"总秒数: {time_diff.total_seconds()}")
print(f"总天数: {time_diff.days}")
print(f"总小时数: {time_diff.total_seconds() / 3600:.2f}")

# 特殊日期计算
print(f"\n特殊日期计算:")

# 本月第一天和最后一天
first_day = today.replace(day=1)
next_month = (first_day + timedelta(days=32)).replace(day=1)
last_day = next_month - timedelta(days=1)

print(f"本月第一天: {first_day}")
print(f"本月最后一天: {last_day}")

# 星期计算
weekday_name = calendar.day_name[today.weekday()]
print(f"今天是: {weekday_name}")
print(f"今天是本周第{today.weekday() + 1}天")

# UTC时间处理
utc_now = datetime.now(timezone.utc)
local_now = datetime.now()

print(f"UTC时间: {utc_now}")
print(f"本地时间: {local_now}")
print(f"时区偏移: {local_now.utcoffset()}")

# 时区转换
from datetime import timezone

# 创建特定时区
beijing_tz = timezone(timedelta(hours=8))
tokyo_tz = timezone(timedelta(hours=9))

# 时区转换
beijing_time = utc_now.astimezone(beijing_tz)
tokyo_time = utc_now.astimezone(tokyo_tz)

print(f"北京时间: {beijing_time}")
print(f"东京时间: {tokyo_time}")

# 实用函数示例
def get_age(birth_date):
    """计算年龄"""
    today = date.today()
    age = today.year - birth_date.year
    if today.month < birth_date.month or (today.month == birth_date.month and today.day < birth_date.day):
        age -= 1
    return age

def is_business_day(check_date):
    """判断是否为工作日"""
    return check_date.weekday() < 5  # 0-4是周一到周五

def get_month_range(year, month):
    """获取指定月份的开始和结束日期"""
    start_date = date(year, month, 1)
    if month == 12:
        end_date = date(year + 1, 1, 1) - timedelta(days=1)
    else:
        end_date = date(year, month + 1, 1) - timedelta(days=1)
    return start_date, end_date

def get_quarter_start(check_date):
    """获取季度开始日期"""
    quarter = (check_date.month - 1) // 3 + 1
    return date(check_date.year, (quarter - 1) * 3 + 1, 1)

def days_until_weekend(check_date):
    """计算距离周末还有几天"""
    days_ahead = 5 - check_date.weekday()  # 5是周六
    if days_ahead <= 0:  # 已经是周末
        return 0
    return days_ahead

# 测试实用函数
birth_date = date(1990, 5, 15)
today = date.today()

print(f"\n实用函数示例:")
print(f"出生日期 {birth_date} 对应年龄: {get_age(birth_date)}岁")
print(f"今天是否为工作日: {'是' if is_business_day(today) else '否'}")

start, end = get_month_range(2024, 3)
print(f"2024年3月范围: {start} 到 {end}")

quarter_start = get_quarter_start(today)
print(f"当前季度开始: {quarter_start}")

weekend_days = days_until_weekend(today)
print(f"距离周末还有: {weekend_days}天")

# 时间性能测试
def time_function(func, *args, **kwargs):
    """测试函数执行时间"""
    start_time = datetime.now()
    result = func(*args, **kwargs)
    end_time = datetime.now()
    execution_time = end_time - start_time
    
    return result, execution_time.total_seconds()

# 示例：测试列表排序时间
import random
test_list = [random.randint(1, 1000) for _ in range(10000)]
result, exec_time = time_function(sorted, test_list)
print(f"\n排序10000个数字耗时: {exec_time:.4f}秒")

# 日志时间戳格式化
def log_timestamp():
    """生成日志时间戳"""
    return datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]

# 文件名时间戳
def filename_timestamp():
    """生成用于文件名的时间戳"""
    return datetime.now().strftime('%Y%m%d_%H%M%S')

# 计算程序运行时间
class Timer:
    def __init__(self):
        self.start_time = None
    
    def start(self):
        self.start_time = datetime.now()
    
    def stop(self):
        if self.start_time:
            end_time = datetime.now()
            duration = end_time - self.start_time
            return duration.total_seconds()
        return 0
    
    def __enter__(self):
        self.start()
        return self
    
    def __exit__(self, *args):
        return self.stop()

# 使用示例
print(f"\n应用场景示例:")
print(f"日志时间戳: {log_timestamp()}")
print(f"文件名时间戳: {filename_timestamp()}")

# 使用定时器
with Timer() as timer:
    time_module.sleep(0.1)  # 模拟耗时操作
    duration = timer.stop()
print(f"操作耗时: {duration:.3f}秒")

# 计算两个日期之间的工作日
def count_business_days(start_date, end_date):
    """计算两个日期之间的工作日数量"""
    current = start_date
    business_days = 0
    
    while current <= end_date:
        if is_business_day(current):
            business_days += 1
        current += timedelta(days=1)
    
    return business_days

start = date(2024, 3, 1)
end = date(2024, 3, 31)
business_day_count = count_business_days(start, end)
print(f"2024年3月工作日数量: {business_day_count}天")

import re

# 基本匹配函数
text = "Hello, my phone number is 138-1234-5678, email is [email protected]"

# search() - 查找第一个匹配
phone_pattern = r'\d{3}-\d{4}-\d{4}'
phone_match = re.search(phone_pattern, text)
if phone_match:
    print(f"找到电话: {phone_match.group()}")
    print(f"位置: {phone_match.start()}-{phone_match.end()}")

# findall() - 查找所有匹配
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
emails = re.findall(email_pattern, text)
print(f"找到的邮箱: {emails}")

# match() - 从字符串开头匹配
greeting_pattern = r'Hello'
if re.match(greeting_pattern, text):
    print("文本以Hello开头")

# fullmatch() - 完整匹配
full_pattern = r'Hello.*com'
if re.fullmatch(full_pattern, text):
    print("整个文本匹配模式")

# 分组捕获
log_text = "2024-03-15 14:30:25 ERROR Database connection failed"
log_pattern = r'(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) (\w+) (.+)'

match = re.search(log_pattern, log_text)
if match:
    date_part = match.group(1)
    time_part = match.group(2)
    level = match.group(3)
    message = match.group(4)
    
    print(f"日期: {date_part}")
    print(f"时间: {time_part}")
    print(f"级别: {level}")
    print(f"消息: {message}")
    
    # 获取所有分组
    print(f"所有分组: {match.groups()}")

# 命名分组
named_pattern = r'(?P<date>\d{4}-\d{2}-\d{2}) (?P<time>\d{2}:\d{2}:\d{2}) (?P<level>\w+) (?P<message>.+)'
named_match = re.search(named_pattern, log_text)
if named_match:
    print(f"\n命名分组结果: {named_match.groupdict()}")
    print(f"错误级别: {named_match.group('level')}")

# sub() - 替换
original_text = "手机号码是138-1234-5678，联系电话139-8765-4321"
phone_pattern = r'\d{3}-\d{4}-\d{4}'

# 替换为隐藏格式
hidden_text = re.sub(phone_pattern, '***-****-****', original_text)
print(f"隐藏后: {hidden_text}")

# 使用函数替换
def mask_phone(match):
    phone = match.group()
    return phone[:3] + '-****-' + phone[-4:]

masked_text = re.sub(phone_pattern, mask_phone, original_text)
print(f"部分隐藏: {masked_text}")

# split() - 分割
data = "apple,banana;orange:grape|kiwi"
fruits = re.split(r'[,;:|]', data)
print(f"分割结果: {fruits}")

# subn() - 替换并返回次数
result, count = re.subn(phone_pattern, '[PHONE]', original_text)
print(f"替换{count}次后: {result}")

# 常用正则表达式模式
patterns = {
    '邮箱': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
    '手机号': r'1[3-9]\d{9}',
    'IP地址': r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b',
    'URL': r'https?://(?:[-\w.])+(?:[:\d]+)?(?:/(?:[\w/_.])*(?:\?(?:[\w&=%.])*)?(?:#(?:[\w.])*)?)?',
    '身份证': r'\d{17}[\dXx]',
    '中文': r'[\u4e00-\u9fff]+',
    '数字': r'-?\d+(?:\.\d+)?',
    '日期': r'\d{4}-\d{2}-\d{2}'
}

test_text = """
联系信息:
邮箱: [email protected]
手机: 13812345678
网站: https://www.example.com/page?id=123
IP: 192.168.1.100
日期: 2024-03-15
价格: 99.99元
姓名: 张三
"""

print("模式匹配结果:")
for name, pattern in patterns.items():
    matches = re.findall(pattern, test_text)
    if matches:
        print(f"{name}: {matches}")

from collections import Counter, defaultdict, OrderedDict, namedtuple, deque

# Counter基本用法
text = "hello world python programming"
char_count = Counter(text)
print(f"字符计数: {char_count}")
print(f"最常见的3个字符: {char_count.most_common(3)}")

# 列表元素计数
fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
fruit_count = Counter(fruits)
print(f"\n水果计数: {fruit_count}")
print(f"苹果数量: {fruit_count['apple']}")
print(f"最常见的水果: {fruit_count.most_common(1)}")

# Counter的数学运算
c1 = Counter(['a', 'b', 'c', 'a', 'b', 'b'])
c2 = Counter(['a', 'b', 'b', 'd', 'd', 'd'])

print(f"\nCounter运算:")
print(f"c1: {c1}")
print(f"c2: {c2}")
print(f"c1 + c2: {c1 + c2}")
print(f"c1 - c2: {c1 - c2}")
print(f"c1 & c2 (交集): {c1 & c2}")
print(f"c1 | c2 (并集): {c1 | c2}")

# 实际应用示例
def analyze_text(text):
    """文本分析函数"""
    words = text.lower().split()
    word_count = Counter(words)
    
    return {
        'total_words': len(words),
        'unique_words': len(word_count),
        'most_common': word_count.most_common(5),
        'word_frequency': dict(word_count)
    }

sample_text = "Python is great Python is powerful Python programming is fun"
analysis = analyze_text(sample_text)
print(f"\n文本分析结果: {analysis}")

# defaultdict基本用法
# 普通字典的问题
regular_dict = {}
# regular_dict['missing_key'].append('value')  # 这会引发KeyError

# defaultdict解决方案
dd_list = defaultdict(list)
dd_list['fruits'].append('apple')
dd_list['fruits'].append('banana')
dd_list['colors'].append('red')
print(f"defaultdict(list): {dict(dd_list)}")

dd_int = defaultdict(int)
dd_int['count'] += 1
dd_int['count'] += 5
print(f"defaultdict(int): {dict(dd_int)}")

dd_set = defaultdict(set)
dd_set['tags'].add('python')
dd_set['tags'].add('programming')
dd_set['tags'].add('python')  # 集合自动去重
print(f"defaultdict(set): {dict(dd_set)}")

# 实际应用: 按类别分组
students = [
    {'name': '张三', 'grade': 'A', 'subject': '数学'},
    {'name': '李四', 'grade': 'B', 'subject': '数学'},
    {'name': '王五', 'grade': 'A', 'subject': '物理'},
    {'name': '赵六', 'grade': 'C', 'subject': '数学'},
]

# 按成绩分组
grade_groups = defaultdict(list)
for student in students:
    grade_groups[student['grade']].append(student['name'])

print(f"\n按成绩分组: {dict(grade_groups)}")

# 按学科统计
subject_count = defaultdict(int)
for student in students:
    subject_count[student['subject']] += 1

print(f"学科人数统计: {dict(subject_count)}")

# namedtuple创建
Person = namedtuple('Person', ['name', 'age', 'city'])
Point = namedtuple('Point', 'x y')
Student = namedtuple('Student', 'name grade subjects')

# 创建实例
person = Person('张三', 25, '北京')
point = Point(10, 20)
student = Student('李四', 'A', ['math', 'physics'])

print(f"Person: {person}")
print(f"Point: {point}")
print(f"Student: {student}")

# 访问属性
print(f"\n属性访问:")
print(f"姓名: {person.name}")
print(f"年龄: {person.age}")
print(f"坐标: ({point.x}, {point.y})")

# namedtuple的方法
print(f"\nnamedtuple方法:")
print(f"字段名: {person._fields}")
print(f"转为字典: {person._asdict()}")

# _replace方法(创建新实例)
new_person = person._replace(age=26, city='上海')
print(f"更新后: {new_person}")

# 从列表创建
data = ['王五', 30, '广州']
person_from_list = Person._make(data)
print(f"从列表创建: {person_from_list}")

# 实际应用: 数据结构
Employee = namedtuple('Employee', 'id name department salary')

employees = [
    Employee(1, '张三', 'IT', 8000),
    Employee(2, '李四', 'HR', 6000),
    Employee(3, '王五', 'IT', 9000),
]

# 简单的数据分析
it_employees = [emp for emp in employees if emp.department == 'IT']
avg_salary = sum(emp.salary for emp in employees) / len(employees)

print(f"\nIT部门员工: {it_employees}")
print(f"平均工资: {avg_salary}")

# deque基本操作
dq = deque(['a', 'b', 'c'])
print(f"初始队列: {dq}")

# 左右两端添加
dq.appendleft('left')
dq.append('right')
print(f"添加后: {dq}")

# 左右两端删除
left_item = dq.popleft()
right_item = dq.pop()
print(f"删除的元素: {left_item}, {right_item}")
print(f"删除后: {dq}")

# 旋转操作
dq.extend(['d', 'e', 'f'])
print(f"扩展后: {dq}")

dq.rotate(2)  # 右旋转2位
print(f"右旋转2位: {dq}")

dq.rotate(-1)  # 左旋转1位
print(f"左旋转1位: {dq}")

# 限制大小的deque
limited_dq = deque(maxlen=3)
for i in range(5):
    limited_dq.append(i)
    print(f"添加{i}后: {limited_dq}")

# 实际应用: 滑动窗口
def moving_average(data, window_size):
    """计算滑动平均值"""
    window = deque(maxlen=window_size)
    averages = []
    
    for value in data:
        window.append(value)
        if len(window) == window_size:
            avg = sum(window) / len(window)
            averages.append(avg)
    
    return averages

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ma3 = moving_average(data, 3)
print(f"\n数据: {data}")
print(f"3日滑动平均: {ma3}")

# 实际应用: 最近访问记录
class RecentHistory:
    def __init__(self, maxsize=10):
        self.history = deque(maxlen=maxsize)
    
    def add(self, item):
        self.history.append(item)
    
    def get_recent(self, n=None):
        if n is None:
            return list(self.history)
        return list(self.history)[-n:]

# 测试最近访问记录
history = RecentHistory(5)
for i in range(8):
    history.add(f"page_{i}")
    print(f"访问 page_{i}, 历史: {history.get_recent()}")

# OrderedDict保持插入顺序
od = OrderedDict()
od['first'] = 1
od['second'] = 2
od['third'] = 3

print(f"OrderedDict: {od}")
print(f"键的顺序: {list(od.keys())}")

# move_to_end方法
od.move_to_end('first')  # 移动到末尾
print(f"移动后: {od}")

od.move_to_end('third', last=False)  # 移动到开头
print(f"移动到开头: {od}")

# popitem方法
last_item = od.popitem(last=True)  # 删除末尾
first_item = od.popitem(last=False)  # 删除开头
print(f"删除的元素: {last_item}, {first_item}")
print(f"剩余: {od}")

# 实际应用: LRU缓存
class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()
    
    def get(self, key):
        if key in self.cache:
            # 移动到末尾（最近使用）
            self.cache.move_to_end(key)
            return self.cache[key]
        return None
    
    def put(self, key, value):
        if key in self.cache:
            # 更新并移动到末尾
            self.cache[key] = value
            self.cache.move_to_end(key)
        else:
            # 新增
            if len(self.cache) >= self.capacity:
                # 删除最久未使用的（开头）
                self.cache.popitem(last=False)
            self.cache[key] = value
    
    def items(self):
        return list(self.cache.items())

# 测试LRU缓存
lru = LRUCache(3)
lru.put('a', 1)
lru.put('b', 2)
lru.put('c', 3)
print(f"\nLRU缓存: {lru.items()}")

lru.get('a')  # 访问'a'
lru.put('d', 4)  # 添加'd', 应该移除'b'
print(f"添加'd'后: {lru.items()}")

import itertools

# count() - 无限计数器
print("无限计数器:")
counter = itertools.count(10, 2)  # 从10开始，步长为2
for i, value in enumerate(counter):
    if i >= 5:  # 只显示前5个
        break
    print(f"  count[{i}]: {value}")

# cycle() - 循环迭代器
print("\n循环迭代器:")
colors = itertools.cycle(['red', 'green', 'blue'])
for i, color in enumerate(colors):
    if i >= 8:  # 只显示前8个
        break
    print(f"  cycle[{i}]: {color}")

# repeat() - 重复迭代器
print("\n重复迭代器:")
# 无限重复
repeater = itertools.repeat('hello')
for i, value in enumerate(repeater):
    if i >= 3:
        break
    print(f"  repeat[{i}]: {value}")

# 有限重复
limited_repeat = itertools.repeat('world', 3)
print(f"  有限重复: {list(limited_repeat)}")

# 实际应用: 生成测试数据
def generate_test_data(n):
    """生成测试数据"""
    ids = itertools.count(1)
    statuses = itertools.cycle(['active', 'inactive', 'pending'])
    
    for i in range(n):
        yield {
            'id': next(ids),
            'name': f'user_{i+1}',
            'status': next(statuses)
        }

test_data = list(generate_test_data(6))
print(f"\n测试数据: {test_data}")

# chain() - 连接多个可迭代对象
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [10, 20]

chained = itertools.chain(list1, list2, list3)
print(f"chain结果: {list(chained)}")

# chain.from_iterable() - 从可迭代对象的可迭代对象中连接
lists = [[1, 2], [3, 4], [5, 6]]
flattened = itertools.chain.from_iterable(lists)
print(f"chain.from_iterable结果: {list(flattened)}")

# compress() - 根据选择器过滤
data = ['a', 'b', 'c', 'd', 'e']
selectors = [1, 0, 1, 0, 1]  # 1表示选中，0表示过滤
filtered = itertools.compress(data, selectors)
print(f"compress结果: {list(filtered)}")

# dropwhile() 和 takewhile() - 条件过滤
numbers = [1, 3, 5, 6, 7, 8, 9, 10]

# dropwhile: 跳过前面满足条件的元素
dropped = itertools.dropwhile(lambda x: x < 6, numbers)
print(f"dropwhile(x<6): {list(dropped)}")

# takewhile: 只取前面满足条件的元素
taken = itertools.takewhile(lambda x: x < 6, numbers)
print(f"takewhile(x<6): {list(taken)}")

# filterfalse() - 过滤不满足条件的元素
filtered_false = itertools.filterfalse(lambda x: x % 2 == 0, numbers)
print(f"filterfalse(偶数): {list(filtered_false)}")

# islice() - 切片迭代器
data = range(20)
sliced = itertools.islice(data, 5, 15, 2)  # 从索引5开始，到索引15结束，步长为2
print(f"islice(5, 15, 2): {list(sliced)}")

# accumulate() - 累积计算
numbers = [1, 2, 3, 4, 5]
accumulated = itertools.accumulate(numbers)  # 默认是加法
print(f"累积和: {list(accumulated)}")

# 使用自定义函数
import operator
accumulated_mult = itertools.accumulate(numbers, operator.mul)  # 累积乘积
print(f"累积乘积: {list(accumulated_mult)}")

# 实际应用: 批量处理数据
def process_batches(data, batch_size):
    """将数据分批处理"""
    iterator = iter(data)
    while True:
        batch = list(itertools.islice(iterator, batch_size))
        if not batch:
            break
        yield batch

large_data = range(25)
batches = list(process_batches(large_data, 7))
print(f"\n分批处理结果: {batches}")

# product() - 笛卡尔积(组合)
colors = ['red', 'green']
sizes = ['S', 'M', 'L']
products = itertools.product(colors, sizes)
print(f"product结果: {list(products)}")

# 自身的笛卡尔积(重复组合)
digits = [0, 1]
binary_2bit = itertools.product(digits, repeat=2)
print(f"2位二进制: {list(binary_2bit)}")

# permutations() - 排列
items = ['A', 'B', 'C']
perms_2 = itertools.permutations(items, 2)  # 2个元素的排列
print(f"2元素排列: {list(perms_2)}")

perms_all = itertools.permutations(items)  # 全排列
print(f"全排列: {list(perms_all)}")

# combinations() - 组合(无重复)
combos_2 = itertools.combinations(items, 2)
print(f"2元素组合: {list(combos_2)}")

# combinations_with_replacement() - 组合(有重复)
combos_rep = itertools.combinations_with_replacement(['A', 'B'], 2)
print(f"有重复组合: {list(combos_rep)}")

# 实际应用: 密码穷举
def generate_passwords(chars, length):
    """生成指定长度的所有可能密码"""
    for combo in itertools.product(chars, repeat=length):
        yield ''.join(combo)

# 生成短密码示例(仅用于演示)
short_chars = 'ab'
short_passwords = list(generate_passwords(short_chars, 3))
print(f"\n3位密码穷举: {short_passwords}")

# 实际应用: 参数组合测试
def test_combinations():
    """生成测试参数组合"""
    learning_rates = [0.01, 0.1]
    batch_sizes = [32, 64]
    epochs = [10, 20]
    
    for lr, bs, ep in itertools.product(learning_rates, batch_sizes, epochs):
        yield {
            'learning_rate': lr,
            'batch_size': bs,
            'epochs': ep
        }

test_configs = list(test_combinations())
print(f"\n测试配置组合: {test_configs[:4]}...")  # 只显示前4个