Python3基础库入门（个人学习用）

系统库

OS标准库（cmd）

OS表示Operating System，即操作系统。OS标准库是一个操作系统接口模块，提供一些方便使用操作系统相关功能的函数，具体安装位置可通过导入os模块查看os.__file__属性得到。当需要在Python代码中调用OS相关功能实现业务逻辑或者无法直接使用命令行工具时，我们就需要考虑导入此模块，因此有必要进行深入学习。

1. 文件与目录操作

创建/删除目录：

os.mkdir("new_folder")       # 创建单层目录
os.makedirs("a/b/c")        # 递归创建多层目录
os.rmdir("new_folder")      # 删除空目录
os.removedirs("a/b/c")      # 递归删除空目录

文件操作：

os.rename("old.txt", "new.txt")  # 重命名文件
os.remove("file.txt")            # 删除文件
os.unlink("file.txt")            # 同 remove()

2. 路径管理（跨平台兼容）

路径拼接与解析：

path = os.path.join("folder", "sub", "file.txt")  # 自动处理分隔符（如 folder/sub/file.txt）
dir_name = os.path.dirname(path)                  # 获取目录名（folder/sub）
file_name = os.path.basename(path)                # 获取文件名（file.txt）

路径检查：

os.path.exists("file.txt")    # 检查路径是否存在
os.path.isfile("file.txt")    # 是否为文件
os.path.isdir("folder")       # 是否为目录
os.path.getsize("file.txt")   # 获取文件大小（字节）

3. 环境变量管理

读取/设置环境变量：

home_dir = os.environ["HOME"]                  # 读取（Linux/macOS）
os.environ["API_KEY"] = "12345"                # 设置临时环境变量（仅在当前进程生效）

获取系统信息：

os.name        # 操作系统类型（'posix'、'nt'、'java'）
os.cpu_count() # 获取 CPU 核心数

sys模块（python解释器）

Python 的 sys 模块是标准库中用于与 Python 解释器及其运行环境交互的核心模块，提供了访问命令行参数、系统配置、程序退出等功能。以下是其核心功能及常见用法：

sys.argv
获取运行 Python 脚本时传递的命令行参数列表
sys.exit([status])
终止 Python 程序，返回状态码（默认 0 表示成功，非 0 表示异常）
sys.path
查看或修改 Python 的模块搜索路径（列表形式）
sys.stdin
标准输入流（默认从键盘读取）
sys.stdout
标准输出流（默认输出到控制台）
sys.stderr
标准错误流（默认输出到控制台）
sys.version
获取 Python 解释器版本信息
sys.platform
获取操作系统标识符（如 win32、linux、darwin）
sys.getdefaultencoding()
获取默认字符串编码（通常为 utf-8）
sys.getfilesystemencoding()
获取文件系统编码（如文件名处理）。
sys.exc_info()
获取当前异常的详细信息（类型、值、回溯栈）。
sys.getsizeof(obj)
返回对象占用的内存字节数（近似值）。

subprocess模块

Python 的 subprocess 模块是用于创建和管理子进程的标准库工具，它允许你在 Python 程序中执行外部命令、与其他进程交互，并控制输入/输出流。相比旧的 os.system 和 os.popen，subprocess 更灵活且安全，是执行系统命令或调用外部程序的首选方式。

• subprocess.run()

同步执行命令，等待完成并返回结果（推荐用于简单场景）。

import subprocess

result = subprocess.run(
    ["ls", "-l"],          # 命令参数列表（避免使用字符串防注入）
    capture_output=True,   # 捕获输出
    text=True,             # 返回字符串而非字节
    check=True,            # 状态码非零时抛出异常
    timeout=10             # 超时时间（秒）
)
print(result.stdout)       # 输出命令结果

• subprocess.Popen()

异步执行命令，灵活控制进程（适合复杂场景）。

proc = subprocess.Popen(
    ["python", "script.py"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True
)
# 发送输入并等待完成
output, error = proc.communicate(input="数据")
print("输出:", output)

• subprocess.check_output()

快速获取命令输出（若失败则抛出异常）。

try:
    output = subprocess.check_output(["echo", "Hello"], text=True)
    print(output)  # "Hello\n"
except subprocess.CalledProcessError as e:
    print("命令执行失败:", e)

importlib标准库

Python 的 importlib 模块是标准库中用于动态管理模块导入的工具，它提供了对 Python 导入系统（import system）的底层控制能力。相较于传统的 import 语句，importlib 允许开发者在运行时按需加载模块、重载模块或实现自定义导入逻辑，尤其适合插件化架构、热更新等场景。

• 动态导入模块

import importlib

# 导入模块（等价于 import os）
os_module = importlib.import_module("os")

# 导入子模块（等价于 import pandas.io.json）
json_parser = importlib.import_module("pandas.io.json")

# 相对导入（从当前包导入子模块）
relative_module = importlib.import_module(".submodule", package="mypackage")

• 重载模块（热更新）

import mymodule  # 首次导入
importlib.reload(mymodule)  # 修改代码后重新加载

• 模块元数据查询

# 检查模块是否存在
spec = importlib.util.find_spec("requests")
if spec is not None:
    print("模块存在，路径:", spec.origin)
else:
    print("模块不存在")

进程、线程、协程

concurrent.futures库

Python 的 concurrent.futures 模块是用于实现多线程/多进程并行编程的高层接口，旨在简化并发任务的执行和管理。它基于线程池（ThreadPoolExecutor）和进程池（ProcessPoolExecutor）的设计模式，提供统一的 API，适用于 I/O 密集型和 CPU 密集型任务的并行处理。

ThreadPoolExecutor

ThreadPoolExecutor通过线程池管理线程，减少了手动管理线程的复杂性，适用于处理大量短期任务。而threading需要手动创建和管理每个线程，适合需要更精细控制的场景。

run_in_executor()是协程的event_loop自带的

ProcessPoolExecutor

threading标准库

==threading 库是用于实现多线程编程的标准库，适合处理 I/O 密集型任务。==尽管由于全局解释器锁（GIL）的存在，多线程在 CPU 密集型任务中无法实现真正的并行，但通过线程并发仍能提升效率。

• 基本用法

通过 Thread 类创建线程，需指定 target（目标函数）和 args（参数）。线程通过 start() 启动，join() 用于等待线程结束。
import threading

def task(name):
    print(f"Thread {name} is running")

#创建线程
t = threading.Thread(target=task, args=("A",))
t.start()  # 启动线程
t.join()   # 等待线程结束

• 线程同步机制

Lock（互斥锁）

lock = threading.Lock()
counter = 0

def increment():
    global counter
    with lock:  # 自动获取和释放锁
        counter += 1

• 守护线程（Daemon Threads）

主线程退出时，守护线程自动终止。适用于后台任务（如心跳检测）：

daemon_thread = threading.Thread(target=background_task)
daemon_thread.daemon = True  # 设置为守护线程
daemon_thread.start()

• 线程间通信

使用 queue.Queue（线程安全队列）传递数据：

import queue

q = queue.Queue()
def producer():
    q.put("Data")

def consumer():
    data = q.get()

• 线程局部数据

通过 threading.local() 为每个线程创建独立数据：

thread_local = threading.local()
def set_data(value):
    thread_local.value = value  # 各线程独立存储

• 适用场景

I/O 密集型任务：如网络请求、文件读写。
并发处理：同时处理多个客户端连接（如 Web 服务器）。

AsyncIO协程（主要看是不是有IO等待）

asyncio 是 Python 的一个标准库，用于编写单线程并发代码，主要通过协程实现。它在 Python 3.4 版本中引入，提供了基于事件循环的并发模型。
asyncio 的主要特点是事件循环（event loop） 和 协程（coroutine）。
事件循环（event loop）是 asyncio 的核心，可以理解为一个无限循环，我们可以把一些函数（通过 async 定义的函数，称为协程）注册到事件循环（event loop）上，当满足事件发生的条件时，调用相应的协程函数。注意：event loop没有权力收回控制权，只能等await执行完或者函数执行完。
协程（coroutine）是 asyncio 的另一个重要概念，使得我们可以在单线程环境中实现并发操作。它是一种比线程更轻量级的存在，协程（coroutine）的调度完全由用户控制，协程之间的切换不涉及系统调用，开销极小。

使用方式

• run

启动异步程序的主入口，负责创建和管理事件循环。通常用于程序顶层，仅调用一次。

第一步，定义一个coroutine function。
async def：

第二步，coro = fun()
这个fun()是一个coroutine function（有点像是注册的意思），返回的是一个coroutine object，虽然调用了，但是它不会立马运行。

第三步，async.run(coro)
本身python运行的是synchronize同步模式，协程函数不能在同步模式下运行，而需要通过event loop（事件循环）来调用。使用async.run(coro)可以由同步模式变成event loop模式，这个coro就是一个coroutine object。

• await

await有点像freertos里面的信号量阻塞，**不过它是单线程的，等完一个再等第二个。**生成器也是同理。
执行await完成了两件事，一是将coroutine转化为task，告诉event loop

• create_task

create_task有点像event_loop的注册事件，告诉event_loop有几个任务在等待信号，注册的好处就是可以同时等几个任务，所以这种是适合需要等待的程序，比如网络。

• gather

gather可以同时把几个coroutine都建立任务，并且要等里面所有的任务都完成，才返回event loop控制权。

asyncio.Event()对象

asyncio.Event() 用于跨协程的事件通知。
核心方法 ：

• set() : 设置事件为已触发状态
• clear() : 重置事件为未触发状态
• wait() : 等待事件被触发（协程方法）

asyncio.Future()对象

asyncio.Future() 创建一个新的Future对象。
这个Future永远不会被设置结果（既不会set_result也不会set_exception）。
await 会一直挂起当前协程，直到Future完成（但这里永远不会完成）。

相当于同步代码中的 while True: pass 无限循环

queue标准库

Python 的 queue 库（标准库，无需安装）提供了线程安全的队列（FIFO、LIFO、优先级队列）实现，主要用于多线程编程中实现线程间的数据共享和通信。

• 队列类型

queue 模块提供了三种队列：
Queue：先进先出（FIFO）队列。
LifoQueue：后进先出（LIFO）队列（类似栈）。
PriorityQueue：优先级队列，元素按优先级排序（优先级值越小越优先）。
from queue import Queue, LifoQueue, PriorityQueue

#创建队列
fifo_q = Queue(maxsize=3)      # 最多容纳3个元素
lifo_q = LifoQueue()
priority_q = PriorityQueue()   # 元素格式：(priority, data)

• 核心方法
  通用方法
  put(item, block=True, timeout=None)
  向队列添加元素。若队列满且 block=True，会阻塞直到有空间；若 timeout 超时则抛出 queue.Full 异常。
  get(block=True, timeout=None)
  从队列取出元素。若队列空且 block=True，会阻塞直到有元素；若 timeout 超时则抛出 queue.Empty 异常。
  qsize()
  返回队列当前元素数量（注意：此值在多线程环境下可能不精确）。
  empty()
  判断队列是否为空。
  full()
  判断队列是否已满。

非阻塞方法
put_nowait(item)
等价于 put(item, block=False)，队列满时直接抛出 queue.Full。
get_nowait()
等价于 get(block=False)，队列空时直接抛出 queue.Empty。

任务完成通知
task_done()
标记一个已从队列中获取的任务完成（需与 join() 配合使用）。
join()
阻塞直到队列中所有元素被处理且 task_done() 被调用对应次数。

• 线程安全特性

queue 的队列是线程安全的，内部通过锁机制（threading.Lock）实现，无需手动处理多线程竞争问题。适合在 threading 多线程中共享数据。

selectors 模块（IO多路复用）

Python 的 selectors 模块提供了一个高级的 I/O 多路复用接口，它封装了底层的多路复用机制，如 select、poll 和 epoll。这个模块在 Python 3.4 中引入，旨在让程序员更容易地编写高性能的网络应用。

调试

tqdm进度条

tqdm 是一个用于在 Python 中显示进度条的流行库，其名称源自阿拉伯语 taqaddum（تقدّم），意为“进展”。它简单易用且高度可定制，能够为长时间运行的任务提供实时进度反馈，帮助开发者更直观地监控代码执行状态。

• 在循环中使用

from tqdm import tqdm
import time

# 在 for 循环外包裹 tqdm()
for i in tqdm(range(100)):
    time.sleep(0.1)  # 模拟耗时操作

• 手动更新（使用with）

with tqdm(total=100) as pbar:
    for i in range(10):
        time.sleep(0.1)
        pbar.update(10)  # 手动更新进度（每次增加10%）

• 自定义描述和式样

for i in tqdm(range(100), desc="Processing", ncols=100, bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}"):
    time.sleep(0.1)

• 嵌套进度条

from tqdm import trange

for i in trange(3, desc="Outer"):
    for j in trange(5, desc="Inner", leave=False):
        time.sleep(0.1)