标签：转换   操作审计   级别   config   dict   重命名文件   线程id   软件开发   ext   

常用标准库

标准库 说明

• builtins 内建函数默认加载
• math 数学库
• random 生成随机数
• time 时间
• datetime 日期和时间
• calendar 日历
• hashlib 加密算法
• copy 拷贝
• functools 常用的工具
• os 操作系统接口
• re 字符串正则匹配
• sys Python自身运行环境
• multiprocessing 多线程
• threading 多线程
• json 编码和解码 JSON 对象
• logging 记录日志，调试

一、random模块

此模块提供了和随机数获取的相关方法

1、random.random() 获取[0.0, 1.0)范围内的浮点数

print(random.random()) # 0.25394249521062395

2、random.randint(a, b) : 获取[a, b]范围内的一个整数

print(random.randint(3, 5)) # 5

3、random.uniform(a, b) : 获取[a, b)范围内的浮点数

print(random.uniform(3, 4)) # 3.3344853160466155

4、random.shuffle(x) : 把参数指定的数据中的元素打乱，参数必须是一个可变的数据类型

? list1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print(list1) # [4, 1, 2, 3, 5]

5、random.samlpe(x,k) : 从x中随机抽取k个数据，组成一个列表返回

? list1 = [1, 2, 3, 4, 5]
print(random.sample(list1, 3)) # [2, 4, 5]

二、time模块

1、时间戳

t1 = time.time() # (从1970.1.1 00:00:00到现在的秒数)
print(t1) # 1590794054.9363732

2、ctime 将时间戳转成字符串

t2 = time.ctime(time.time())
print(t2) # Sat May 30 07:14:14 2020

3、localtime 将时间戳转成元组

t3 = time.localtime(time.time())
print(t3) # time.struct_time(tm_year=2020, tm_mon=5, tm_mday=30,

# tm_hour=7, tm_min=14, tm_sec=14, tm_wday=5, tm_yday=151, tm_isdst=0)

4、gmtime 格式化时间对象 (格林尼治时间：欧洲时间标准)

print(time.gmtime()) # time.struct_time(tm_year=2020, tm_mon=5, tm_mday=29,

# tm_hour=23, tm_min=19, tm_sec=47, tm_wday=4, tm_yday=150, tm_isdst=0)

5、mktime 将元组转成时间戳

t4 = time.mktime(t3)
print(t4) # 1590794054.0

6、strftime 将时间标准格式化输出

%Y Year with century as a decimal number.

%m Month as a decimal number [01,12].

%d Day of the month as a decimal number [01,31].

%H Hour (24-hour clock) as a decimal number [00,23].

%M Minute as a decimal number [00,59].

%S Second as a decimal number [00,61].

t5 = time.strftime("%Y-%m-%d %H:%M:%S")
print(t5) # 2020-05-30 07:14:14

7、strptime 将时间字符串转成元组

t6 = time.strptime("2020-02-15","%Y-%m-%d")
print(t6) # time.struct_time(tm_year=2020, tm_mon=2, tm_mday=15,

# tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=46, tm_isdst=-1)

8、time.sleep(x) 暂停当前程序，睡眠x秒

? time.sleep(x)

三、datatime模块

1、date 日期 类，需要创建对象

d2 = datetime.date(2020, 2, 15) # 2020-2-15
print(d2.year) # 2020
print(d2.month) # 2
print(d2.day) # 15
print(datetime.date.ctime(d2)) # Sat Feb 15 00:00:00 2020

2、today 获取当前日期

print(datetime.date.today()) # 2020-05-30

3、time 时间

t = datetime.time(7, 42, 32)
print(t.hour) # 7
print(t.minute) # 42
print(t.second) # 32

4、datetime 创建日期时间

print(datetime.datetime(2020, 2, 15, 8, 25, 32)) # 2020-02-15 08:25:32

# 当前时间

d4 = datetime.datetime.now() # 2020-05-30 07:46:29.241167
print(d4)

5、timedelta 设置时间差

datetime_timedelta = datetime.timedelta(seconds=60)

# 利用时间差进行操作(只能使用date、datetime、timedelta进行运算)

d5 = d4 + datetime_timedelta
print(d5) # 2020-05-30 07:47:29.241167

四、os、sys模块

1、Os 操作系统相关的操作

序号 方法及描述
os.path 模块 获取文件的属性信息。
os.remove(path) 删除path文件。如果path是文件夹，将抛出OSError;
os.removedirs(path) 递归删除目录。(目录必须是空的)
os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
shutil.rmtree(path) （需导包）递归删除目录
os.rename(src, dst) 重命名文件或目录，从 src 到 dst
os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。

2、os.path 文件相关操作

方法 说明
os.path.dirname(path) 返回文件路径（不判断路径是否存在）
os.path.basename(path) 返回文件名（不判断文件是否存在）
os.path.split(path) 把路径分割成 dirname 和 basename，返回一个元组（不判断文件和路径是否存在）
os.path.splitext(path) 分割路径，返回路径名和文件扩展名的元组
os.path.join(path1[, path2[, ...]]) 把目录和文件名合成一个路径
os.path.abspath(path) 返回绝对路径
os.path.isabs(path) 判断是否为绝对路径
os.path.isdir(path) 判断路径是否为目录
os.path.exists(path) 路径存在则返回True,路径损坏返回False
os.path.isfile(path) 判断路径是否为文件
os.path.getctime(path) 返回文件 path 创建时间
os.path.getatime(path) 返回最近访问时间（浮点型秒数）
os.path.getmtime(path) 返回最近文件修改时间

3、sys

sys.argv 获取命令行方式运行的脚本后面的参数

print(sys.argv[0]) # 脚本名 F:/pycharm/first_demo/module/module_demo/sys_01.py

print(sys.argv[1]) # 第一个参数

print(sys.argv[2]) # 第二个参数

sys.path 系统（解释器）寻找模块的路径

print(sys.path) # 列表形式

sys.modules 返回系统已经加载的模块，以字典形式返回

print(sys.modules)

五、json模块

json(JavaScript Object Notation) : java脚本对象标记语言，一种简单的数据交换格式。

序列化

将内存中的数据，转换成字节串，用以保存在文件或通过网络传输称为序列化过程

反序列化

从文件、网络中获取的数据，转换成内存中原来的数据类型称为反序列化过程

json :将数据结构（list，tuple，dict）转化成字符串，用于存储或网络传输，并且可以反转回去。

序列化

dumps 把指定的对象转化成json格式的字符串

s = json.dumps([1, 2, 3])
print(s, type(s)) # ‘[1, 2, 3]‘ <class ‘str‘>

s = json.dumps((1, 2, 3))
print(s, type(s)) # ‘[1, 2, 3]‘ <class ‘str‘> 元组序列化后，变成列表

s = json.dumps({‘name‘: ‘Jack‘, ‘age‘: 18})
print(s, type(s)) # ‘{‘name‘: ‘Jack‘, ‘age‘: 18}‘ <class ‘str‘>

dump 将json结果写到文件中

with open(‘filename.txt‘, ‘at‘, encoding=‘utf-8‘) as f:
json.dump([1, 2, 3], f)

反序列化

loads # 将json转换成原数据类型

res1 = json.dumps([1, 2, 3])
res2 = json.loads(res1)
print(res2, type(res2)) # [1, 2, 3] <class ‘list‘>

res1 = json.dumps((1, 2, 3))
res2 = json.loads(res1) # 元组会变成列表
print(res2, type(res2)) # [1, 2, 3] <class ‘list‘>

load 从文件中将Json反序列化

with open(‘filename.txt‘, encoding=‘utf-8‘) as f:
res1 = json.load(f)
print(res1, type(res1)) # [1, 2, 3] <class ‘list‘>

Json特性

json 通常是一次性写，一次性读，使用另一种方法，实现多次写，多次读

把序列化的对象，通过多次序列化的方式，用文件的write方法，把多次系列化后的json字符写到文件中
with open(‘filename.txt‘, mode="at", encoding=‘utf-8‘) as f:
f.write(json.dumps([1, 2, 3]) + ‘\n‘)
f.write(json.dumps([4, 5, 6]) + ‘\n‘)

# 把分次序列化的json字符串，反序列化回来

方法一：
with open(‘filename.txt‘, mode="rt", encoding=‘utf-8‘) as f:
res1 = json.loads(f.readline().strip())
res2 = json.loads(f.readline().strip())
print(res1, res2) # [1, 2, 3] [4, 5, 6]

方法二：
with open(‘filename.txt‘, mode="rt", encoding=‘utf-8‘) as f:
for line in f:
print(json.loads(line))

输出：
[1, 2, 3]
[4, 5, 6]

JSON序列化日期类型

通过json学列化时间日期格式数据的时候需要注意，不能直接序列化，可借助类

import json
from datetime import datetime
from datetime import date

对含有日期格式数据的json数据进行转换

class JsonCustomEncoder(json.JSONEncoder):
def default(self, field):
if isinstance(field,datetime):
return field.strftime(‘%Y-%m-%d %H:%M:%S‘)
elif isinstance(field,date):
return field.strftime(‘%Y-%m-%d‘)
else:
return json.JSONEncoder.default(self,field)

d1 = datetime.now()
dd = json.dumps(d1,cls=JsonCustomEncoder)

六、pickle模块

将python中所有的数据类型转换成字节串，序列化过程

将字节串转化成Python的数据类型，反序列化过程

pickle场景

和json一样：一次性写入，一次性读取

pickle 所有的数据类型都可以进行序列化

bys1 = pickle.dumps([1, 2, 3])
print(bys1, type(bys1)) # b‘\x80\x03]q\x00(K\x01K\x02K\x03e.‘ <class ‘bytes‘>

保存了元组的数据类型

bys2 = pickle.dumps((1, 2, 3))
print(bys2, type(bys2)) # b‘\x80\x03K\x01K\x02K\x03\x87q\x00.‘ <class ‘bytes‘>

res1 = pickle.loads(bys2)
print(res1) # (1, 2, 3)

set类型也可以进行序列化

bys3 = pickle.dumps({1, 2, 3})
res2 = pickle.loads(bys3)
print(res2, type(res2)) # {1, 2, 3} <class ‘set‘>

# 将pickle序列化内容写入文件

with open(‘filename.txt‘, mode=‘wb‘) as f:
pickle.dump([1, 2, 3], f)

# 从文件中反序列化pickle数据

with open(‘filename.txt‘, mode=‘rb‘) as f:
res = pickle.load(f)
print(res, type(res)) # [1, 2, 3] <class ‘list‘>

json和pickle的对比

json:
不是所有的数据类型都可以序列化，结果是字符串
不能多次对同一个文件序列化
Json数据可以跨语言
pickle：
所有python类型都能序列化，结果是字符串
可以多次对同一个文件序列化
不能跨语言

七、hashlib模块

hashlib ：封装一些用于加密的类。

目的 ：用于判断和验证，而并非解密

特点

? 把一个大的数据，切分成不同块，分别对不同的快进行加密，在汇总结果，和直接对整体数据加密的结果是一致的。
? 单向加密。不可逆。
? 原始数据的一点变化，将导致结果非常大的差异，‘雪崩’效应

数据加密三大步骤

? 1、获取一个加密对象
? 2、使用加密对象的update，进行加密，update方法可以调用多次
? 3、通常使用hexdigest获取加密结果，或digest() （获取的是字节串）

不同的加密算法：加密结果的长度不同
sha225(), sha256(), sha384() .....
对应的二进制位数，表示使用16进制

获取一个加密对象

m = hashlib.md5()

update() 方法加密

m.update(‘abc中文‘.encode(‘utf-8‘))

hexdigest 获取加密结果

res = m.hexdigest()
print(res) # 1af98e0571f7a24468a85f91b908d335

m1 = hashlib.md5()
m1.update(b‘abc‘)
m1.update(b‘def‘)
print(m1.hexdigest()) # e80b5017098950fc58aad83c8c14978e

m2 = hashlib.md5()
m2.update(b‘abcdef‘)
print(m2.hexdigest()) # e80b5017098950fc58aad83c8c14978e

八、collections模块

1、namedtuple() : 命名元组

Rectangle = namedtuple(‘Rectangle_class‘, [‘length‘, ‘width‘])

r = Rectangle(10, 5)

# 通过属性访问元组的元素

print(r.length) # 10
print(r.width) # 5

# 通过索引的方式访问元组

print(r[0], r[1]) # 10 5

defaultdict() : 默认值字典

d = defaultdict(int, name=‘Andy‘, age=10)
print(d[‘name‘]) # Andy
print(d[‘age‘]) # 10
print(d[‘addr‘]) # 0 {‘addr‘: 0} 也会被添加进字典
print(d) # defaultdict(<class ‘int‘>, {‘name‘: ‘Andy‘, ‘age‘: 10, ‘addr‘: 0})

# 自定义函数充当第一个参数

# 要求，不能有参数

def f():
return ‘hello‘

d = defaultdict(f, name=‘Andy‘, age=10)
print(d[‘addr‘]) # hello
print(d) # defaultdict(<function f at 0x00000145D90E8B88>, {‘name‘: ‘Andy‘, ‘age‘: 10, ‘addr‘: ‘hello‘})

Counter() : 计数器

# Counter: 计数器

c = Counter(‘aabvcaavcavacvca‘)
print(c) # Counter({‘a‘: 7, ‘v‘: 4, ‘c‘: 4, ‘b‘: 1})

# most_common 打印前三的数据

print(c.most_common(3)) # [(‘a‘, 7), (‘v‘, 4), (‘c‘, 4)]

九、shutil模块

文件相关相关的操作

copy2() 复制文件

# shutil.copy2(‘原文件‘, ‘现文件‘)

copytree() 复制目录

shutil.copytree(‘原目录‘, ‘新目录‘, ignore=shutil.ignore_patterns(‘*.pyc‘))

# ignore 忽略； *.pyc 忽略以.pyc结尾的文件

rmtree() 删除目录

shutil.rmtree(‘path‘, ignore_errors=True)

move() 移动文件

shutil.move(‘原目录‘, ‘新目录‘, copy_function=shutil.copy2)

disk_usage() 获得磁盘的使用空间

total, used, free = shutil.disk_usage(".")
# total 总共
# used 已使用
# free 剩余

make_archive() 压缩文件

shutil.make_archive(‘压缩文件夹的名字‘, ‘zip‘, ‘带压缩的文件夹路径‘)

unpack_archive() 解压文件

shutil.unpack_archive(‘要解压的文件‘, ‘要解压的路径‘)

十、logging模块

用途：
排错、数据分析，操作审计

简单配置

# 输出内容是有等级的 ： 默认处理warning以上的信息

logging.debug(‘debug message‘) # 调试
logging.info(‘info message‘) # 信息
logging.warning(‘warning message‘) # 警告
logging.error(‘error message‘) # 错误
logging.critical(‘critical message‘) # 批判性的
输出：
WARNING:root:warning message
ERROR:root:error message
CRITICAL:root:critical message

灵活配置日志级别，日志格式，输出位置

basicConfig标准配置信息

logging.basicConfig(
format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s‘,
datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
)

配置完毕后调用logging
logging.warning("这是一个警告信息！")
输出：
2020-06-01 18:12:50 PM - root - WARNING[line:19] -logging_01: 这是一个警告信息！

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(name)s logger的名字
%(levelno)s 数字形式的日志级别
%(module)s 调用日志输出函数的模块名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(funcName)s 调用日志输出函数的函数名
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

打印到文件中

# 调整日志打印级别和日志文件

logging.basicConfig(
format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s‘,
datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
filename= ‘tmp.log‘,
level=logging.DEBUG
)
在文件中中文会出现乱码，并且不能显示在控制台

打印到控制台和解决乱码
fh = logging.FileHandler(‘tem.log‘, encoding=‘utf-8‘) # 输出到文件
sh = logging.StreamHandler() # 输出到控制台
logging.basicConfig(
format=‘%(asctime)s - %(name)s - %(levelname)s[line:%(lineno)d] -%(module)s: %(message)s‘,
datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
level=logging.DEBUG,
handlers=[fh, sh]
)

logging.warning("这是一个警告信息！")

日志切割

from logging import handlers

sh = logging.StreamHandler() # 打印到控制台

# 按文件大小进行切分

rh = handlers.RotatingFileHandler(‘my_app_size.log‘, maxBytes=1024, backupCount=5)

# 按文件时间进行切分

fh = handlers.TimedRotatingFileHandler(filename=‘my_app_time.log‘, when=‘s‘, interval=5, encoding=‘utf-8‘)
logging.basicConfig(
format=‘%(asctime)s - %(name)s - %(levelname)s[line:%(lineno)d] -%(module)s: %(message)s‘,
datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
level=logging.DEBUG,
handlers=[fh, rh, sh]
)

for i in range(100):
time.sleep(0.2)
logging.warning("这是一个警告信息！")

软件开发规范
所有代码不可能全部写入一个文件，加载效率低，不容易查找，不规范

10_常用标准库

标签：转换   操作审计   级别   config   dict   重命名文件   线程id   软件开发   ext   

原文地址：https://www.cnblogs.com/q121211z/p/13344962.html