1
2
3
4
5
6
7
8
9

# 基础 import 语法
import math          # 导入数学模块
import random        # 导入随机数模块
import os            # 导入操作系统接口模块

# 使用模块里的函数，要用"模块名.函数名"的方式
print(math.sqrt(16))    # 16的平方根 → 4.0
print(random.randint(1, 10))  # 1到10之间的随机整数（每次运行结果不同）
print(os.getcwd())      # 获取当前工作目录

1
2
3
4
5

import sys

# 查看 Python 已经加载的所有模块
print(len(sys.modules))  # 当前已加载模块数量（数字很大，Python 自带很多模块）
print('math' in sys.modules)  # 查看 math 模块是否已加载 → True

1
2
3
4
5
6
7
8
9

# 从模块中导入特定函数或变量
from math import sqrt, pi          # 只导入平方根和圆周率
from random import randint, choice  # 只导入随机整数和随机 choice

# 现在可以直接用，不用加模块名前缀
print(sqrt(25))      # → 5.0
print(pi)            # → 3.141592653589793
print(randint(1, 6)) # 掷骰子，1到6之间 → 每次结果不同
print(choice(['甲', '乙', '丙']))  # 随机选一个人回答问题

1
2
3
4
5

# 演示命名冲突的惨剧
from math import pi

pi = 3.14  # 糟糕！你刚才 import 的圆周率被你覆盖了！
print(pi)  # → 3.14 （不再是 3.14159...了，哭晕在厕所）

1
2
3
4
5
6
7
8
9

# 昵称的好处：简短、避免冲突
import numpy as np           # 数据科学家的最爱，简写为 np
import pandas as pd          # 数据处理神器，简写为 pd
import matplotlib.pyplot as plt  # 画图必备，简写为 plt
import tensorflow as tf      # 深度学习框架，简写为 tf

# 起了外号之后，就用外号来叫它
print(np.array([1, 2, 3]))   # numpy 的数组
print(pd.DataFrame({'a': [1, 2]}))  # pandas 的数据框

1
2
3
4
5
6
7
8

# 给函数也起别名
from random import randint as ri
from collections import defaultdict as dd

print(ri(1, 100))  # 随机整数，简写版
d = dd(int)  # defaultdict，创建一个默认值为 0 的字典
d['score'] += 1
print(d['score'])  # → 1

1
2
3

# mypackage/utils.py 文件里
from mypackage import config      # 绝对导入：从项目根目录开始
from mypackage.helpers import foo  # 绝对导入另一个模块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 假设项目结构：
# myproject/
#   __init__.py
#   main.py
#   utils/
#     __init__.py
#     helpers.py

# 在 utils/helpers.py 里，你想导入同一级的其他模块
from . import helpers      # 从当前包（utils）导入
from .. import main        # 从上级包（myproject）导入
from .specific import func  # 从当前包的 specific 模块导入

1
2
3
4
5
6

# 实际栗子：假设你在 mypackage/utils/formatters.py 里
# 想导入同包的 validators.py
from .validators import validate_email  # 相对导入

# 或者导入父包的 config.py
from ..config import settings  # 相对导入，.. 表示上级目录

1
2
3
4
5

import sys

# 打印 Python 找模块的路径列表
for i, path in enumerate(sys.path):
    print(f"{i}: {path}")

1
2
3
4
5
6

# 你可以手动往 sys.path 里加新路径
import sys
sys.path.append('D:/my_awesome_library')  # 把你的私人库目录加进去
sys.path.insert(0, 'D:/even_awesomer')    # 插队到最前面（最高优先级）

import my_module  # 现在 Python 也会去这两个地方找

1
2
3
4
5
6
7

# 一个小技巧：获取模块的真实文件路径
import os
import math

# 想知道 import 的模块实际在哪个文件？
print(math.__file__)  # → C:\Python311\Lib\math.py （或者 .pyd 文件）
print(os.__file__)    # → C:\Python311\Lib\os\__init__.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# mymodule.py

# 定义公开的 API（别人 import * 的时候能看到这些）
__all__ = ['public_function', 'MyClass', 'PUBLIC_CONSTANT']

def public_function():
    """这是公开展示的函数"""
    return "我是公开的！"

def _private_helper():
    """这是内部小助手，不在公开名单里"""
    return "我是隐藏的！"

class MyClass:
    pass

PUBLIC_CONSTANT = 42
_private_var = "看不到我"

1
2
3
4
5
6
7

# 使用 import *
from mymodule import *  # 只能拿到 __all__ 里声明的

print(public_function())   # ✅ 正常用
print(MyClass)             # ✅ 正常用
print(PUBLIC_CONSTANT)    # ✅ 正常用
# print(_private_helper()) # ❌ 用 import * 不会导入它（不在 __all__ 中）；但显式 import _private_helper 是可以的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 强烈推荐写法：__all__ + 下划线约定 双重保险
__all__ = ['process_data', 'DataProcessor']  # 明确公开名单

def _internal_helper(data):  # 下划线开头，内部使用
    """清洗数据内部用的"""
    return [x.strip() for x in data]

def process_data(data):      # 公开 API
    cleaned = _internal_helper(data)
    return cleaned

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 传统包目录结构
mypackage/
    __init__.py      # 包入口文件（空也行，有内容也行）
    main.py           # 主模块
    utils/
        __init__.py
        helpers.py
        formatters.py
    models/
        __init__.py
        user.py
        order.py

1
2
3
4
5
6

# 使用包里的模块
from mypackage.utils.helpers import clean_data
from mypackage.models.user import User

user = User("张三")
print(clean_data([" 苹果 ", " 香蕉 "]))  # → ['苹果', '香蕉']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# mypackage/__init__.py 的内容

# 1. 首次 import 这个包时，会执行这里的代码
print("🥳 mypackage 被加载了！")

# 2. 把常用的子模块"提升"到包级别，简化导入
from .utils.helpers import clean_data  # 把 clean_data 提升到包级别
from .utils import helpers, formatters
from .models import user, order

# 3. 设置包级别的 __all__，控制 from mypackage import * 的行为
__all__ = ['clean_data', 'helpers', 'formatters', 'user', 'order']

1
2
3
4
5
6

# 现在你可以这样导入（因为 __init__.py 帮你提升了）
import mypackage

# 原本要这样：from mypackage.utils.helpers import clean_data
# 现在可以这样（前提是 __init__.py 里已经 from .utils.helpers import clean_data）：
from mypackage import clean_data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# __init__.py 还能用来做包初始化配置
# 比如 Flask 框架就是用 __init__.py 来初始化应用实例

# 假设这是 mypackage/config.py 的内容
DATABASE_URL = "sqlite:///mydb.sqlite3"
DEBUG = True

# mypackage/__init__.py 里
from .config import DATABASE_URL, DEBUG

# 这样外部可以直接 mypackage.DATABASE_URL 访问

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 命名空间包的特点：
# 1. 不需要 __init__.py
# 2. 可以跨多个目录
# 3. 是"只读"的，不能有 __init__.py 里的代码

# 假设你有这样的结构：
# /usr/lib/python3/site-packages/mypackage/__init__.py  （第三方库）
# /home/user/projects/mypackage/utils.py                  （你的代码）
# 
# 用户 import mypackage 时，Python 会自动"拼接"这两个目录的内容！

1
2
3
4
5
6
7
8
9

# 命名空间包的实际应用：同一模块的不同来源
# 比如你写的代码和第三方库可以往同一个命名空间里加东西

# 创建命名空间包只需要建立目录，不放 __init__.py 即可
# Python 会智能合并所有同名包的路径

# 查看包的所有来源路径
import mypackage
print(mypackage.__path__)  # 会列出所有来源路径

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 跨包导入栗子：myproject/api/views.py 导入 db 模块

# 假设目录结构是：
# myproject/
#   __init__.py
#   api/
#     __init__.py
#     views.py
#   db/
#     __init__.py
#     connection.py

# myproject/db/connection.py
def get_connection():
    return "数据库连接对象"

# myproject/api/views.py
# 方式1：绝对导入（推荐，清晰明了）
from myproject.db import connection
conn = connection.get_connection()

# 方式2：相对导入（适合包内部使用）
from ..db import connection
conn = connection.get_connection()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 从子包"晋升"到父包
# 假设 myproject/core/logic.py 想访问 myproject/config.py

# myproject/core/logic.py
from .. import config  # .. 表示上级包（myproject）
print(config.SETTINGS)

# 或者
import myproject.config as config
print(config.SETTINGS)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# hello.py

def say_hello(name):
    """打招呼函数"""
    return f"你好，{name}！欢迎来到 Python 的世界！"

def _private_func():
    """内部小函数，不想被外面用"""
    return "这是内部用的"

# ⭐ 关键代码来了！
if __name__ == "__main__":
    # 只有直接运行这个文件时，以下代码才会执行
    # 如果是被其他文件 import 的，这块代码不会执行
    print("=== 直接运行模式 ===")
    print(say_hello("小明"))
    print(say_hello("小红"))
else:
    # 被 import 时的提示（可选）
    print(f"模块 {__name__} 被导入了")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 场景1：直接运行 hello.py
# 输出：
# === 直接运行模式 ===
# 你好，小明！欢迎来到 Python 的世界！
# 你好，小红！欢迎来到 Python 的世界！

# 场景2：在另一个文件里 import hello
# import hello
# 输出：
# 模块 hello 被导入了
# （不会打印问候语，因为 if __name__ == "__main__" 不会成立）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 实际项目中的经典用法：命令行工具
# bot.py

import sys
import json

def main():
    """主函数，程序的入口"""
    config = load_config()
    bot = create_bot(config)
    bot.run()

def load_config():
    with open('config.json') as f:
        return json.load(f)

def create_bot(config):
    print(f"启动机器人：{config['name']}")
    return type('Bot', (), {'run': lambda self: print("机器人运行中...")})()

if __name__ == "__main__":
    # 直接运行时执行
    main()
else:
    # 被作为模块导入时，不执行 main()
    print(f"{__name__} 模块已加载，供其他模块使用")

1
2
3
4
5
6
7

# 检测自己是不是入口模块
print(f"当前模块的 __name__ 是：{__name__}")

if __name__ == "__main__":
    print("我是被直接运行的！")
else:
    print("我是被别的模块导入的")

1
2
3
4
5
6
7

# 入口模块的 sys.argv 有特殊含义
# 假设你在命令行运行：python my_script.py arg1 arg2

import sys
if __name__ == "__main__":
    print(f"脚本名：{sys.argv[0]}")    # → my_script.py
    print(f"参数列表：{sys.argv[1:]}")  # → ['arg1', 'arg2']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import os

# 获取当前工作目录（你现在在哪个文件夹里）
cwd = os.getcwd()
print(f"当前目录：{cwd}")

# 创建目录
os.makedirs("test_folder", exist_ok=True)  # 递归创建，exist_ok=True 避免已存在报错

# 删除目录
os.rmdir("test_folder")  # 只能删除空目录

# 列出目录内容
print(os.listdir("."))  # 列出当前目录所有文件和文件夹

# 检查路径
print(os.path.exists("test_folder"))  # False，目录已被删除
print(os.path.isfile("Chapter-16-Modules.md"))  # 检查是否是文件
print(os.path.isdir("test_folder"))   # 检查是否是目录

# 路径拼接（跨平台兼容！）
full_path = os.path.join("home", "user", "documents", "file.txt")
print(full_path)  # Windows: home\user\documents\file.txt  Linux: home/user/documents/file.txt

# 获取文件信息
size = os.path.getsize("Chapter-16-Modules.md")
print(f"文件大小：{size} 字节")

# 环境变量
home_dir = os.environ.get("HOME") or os.environ.get("USERPROFILE")
print(f"用户目录：{home_dir}")

# 执行系统命令（慎用！有安全风险）
# os.system("dir")  # Windows
# os.system("ls")   # Linux/Mac

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

import sys

# Python 版本信息
print(f"Python 版本：{sys.version}")
print(f"版本详情：{sys.version_info}")
print(f"主版本号：{sys.version_info.major}")  # 3
print(f"次版本号：{sys.version_info.minor}")  # 11

# 命令行参数（sys.argv）
# 假设运行：python script.py arg1 arg2
print(f"脚本名：{sys.argv[0]}")
print(f"参数个数：{len(sys.argv)}")

# 退出程序（别乱用！）
# sys.exit(0)  # 正常退出
# sys.exit(1)  # 出错退出

# 模块搜索路径
print(f"\n模块搜索路径：")
for p in sys.path[:3]:  # 只显示前3个
    print(f"  {p}")

# 最大的整数和浮点数
print(f"最大整数：{sys.maxsize}")
print(f"最大浮点数：{sys.float_info.max}")

# stdin / stdout / stderr
print("普通输出", file=sys.stdout)  # 打印到标准输出
print("错误信息", file=sys.stderr)  # 打印到标准错误

# 强制刷新输出
print("马上显示！", flush=True)

# 查看已加载的模块数量
print(f"\n已加载模块数：{len(sys.modules)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

from pathlib import Path

# 当前目录的 Path 对象
p = Path(".")
print(p)  # .

# 路径拼接，用 /
data_dir = Path("data") / "output" / "results"
print(data_dir)  # data\output\results

# 创建目录
data_dir.mkdir(parents=True, exist_ok=True)

# 路径存在性检查
print(Path("Chapter-16-Modules.md").exists())  # True
print(Path("不存在的文件.txt").exists())      # False

# 文件 vs 目录
print(Path("Chapter-16-Modules.md").is_file())   # True
print(Path(".").is_dir())                         # True

# 遍历目录
for item in Path(".").iterdir():
    print(f"  {item.name} ({'dir' if item.is_dir() else 'file'})")

# 路径.glob() 模式匹配
for py_file in Path(".").glob("*.md"):
    print(f"  找到 Markdown: {py_file.name}")

# 递归搜索
for py_file in Path(".").rglob("*.py"):
    print(f"  找到 Python: {py_file}")

# 读取/写入文件（Python 3.4+ 新写法）
test_file = data_dir / "test.txt"
test_file.write_text("Hello, pathlib!", encoding="utf-8")
content = test_file.read_text(encoding="utf-8")
print(f"读取内容：{content}")

# 获取各种路径信息
readme = Path("README.md")
print(f"文件名：{readme.name}")        # README.md
print(f"不含扩展名：{readme.stem}")    # README
print(f"扩展名：{readme.suffix}")     # .md
print(f"父目录：{readme.parent}")     # .
print(f"绝对路径：{readme.resolve()}")

# 解析路径（把字符串转成 Path 对象）
home = Path.home()
print(f"用户主目录：{home}")

# 相对路径
file_path = Path("data/config/settings.py")
print(f"相对路径：{file_path}")                    # data/config/settings.py
print(f"绝对路径：{file_path.resolve()}")           # D:\...\data\config\settings.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

import time
import datetime

# ===== time 模块 =====

# 获取当前时间戳（从1970年1月1日到现在经过的秒数）
timestamp = time.time()
print(f"当前时间戳：{timestamp}")

# 时间戳转 struct_time（分解时间）
struct = time.localtime(timestamp)
print(f"struct_time：{struct}")
print(f"年={struct.tm_year}, 月={struct.tm_mon}, 日={struct.tm_mday}")

# struct_time 转字符串
formatted = time.strftime("%Y-%m-%d %H:%M:%S", struct)
print(f"格式化时间：{formatted}")

# 字符串转 struct_time
parsed = time.strptime("2024-01-15 10:30:00", "%Y-%m-%d %H:%M:%S")
print(f"解析后：{parsed}")

# 暂停一会儿（程序"睡觉"）
print("我要睡2秒...")
time.sleep(2)
print("睡醒了！")

# ===== datetime 模块 =====

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

# 创建特定时间
birthday = datetime.datetime(2000, 1, 1, 0, 0, 0)
print(f"千禧年：{birthday}")

# 时间相减（得到 timedelta）
diff = now - birthday
print(f"活了 {diff.days} 天了！")

# 加减时间
future = now + datetime.timedelta(days=7)
past = now - datetime.timedelta(hours=12)
print(f"一周后：{future}")
print(f"12小时前：{past}")

# 格式化时间（strftime）
print(now.strftime("%Y年%m月%d日 %H:%M:%S"))
print(now.strftime("%A, %B %d, %Y"))  # 英文格式

# 字符串转时间（strptime）
date_str = "2024-06-01 12:00:00"
parsed_time = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(f"解析时间：{parsed_time}")

# date 对象（只有日期，没有时间）
today = datetime.date.today()
print(f"今天是：{today}")
print(f"今天是星期{['一','二','三','四','五','六','日'][today.weekday()]}")

# ===== 实用技巧 =====

# 简单计时器
def timer(func):
    """装饰器：计算函数执行时间"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 耗时：{end - start:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "完成"

print(slow_function())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import json

# ===== Python 对象 → JSON 字符串 =====

data = {
    "name": "小明",
    "age": 18,
    "scores": [95, 88, 92],
    "is_student": True,
    "address": {"city": "北京", "district": "朝阳区"}
}

# 序列化（dump：写入文件，dumps：写入字符串）
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print("JSON 字符串：")
print(json_str)

# ===== JSON 字符串 → Python 对象 =====

json_text = '{"name": "小红", "age": 17, "grades": [80, 90]}'
parsed = json.loads(json_text)
print(f"解析后：{parsed}")
print(f"类型：{type(parsed)}")  # <class 'dict'>

# ===== 文件操作 =====

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

# 读取 JSON 文件
with open("data.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)
print(f"从文件读取：{loaded}")

# ===== 高级选项 =====

# 自定义序列化（处理 datetime 等特殊类型）
from datetime import datetime

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return {"__datetime__": obj.isoformat()}
        return super().default(obj)

data_with_date = {"event": "派对", "time": datetime.now()}
encoded = json.dumps(data_with_date, cls=CustomEncoder)
print(f"带日期的JSON：{encoded}")

# ===== JSON vs Python 类型对照表 =====
# Python          → JSON
# dict            → object {}
# list, tuple     → array []
# str             → string ""
# int, float      → number
# True / False    → true / false
# None            → null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

import re

text = "我的邮箱是 zhangsan@163.com，另一个是 li_si@qq.com，别打 138-1234-5678 这个电话"

# ===== 基础匹配 =====

# findall: 找出所有匹配
emails = re.findall(r'\w+@\w+\.\w+', text)
print(f"邮箱：{emails}")

# search: 找第一个匹配
phone_match = re.search(r'\d{3}-\d{4}-\d{4}', text)
if phone_match:
    print(f"电话号码：{phone_match.group()}")

# match: 从开头匹配
result = re.match(r'^我的', text)
print(f"开头匹配：{result.group() if result else '不匹配'}")

# split: 用正则分割
parts = re.split(r'[,，。.]', "苹果,香蕉。草莓,葡萄")
print(f"分割结果：{parts}")

# sub: 替换
cleaned = re.sub(r'\d{3}-\d{4}-\d{4}', '[电话号码]', text)
print(f"脱敏后：{cleaned}")

# ===== 正则语法速查 =====

# .  匹配任意字符（除了换行）
# \d 匹配数字 [0-9]
# \D 匹配非数字 [^0-9]
# \w 匹配字母数字下划线 [a-zA-Z0-9_]
# \W 匹配非字母数字
# \s 匹配空白字符（空格、tab、换行）
# \S 匹配非空白字符
# ^  匹配字符串开头
# $  匹配字符串结尾
# *  0次或多次
# +  1次或多次
# ?  0次或1次（可选）
# {n} 恰好n次
# {n,m} n到m次
# [] 字符类，如 [aeiou] 匹配元音
# |  或，如 cat|dog
# () 分组

# ===== 高级：分组捕获 =====

log = "2024-06-15 10:30:45 ERROR Connection failed"
pattern = r'(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) (\w+) (.+)'
match = re.match(pattern, log)
if match:
    print(f"日期：{match.group(1)}-{match.group(2)}-{match.group(3)}")
    print(f"时间：{match.group(4)}:{match.group(5)}:{match.group(6)}")
    print(f"级别：{match.group(7)}")
    print(f"消息：{match.group(8)}")
    # 也能用具名分组
    # (?P<name>pattern)

# ===== re.compile 预编译（多次使用时效率更高）=====

email_pattern = re.compile(r'\w+@\w+\.\w+')
urls = ["test@gmail.com", "invalid", "user@yahoo.com"]
for url in urls:
    if email_pattern.fullmatch(url):  # 完全匹配
        print(f"有效邮箱：{url}")
    else:
        print(f"无效：{url}")

# ===== 实战：验证手机号 =====
def validate_phone(phone):
    """验证中国手机号"""
    pattern = r'^1[3-9]\d{9}$'  # 1开头，第二位3-9，后面9位数字
    return bool(re.fullmatch(pattern, phone))

print(validate_phone("13812345678"))  # True
print(validate_phone("12345678901"))   # False
print(validate_phone("138-1234-5678")) # False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

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

# ===== namedtuple：带名字的元组 =====
# 适合表示不可变的"记录"

Point = namedtuple('Point', ['x', 'y', 'z'])
p1 = Point(10, 20, 30)
p2 = Point(x=100, y=200, z=300)

print(f"点1：{p1}")
print(f"点1.x = {p1.x}, 点1.y = {p1.y}")  # 用名字访问，比索引直观
print(f"点2：{p2}")

# namedtuple 也有 _replace 方法创建"修改版"
p3 = p1._replace(x=999)
print(f"修改后的点：{p3}")

# ===== defaultdict：默认值字典 =====
# 访问不存在的 key 不会报错，会自动创建默认值

dd = defaultdict(int)  # 默认值是 0（int() 的结果）
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
for word in words:
    dd[word] += 1
print(f"水果计数：{dict(dd)}")  # {'apple': 3, 'banana': 2, 'cherry': 1}

# 默认值工厂：
# int → 0
# list → []
# dict → {}
# set → set()

dd2 = defaultdict(list)  # 默认值是空列表
dd2["colors"].append("red")
dd2["colors"].append("blue")
print(f"颜色列表：{dict(dd2)}")

# ===== Counter：计数器 =====
# 专门用来数东西出现次数

votes = ["A", "B", "A", "C", "B", "A", "A"]
counter = Counter(votes)
print(f"投票结果：{counter}")
print(f"最高票：{counter.most_common(1)}")  # [('A', 4)]
print(f"A 得了 {counter['A']} 票")

# Counter 运算
c1 = Counter(["a", "b", "c", "a"])
c2 = Counter(["a", "b", "d"])
print(f"合并：{c1 + c2}")  # {'a': 2, 'b': 2, 'c': 1, 'd': 1}
print(f"交集：{c1 & c2}")  # {'a': 1, 'b': 1}

# ===== deque：双端队列 =====
# 两端都能添加/删除，比 list 的 pop(0) 高效得多

dq = deque(["甲", "乙", "丙"])
dq.append("丁")      # 右端添加
dq.appendleft("甲'") # 左端添加
print(f"队列：{list(dq)}")

dq.pop()             # 右端弹出
dq.popleft()         # 左端弹出
print(f"操作后：{list(dq)}")

# deque 的实用场景：保持最后 N 个元素
last_lines = deque(maxlen=5)
for i in range(10):
    last_lines.append(f"行 {i}")
print(f"最后5行：{list(last_lines)}")

# ===== OrderedDict：有序字典 =====
# Python 3.7+ 普通字典已自动保持插入顺序，
# OrderedDict 在需要特定顺序操作（如 move_to_end）时仍有价值

od = OrderedDict()
od["first"] = 1
od["second"] = 2
od["third"] = 3
print(f"有序字典：{dict(od)}")

# 移动到末尾
od.move_to_end("first")
print(f"移动后：{list(od.keys())}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

import itertools

# ===== count / cycle / repeat：无限迭代器 =====

# count: 无限计数器
for i in itertools.count(start=10, step=2):
    print(i, end=" ")
    if i > 20:
        break
print()  # 10 12 14 16 18 20 22

# cycle: 无限循环
cycler = itertools.cycle(["红", "绿", "蓝"])
for i in range(7):
    print(next(cycler), end=" ")
print()  # 红 绿 蓝 红 绿 蓝 红

# repeat: 重复一个值
repeater = itertools.repeat("呗", times=3)
print(list(repeater))  # ['呗', '呗', '呗']

# ===== 有限迭代器 =====

# accumulate: 累加
nums = [1, 2, 3, 4, 5]
print(list(itertools.accumulate(nums)))         # [1, 3, 6, 10, 15]
print(list(itertools.accumulate(nums, max)))    # [1, 2, 3, 4, 5]

# chain: 连接多个迭代器
a = [1, 2, 3]
b = [4, 5, 6]
print(list(itertools.chain(a, b)))  # [1, 2, 3, 4, 5, 6]
print(list(itertools.chain.from_iterable([a, b, [7, 8]])))  # 嵌套列表扁平化

# compress: 按条件过滤
data = ["甲", "乙", "丙", "丁", "戊"]
selector = [True, False, True, False, True]
print(list(itertools.compress(data, selector)))  # ['甲', '丙', '戊']

# dropwhile / takewhile: 按条件跳过/取元素
nums = [1, 3, 5, 2, 4, 6]
print(list(itertools.dropwhile(lambda x: x < 5, nums)))  # [5, 2, 4, 6] （遇到>=5的就开始保留）
print(list(itertools.takewhile(lambda x: x < 5, nums)))  # [1, 3] （遇到>=5的就停止）

# groupby: 分组（需要数据先排序）
data = [("甲", "A"), ("乙", "A"), ("丙", "B"), ("丁", "B"), ("戊", "A")]
data.sort(key=lambda x: x[1])  # 必须先排序！
for key, group in itertools.groupby(data, key=lambda x: x[1]):
    print(f"{key}: {list(group)}")
# A: [('甲', 'A'), ('乙', 'A')]
# B: [('丙', 'B'), ('丁', 'B')]
# A: [('戊', 'A')]

# ===== 组合生成器 =====

# product: 笛卡尔积
colors = ["红", "绿"]
sizes = ["S", "M", "L"]
print(list(itertools.product(colors, sizes)))
# [('红', 'S'), ('红', 'M'), ('红', 'L'), ('绿', 'S'), ('绿', 'M'), ('绿', 'L')]

# permutations: 排列（有序）
print(list(itertools.permutations("ABC", 2)))
# [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

# combinations: 组合（无序）
print(list(itertools.combinations("ABC", 2)))
# [('A', 'B'), ('A', 'C'), ('B', 'C')]

# combinations_with_replacement: 带重复的组合
print(list(itertools.combinations_with_replacement("AB", 3)))
# [('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'B', 'B'), ('B', 'B', 'B')]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

import functools

# ===== lru_cache：记忆化缓存 =====
# 把函数的结果缓存起来，相同的参数不再重复计算

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

import time
start = time.time()
print(f"Fib(30) = {fibonacci(30)}")
print(f"耗时：{time.time() - start:.6f}秒")

# 清除缓存
fibonacci.cache_clear()

# ===== partial：偏函数 =====
# 固定函数的部分参数，创建一个"简化版"函数

def power(base, exponent):
    return base ** exponent

square = functools.partial(power, exponent=2)  # 固定 exponent=2
cube = functools.partial(power, exponent=3)   # 固定 exponent=3

print(square(5))  # 25
print(cube(5))    # 125

# ===== reduce：归约 =====
# 把序列"压缩"成一个值

numbers = [1, 2, 3, 4, 5]
total = functools.reduce(lambda x, y: x + y, numbers)
print(f"总和：{total}")  # 15

max_val = functools.reduce(lambda x, y: x if x > y else y, numbers)
print(f"最大值：{max_val}")  # 5

# ===== cmp_to_key：自定义排序 =====
# 把比较函数转成 key 函数

sorted(["香蕉", "苹果", "枣子"], key=functools.cmp_to_key(
    lambda a, b: len(a) - len(b)  # 按长度排序
))  # ['枣子', '苹果', '香蕉']

# ===== wraps：装饰器保存元信息 =====
# 让装饰器不要"吃掉"原函数的 __name__、__doc__ 等

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("调用前")
        result = func(*args, **kwargs)
        print("调用后")
        return result
    return wrapper

@my_decorator
def say_hi():
    """这个函数打招呼"""
    print("嗨！")

print(say_hi.__name__)  # say_hi （而不是 wrapper）
print(say_hi.__doc__)   # 这个函数打招呼

# ===== singledispatch：泛函数 =====
# 根据第一个参数的类型决定调用哪个实现

@functools.singledispatch
def process(x):
    """默认处理"""
    print(f"默认处理：{x}")

@process.register(int)
def _(x):
    print(f"整数处理：{x} 的平方是 {x**2}")

@process.register(str)
def _(x):
    print(f"字符串处理：'{x}' 长度是 {len(x)}")

process(10)      # 整数处理
process("hello") # 字符串处理
process([1, 2])  # 默认处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

import logging

# ===== 基础配置 =====
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

logger = logging.getLogger(__name__)  # 用模块名作为 logger 名字

logger.debug("调试信息（通常不显示）")
logger.info("一般信息")
logger.warning("警告信息")
logger.error("错误信息")
logger.critical("严重错误")

# ===== 日志级别 =====
# DEBUG < INFO < WARNING < ERROR < CRITICAL
# 默认是 WARNING 及以上才会输出

# ===== 输出到文件 =====
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('app.log', encoding='utf-8'),
        logging.StreamHandler()  # 同时输出到控制台
    ]
)

# ===== 实战配置 =====
logger2 = logging.getLogger('myapp')
logger2.setLevel(logging.DEBUG)

# 创建 handler（输出到文件）
file_handler = logging.FileHandler('debug.log', encoding='utf-8')
file_handler.setLevel(logging.DEBUG)

# 创建 handler（输出到控制台）
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# 设置格式
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 添加 handler
logger2.addHandler(file_handler)
logger2.addHandler(console_handler)

logger2.info("这条会同时出现在文件和屏幕上")
logger2.debug("这条只出现在文件里")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import argparse

# ===== 创建解析器 =====
parser = argparse.ArgumentParser(
    description="我的超牛命令行工具",
    epilog="使用愉快！有问题请提 Issue"
)

# ===== 添加参数 =====

# 位置参数（必须提供）
parser.add_argument('input_file', help="输入文件路径")

# 可选参数
parser.add_argument('-o', '--output', default='result.txt', help="输出文件路径")
parser.add_argument('-n', '--number', type=int, default=10, help="处理数量")
parser.add_argument('-v', '--verbose', action='store_true', help="详细模式")
parser.add_argument('-q', '--quiet', action='store_true', help="安静模式")
parser.add_argument('--format', choices=['json', 'csv', 'xml'], default='csv', help="输出格式")

# 互斥组（不能同时使用）
group = parser.add_mutually_exclusive_group()
group.add_argument('--encrypt', action='store_true', help="加密模式")
group.add_argument('--decrypt', action='store_true', help="解密模式")

# ===== 解析参数 =====
args = parser.parse_args()

# ===== 使用参数 =====
print(f"输入文件：{args.input_file}")
print(f"输出文件：{args.output}")
print(f"处理数量：{args.number}")
print(f"详细模式：{args.verbose}")
print(f"输出格式：{args.format}")

1
2
3

# 命令行使用示例：
# python mytool.py data.csv -n 100 -v --format json -o out.json
# python mytool.py --help

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from urllib import request, parse, error

# ===== GET 请求 =====
try:
    with request.urlopen('https://httpbin.org/get') as response:
        data = response.read().decode('utf-8')
        print(f"响应长度：{len(data)} 字符")
        print(f"状态码：{response.status}")
except error.URLError as e:
    print(f"请求失败：{e}")

# ===== 带参数的 GET 请求 =====
params = parse.urlencode({'name': '张三', 'age': 18})
url = f'https://httpbin.org/get?{params}'
print(f"请求URL：{url}")

# ===== POST 请求 =====
data = parse.urlencode({'username': 'admin', 'password': '123456'}).encode()
try:
    with request.urlopen('https://httpbin.org/post', data=data) as response:
        result = response.read().decode()
        print(f"POST响应：{result[:100]}...")
except error.URLError as e:
    print(f"请求失败：{e}")

# ===== 设置请求头 =====
req = request.Request(
    'https://httpbin.org/headers',
    headers={
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'application/json'
    },
    method='GET'
)
with request.urlopen(req) as response:
    import json
    headers = json.loads(response.read().decode())
    print(f"发送的请求头：{headers}")