10_常用标准库

常用标准库

标准库说明

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'>

# json序列化中文时，会自动转换成Unicode编码
res = json.dumps('中国')
print(res)  # "\u4e2d\u56fd"

# 直接显示中文时指定ensure_ascii=False
res = json.dumps('中国', ensure_ascii=False)
print(res)  # "中国"

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("这是一个警告信息！")

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

十一、pymysql模块

python操作mysql数据库

Pymysql的安装和数据库连接
PyMySQL的安装：pip install PyMySQL

python连接数据库

import pymysql
db = pymysql.connect("数据库ip","用户","密码","数据库" ) # 打开数据库连接
cursor.execute("SELECT VERSION()")     # 使用 execute() 方法执行 SQL 查询
data = cursor.fetchone()         # 使用 fetchone() 方法获取单条数据
print ("Database version : %s " % data)
db.close()            # 关闭数据库连接

创建表操作

import pymysql
# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

#使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

#使用 execute() 方法执行 SQL，如果表存在则删除
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#使用预处理语句创建表
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

#关闭数据库连接
db.close()

操作数据

插入操作

import pymysql

#打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

#使用cursor()方法获取操作游标 
cursor = db.cursor()

#SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
   cursor.execute(sql) # 执行sql语句
   db.commit()         # 提交到数据库执行
except:
   db.rollback()       # 如果发生错误则回滚

#关闭数据库连接
db.close()

查询操作

Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。

fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
fetchall(): 接收全部的返回结果行.
rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。

import pymysql

#打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

#使用cursor()方法获取操作游标 
cursor = db.cursor()

#SQL 查询语句
sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > %s" % (1000)
try:
   cursor.execute(sql)# 执行SQL语句
   results = cursor.fetchall()# 获取所有记录列表
   for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]
       # 打印结果
      print ("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \
             (fname, lname, age, sex, income ))
except:
   print ("Error: unable to fetch data")

#关闭数据库连接
db.close()

更新操作

import pymysql

#打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

#使用cursor()方法获取操作游标 
cursor = db.cursor()

#SQL 更新语句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')
try:
   cursor.execute(sql)  # 执行SQL语句
   db.commit()          # 提交到数据库执行
except
   db.rollback()        # 发生错误时回滚

#关闭数据库连接
db.close()

删除操作

import pymysql

#打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

#使用cursor()方法获取操作游标 
cursor = db.cursor()

#SQL 删除语句
sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)
try
   cursor.execute(sql)  # 执行SQL语句
   db.commit()          # 提交修改
except
   db.rollback()        # 发生错误时回滚# 关闭连接
db.close()

posted @ 2020-07-20 14:37 小金a 阅读(77) 评论(0) 收藏举报

刷新页面返回顶部

小金a

10_常用标准库

常用标准库

一、random模块

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

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

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

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

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

二、time模块

1、时间戳

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

3、localtime 将时间戳转成元组

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

5、mktime 将元组转成时间戳

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

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

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

三、datatime模块

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

2、today 获取当前日期

3、time 时间

4、datetime 创建日期时间

5、timedelta 设置时间差

四、os、sys模块

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

2、os.path 文件相关操作

3、sys

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

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

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

五、json模块

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

序列化

反序列化

序列化

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

dump 将json结果写到文件中

反序列化

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

load 从文件中将Json反序列化

Json特性

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

JSON序列化日期类型

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

六、pickle模块

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

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

pickle场景

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

保存了元组的数据类型

set类型也可以进行序列化

json和pickle的对比

七、hashlib模块

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

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

特点

数据加密三大步骤

获取一个加密对象

update() 方法加密

hexdigest 获取加密结果

八、collections模块

1、namedtuple() : 命名元组

defaultdict() : 默认值字典

Counter() : 计数器

九、shutil模块

copy2() 复制文件

copytree() 复制目录

rmtree() 删除目录

move() 移动文件

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

make_archive() 压缩文件

unpack_archive() 解压文件

十、logging模块

简单配置

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

basicConfig标准配置信息

打印到文件中

日志切割

十一、pymysql模块

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

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