Python实用库记录

本文主要记录一些自己遇到的一些实用的Python库，今日开文，后面会不断积累

关于Python内置知识的记录可点击 Python内置知识记录

random

作用：生成随机数

• random.randint(a, b)
  生成 $[a, b]$ 范围内随机的整数
• random.uniform(a, b)
  随机小数生成，生成$[a,b]$范围小数
• random.random()
  生成一个 $[0,1.0)$ 范围内的随机浮点数
• random.choice(sequence)
  从序列中随机获取一个元素，序列可以为 list, tuple, str
• random.shuffle(list)
  将一个列表中的元素打乱，对列表的改变是永久性的

tqdm

作用：实时显示迭代、循环的执行的进度条

trange(i) 是对tqdm(range(i)) 特殊优化过的实例，是一种简单的写法。

from tqdm import tqdm, trange
ans = 0
for i in tqdm(range(1000)):
	for j in range(20000):
        ans += 1
for i in trange(1000):
    for j in range(20000):
        ans += 1

1 基于迭代对象

from tqdm import tqdm, trange
import time
lst = ['a', 'b', 'c', 'd', 'e']
tqdm_lst = tqdm(lst)
for element in tqdm_lst:
    # 前面添加描述
    tqdm_lst.set_description('Processing ' + element)
    time.sleep(0.2)

2 手动更新

就是自己可以设置进度数

# total表示总的进度数
with tqdm(total=100) as pbar:
    pbar.set_description("Processing ")

    for i in range(10):
        time.sleep(0.1)
        # 每次增加10个进度数
        pbar.update(10)
'''
  0%|          | 0/100 [00:00<?, ?it/s]
Processing :   0%|          | 0/100 [00:00<?, ?it/s]
Processing :  10%|█         | 10/100 [00:00<00:00, 98.22it/s]
Processing :  20%|██        | 20/100 [00:00<00:00, 98.66it/s]
Processing :  30%|███       | 30/100 [00:00<00:00, 98.88it/s]
Processing :  40%|████      | 40/100 [00:00<00:00, 99.09it/s]
Processing :  50%|█████     | 50/100 [00:00<00:00, 99.31it/s]
Processing :  60%|██████    | 60/100 [00:00<00:00, 99.35it/s]
Processing :  70%|███████   | 70/100 [00:00<00:00, 99.28it/s]
Processing :  80%|████████  | 80/100 [00:00<00:00, 99.27it/s]
Processing :  90%|█████████ | 90/100 [00:00<00:00, 99.27it/s]
Processing : 100%|██████████| 100/100 [00:01<00:00, 99.17it/s]
Processing : 100%|██████████| 100/100 [00:01<00:00, 99.15it/s]
'''

# tqdm的参数解析
class tqdm(object):
  def __init__(self, iterable=None, desc=None, total=None, leave=False,
               file=sys.stderr, ncols=None, mininterval=0.1,
               maxinterval=10.0, miniters=None, ascii=None,
               disable=False, unit='it', unit_scale=False,
               dynamic_ncols=False, smoothing=0.3, nested=False,
               bar_format=None, initial=0, gui=False):

iterable ：可迭代对象，手动更新时不需要设置
desc: 字符串，左边进度条的描述文字
total：总的项目数
leave：结束后是否保留进度条

# total表示总的进度数
with tqdm(total=100, desc="Processing", leave=True) as bar:
    for i in range(10):
        time.sleep(0.1)
        # 每次增加10个进度数
        bar.update(10)

argparse

作用：命令行参数解析，使用python命令行执行py文件时，可以在命令行传入指定参数，此库就可以进行解析

from argparse import ArgumentParser
parse = ArgumentParser() # 初始化器
# 此形式的命令： python name.py --json_path path
parse.add_argument("--json_path", "-p", dest="json_path", default=None) # 命令行传入的参数
parse.add_argument("--save_path", dest="save_path", default=None) # 可以传入多个参数
args = parse.parse_args()
# 使用相关参数
json_path = args.json_path
save_path = args.save_path

add_argument参数解析：

• name or flags - 选项字符串的名字或者列表，例如 foo 或者 -f, --foo，我们一般写两个，一个长参数，一个短参数
• type - 命令行参数应该被转换成的类型
• default - 不指定参数时的默认值
• help - 参数的帮助信息
• action - 命令行遇到参数时的动作
  • store_True，表示赋值为const，如果命令行指定了参数，默认值为True，否则为False
  • append，将遇到的值存储成列表，也就是如果参数重复则会保存多个值
  • append_const，将参数规范中定义的一个值保存到一个列表
  • count，存储遇到的次数

loguru

作用：在程序中打印相关日志信息，有助于调试代码
loguru提供了七层日志层级，或者说七种日志类型。

from loguru import logger
logger.trace("A trace message.")
logger.debug("A debug message.")
logger.info("An info message.")
logger.success("A success message.")
logger.warning("A warning message.")
logger.error("An error message.")
logger.critical("A critical message.")
'''
2022-08-10 11:58:33.224 | DEBUG | __main__:<module>:12 - A debug message.
2022-08-10 11:58:33.224 | INFO | __main__:<module>:13 - An info message.
2022-08-10 11:58:33.225 | SUCCESS | __main__:<module>:14 - A success message.
2022-08-10 11:58:33.226 | WARNING | __main__:<module>:15 - A warning message.
2022-08-10 11:58:33.226 | ERROR | __main__:<module>:16 - An error message.
2022-08-10 11:58:33.227 | CRITICAL | __main__:<module>:17 - A critical message.
'''

TRACE (5): 用于记录程序执行路径的细节信息，以进行诊断。
DEBUG (10): 开发人员使用该工具记录调试信息。
INFO (20): 用于记录描述程序正常操作的信息消息。
SUCCESS (25): 类似于INFO，用于指示操作成功的情况。
WARNING (30): 警告类型，用于指示可能需要进一步调查的不寻常事件。
ERROR (40): 错误类型，用于记录影响特定操作的错误条件。
CRITICAL (50): 严重类型，用于记录阻止核心功能正常工作的错误条件。

from loguru import logger

for id in range(5):
    logger.info(f"id: {id}")
''' 结果
2024-02-01 09:54:01.537 | INFO     | __main__:<module>:4 - id: 0
2024-02-01 09:54:01.537 | INFO     | __main__:<module>:4 - id: 1
2024-02-01 09:54:01.537 | INFO     | __main__:<module>:4 - id: 2
2024-02-01 09:54:01.538 | INFO     | __main__:<module>:4 - id: 3
2024-02-01 09:54:01.538 | INFO     | __main__:<module>:4 - id: 4
'''

typing

参考： typing详解

1 基础类型注解

作用：用于元素类型的注解，为python程序提供静态类型检查。

# 下面的函数定义就代表第一个参数是str类型，第二个参数为int类型，返回值为str类型
def func(p1: str, p2: int) -> str:
	pass

2 其他注解

常见的注解还有 List, Tuple, Dict, Sequenct 等，分别代表列表、元组、字典、序列

# 对象a为列表，列表中元素类型可以为int或者float
a: List[int or float] = [1, 2.5]
# 对象b为元组，元组对应的类型分别为str，int，float
b: Tuple[str, int, float] = ('name', 18, 1.80)

2.1 Dict, Mappint

Dict、字典，是 dict 的泛型；Mapping，映射，是 collections.abc.Mapping 的泛型。
根据官方文档，Dict 推荐用于注解返回类型，Mapping 推荐用于注解参数。它们的使用方法都是一样的，其后跟一个中括号，中括号内分别声明键名、键值的类型。

def size(rect: Mapping[str, int]) -> Dict[str, int]:
    return {'width': rect['width'] + 100, 'height': rect['width'] + 100}

2.2 Set, AbstractSet

Set、集合，是 set 的泛型；AbstractSet、是 collections.abc.Set 的泛型。根据官方文档，Set 推荐用于注解返回类型，AbstractSet 用于注解参数。

2.3 Sequence

Sequence，是 collections.abc.Sequence 的泛型，在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型，我们可以使用一个更为泛化的类型，叫做 Sequence，其用法类似于 List

2.4 Union

联合类型，Union[X, Y] 代表要么是 X 类型，要么是 Y 类型。
联合类型的联合类型等价于展平后的类型：

Union[Union[int, str], float] == Union[int, str, float]

pathlib

作用：处理路径相关的操作，系统内置标准库，老版本是用的 os.path，问题较多，直接用新的 pathlib，具有诸多优势。

from pathlib import Path

1 常见方法

Path 指的是 Path实例化之后的对象

方法	作用
Path.cwd()	获取当前工作目录
Path.home()	获取当前用户目录
Path.rename()	重命名操作
Path.mkdir()	创建目录操作
Path.exists()	判断是否存在
Path.is_dir()	判断是否为目录
Path.is_file()	判断是否为文件
Path.is_symlink()	判断是否为链接

2 一些常用的文件属性

from pathlib import Path
p = Path(__file__)  # 当前文件路径
print(p.absolute()) # 获取绝对路径
print(p.resolve())  # 获取绝对路径
print(p.name)       # 获取文件名称 '1.py'
print(p.stem)       # 只要文件名，不要后缀 '1'
print(p.suffix)     # 获取文件后缀 '.py'
print(p.suffixes)   # 文件所有的后缀 ['.py']
print(p.parts)      # 拆分路径返回元组，('C:\\', 'Users', 'dell', 'Desktop', '1.py')
print(p.parent)     # 返回上层目录 C:\Users\dell\Desktop
print(p.parent.parent)  # C:\Users\dell
print(p.parents)    # 所有的父级 <WindowsPath.parents>
print(p.anchor)     # 锚，目录前面的部分 C:\ 或者 /

3 目录拼接

• 使用 / 拼接

from pathlib import Path
p = Path('./') # 当前文件路径
path = p / 'files' / 'new_file'

• 使用函数方法

p = Path('./')
print(p.absolute()) # C:\Users\dell\Desktop
# files\new_file
print(p.joinpath('files', 'new_file'))

# C:\Users\dell\Desktop\files\new_file
print(p.joinpath('files', 'new_file').absolute()) 

4 目录遍历

from pathlib import Path
p = Path('./') # 当前工作目录
for path in p.iterdir():
	print(path.absolute())

只获取文件夹

from pathlib import Path

# 当前文件路径
p = Path('./')
print([i for i in p.iterdir() if i.is_dir()]) 

多线程

推荐使用 concurent.futures.ProcessPoolExecutor 替代 multiprocessing.Pool ，前者更容易使用，有更友好的报错提示。

streamlit:快速开发可视化界面