python基础十（常用模块）

一 time与datetime模块

1、time

import time
# 时间分为三种格式：
# 1、时间戳：从1970年到现在经过的秒数
#   作用：用于时间间隔的计算
print(time.time())
# 1680886728.1569963

# 2、按照某种格式显示的时间：2022-07-06 17:12:11
#   作用：用于展示时间
print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
# 2023-04-08 00:58:48 AM
print(time.strftime('%Y-%m-%d %X'))
# 2023-04-08 00:58:48

# 3、结构化的时间
#   作用：用于单独获取时间某一部分
res = time.localtime()
print(res)
# time.struct_time(tm_year=2023, tm_mon=4, tm_mday=8, tm_hour=1, tm_min=1, tm_sec=52, tm_wday=5, tm_yday=98, tm_isdst=0)
print(res.tm_mday)
# 8

2、datetime

import datetime
print(datetime.datetime.now())  # 现在的时间
# 2023-04-08 01:05:08.986442
print(datetime.datetime.now()+datetime.timedelta(days=3))   # 三天后的时间，-3就是三天前的时间
# 2023-04-11 01:05:08.986442
print(datetime.datetime.now()+datetime.timedelta(weeks=3))   # 三周后的时间，-3就是三周前的时间
# 2023-04-29 01:05:08.986442

3、时间模块需要掌握的操作（时间格式的转换）

#  struct_time--->时间戳
import time

s_time = time.localtime()
print(time.mktime(s_time))
# 1680887720.0

# 时间戳--->struct_time
tp_time = time.time()
print(time.localtime(tp_time))
# time.struct_time(tm_year=2023, tm_mon=4, tm_mday=8, tm_hour=1, tm_min=15, tm_sec=20, tm_wday=5, tm_yday=98, tm_isdst=0)

# 补充：世界标准时间与本地时间
# print(time.gmtime())  # 世界标准时间
# time.struct_time(tm_year=2023, tm_mon=4, tm_mday=7, tm_hour=17, tm_min=42, tm_sec=54, tm_wday=4, tm_yday=97, tm_isdst=0)
# print(time.localtime())  # 本地时间，中国比标准时间早八个小时
# time.struct_time(tm_year=2023, tm_mon=4, tm_mday=8, tm_hour=1, tm_min=42, tm_sec=54, tm_wday=5, tm_yday=98, tm_isdst=0)

# struct_time-->格式化的字符串形式的时间
s_time = time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S', s_time))
# 2023-04-08 01:42:54

# 格式化的字符串形式的时间--->struct_time
print(time.strptime('2006-09-01 09:00:00', '%Y-%m-%d %H:%M:%S'))
# time.struct_time(tm_year=2006, tm_mon=9, tm_mday=1, tm_hour=9, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=244, tm_isdst=-1)

# 真正需要掌握的只有一条：format string<----->时间戳
# '1987-09-14 07:00:01'
# format string--->struct_time--->timestamp
res = time.strptime('1987-09-14 07:00:01', '%Y-%m-%d %H:%M:%S')
print(res)
# time.struct_time(tm_year=1987, tm_mon=9, tm_mday=14, tm_hour=7, tm_min=0, tm_sec=1, tm_wday=0, tm_yday=257, tm_isdst=-1)
res1 = time.mktime(res) + 7 * 86400
print(res1)
# 559177201.0

# timestamp---->struct_time--->format string
res2 = time.localtime(res1)
res3 = time.strftime('%Y-%m-%d %H:%M:%S', res2)
print(res3)
# 1987-09-21 07:00:01

# 了解知识
# time.sleep(3)   # 爬虫中模拟人
# import time
# print(time.asctime())   # linx的时间格式

import datetime

print(datetime.datetime.now())
# 2023-04-08 01:44:53.571292
print(datetime.datetime.utcnow())  # 世界标准时间
# 2023-04-07 17:44:53.571292

print(datetime.datetime.fromtimestamp(12345556662))  # 时间戳直接转换成格式化时间
# 2361-03-20 17:17:42

二 random模块

import random

print(random.random())  # (0,1)float 大于0小于1的小数
print(random.randint(1, 3))  # [1,3] 大于等于1且小于等于3之间的整数
print(random.randrange(1, 3))  # [1,3) 大于等于1且小于3之间的整数
print(random.choice([1, 'aa', [4, 5]]))  # 1或者'aa'或者[4,5]
print(random.sample([1, 'xiaobao', [4, 5]], 2))  # 列表元素任意2个组合
print(random.uniform(1, 3))  # 大于1小于3的小数，如1.923455555

item = [1, 3, 4, 6, 8]
random.shuffle(item)  # 打乱item的顺序，相当于“洗牌”
print(item)

应用：随机产生6位的大写字母和数字的验证码

# 函数功能
import random
def make_code(size):
    res = ''
    for i in range(size):
        letter = chr(random.randint(65, 95))
        number = str(random.randint(1, 10))
        chars = random.choice([letter, number])
        res += chars  # 字符串拼接
    return res
print(make_code(8))

三 os模块

import os
# ******
# 1、获取某一个文件夹下所有的子文件以及子文件夹的名字
res = os.listdir(r'E:\Python学习\python全栈学习\day58')
for x in res:
    print(x)
print(res)    # 返回一个列表
# ******
# 2、统计文件大小
size = os.path.getsize(r'E:\Python学习\python全栈学习\day58')
print(size, type(size))
# ******
os.remove(r'E:\Python学习\python全栈学习\day22\hello.text')
os.rename(r'E:\Python学习\python全栈学习\day22\hello.text', r'E:\Python学习\python全栈学习\day22\xiaobao.text')  # 重命名文件/目录
# 3、 应用程序--->向操作系统发指令，直接显示（类似于cmd,dos运行）
os.system(r"dir d:")
# 4、 产生的一个字典：key和value必须都为字符串
os.environ["aaaa"] = 'xiaobao'  # 添进去后，软件全局变量用。'sys.path'是模块导入用，'PATH'是系统调用环境变量
print(os.environ)
# 5、返回path规范化的绝对路径
print(os.path.abspath(r'C:/bbb/test.txt'))  # C:\bbb\test.txt
print(__file__)
print(os.path.abspath(__file__))
# 6、将path分割成目录和文件名二元组返回
print(os.path.split(r'C:/bbb/ccc'))  # ('C:/bbb', 'ccc'),返回一个有两个元素的元组
# ******
# 7、返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname(r'C:/bbb/ccc'))  # C:/bbb，用到了模块导入中的环境变量动态分配中使用
# ******
# 8、返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.basename(r'C:/bbb/ccc/ddd'))  # ddd
# 9、 如果path存在，返回True；如果path不存在，返回False
print(os.path.exists(r'C:/bbb/ccc/'))  # False
print(os.path.exists(r'E:\Python学习'))  # True
# 10、如果path是绝对路径，返回True        # True
print(os.path.isabs(r"C:\Users\admin\PycharmProjects\s14\Day5\test4"))
# *******
# 11、如果path是一个存在的文件，返回True,否则返回False
print(os.path.isfile(r'E:\Python学习\python全栈学习\复习\random模块应用.py'))  # True
# *******
# 12、如果path是一个存在的目录，则返回True,否则返回False
print(os.path.isdir(r'E:\Python学习\python全栈学习\复习'))  # True
# 13、返回path所指向的文件或者目录的最后存取时间
print(os.path.getatime(r'E:\Python学习\python全栈学习\复习'))  # 1680922732.0183225
# 14、返回path所指向的文件或者目录的最后修改时间
print(os.path.getmtime(r'E:\Python学习\python全栈学习\复习\random模块应用.py'))  # 1483510068.746478
# 15、无论linux还是windows，拼接出文件路径
put_filename = '%s%s%s' % ('self.home', os.path.sep, 'filename')
print(put_filename)  # self.home\filename

# os命令创建文件夹: E:/aaa/bbb/ccc/ddd并写入文件file1.txt
import os

os.makedirs('E:/aaa/bbb/ccc/ddd', exist_ok=True)  # exist_ok=True：如果存在当前文件夹不报错。创建文件夹。
path = os.path.join('E:/aaa/bbb/ccc', 'ddd')
print(path)
f_path = os.path.join(path, 'file.txt')

with open(f_path, 'w', encoding='utf8') as f:
    f.write('are you ok!!')

# 将其他目录的绝对路径动态的添加到pyhton的环境变量中

import os
import sys

print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

# 在python3.5之后，推出了一个新的模块pathlib
from pathlib import Path  # Path中得'p'是大写

res1 = Path(__file__)
print(res1)
res = res1.parent.parent
print(res)

代码解释：
要想导入其他目录中的函数，其实就是将其他目录的绝对路径动态的添加到python的环境变量中，这样python解释器就能够在运行时找到导入的模块而不报错：
然后调用sys模块sys.path.append(BASE_DIR)就可以将这条路径添加到python环境变量中

四 sys模块

1 sys.argv           命令行参数List，第一个元素是程序本身路径
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称

五 shutil模块(了解）

高级的 文件、文件夹、压缩包 处理模块

六 json&pickle模块

1、什么是序列化

内存中的数据类型---->序列化----->特定的格式（json格式或者pickle格式）
内存中的数据类型<----反序列化<-----特定的格式（json格式或者pickle格式）

土方法：
{'aaa':11}---->序列化str({'aaa':11})---->'{'aaa':11}'
{'aaa':11}<----序列化eval({'aaa':11})<----'{'aaa':11}'
2、为何要序列化
  序列化得到的结果--->特定的格式的内容有两种用途
  （1）可用于存储--->用于存档
  （2）传输给其他平台使用--->跨平台数据交互

          python                      java
           列表        特定的格式       数组

强调:
    针对用途1的特定一格式：可是一种专用的格式---->pickle只有python能识别
    针对用途2的特定二格式：应该是一种通用、能够被所有语言识别的格式--->json

3、如何序列化与反序列化

# json序列化代码
import json

info = [1, 'aaa', True, False]
with open(r"test.txt", mode='w', encoding='utf-8') as f:
    print(json.dumps(info), type(json.dumps(info)))  # 字符串格式
    f.write(json.dumps(info))

# 反序列化,将文件反序列化到内存中
with open(r"test.txt", mode='r', encoding='utf-8') as f:
    res = f.read()
    print(json.loads(res), type(json.loads(res)))  # 字符串格式

# json验证：json格式兼容的是所有语言通用的数据类型，不能识别某一语言的所独有的类型
# json.dumps({1,2,3,4}) # 集合报错

# json强调:一定要搞清楚json格式，不要与python混淆
# json格式的字符串是"",不是单引号，汉字是bytes模式表示

# 了解，python2.7和python3.5反序列化，可以加b
import json
res = '[1, "aaa", true, false]'
l = json.loads(b'[1, "aaa", true, false]')
print(l, type(l))

4、猴子补丁

# 在入口处打猴子补丁
import json
import ujson
def monkey_patch_json():
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()  # 在入口文件处运行

5、pickle

import pickle

info = {
    'name': "tom",
    "age": "100"
}
f = open("test.txt", 'wb')
f.write(pickle.dumps(info))
f.close()

# pickle反序列化代码
import pickle

f = open("test.txt", "rb")
data = pickle.loads(f.read())
f.close()
print(data["age"])

七 configparser模块

import configparser  # 主要用于配置文件，setting用+

res = configparser.ConfigParser()
res.read(r'E:\Python学习\python全栈学习\day23\test02.ini')

# 1、获取sections
print(res.sections())  # sections的列表
# ['section1', 'section2']

# 2、获取某一section下的所有options,就是获取key
print(res.options('section1'))
# ['k1', 'k2', 'k3', 'k4']

# 3、获取items
print(res.items('section1'))
# [('k1', 'xiaobao'), ('k2', 'lq'), ('k3', 'zd'), ('k4', 'cys1')]

# 4、获取Value
print(res.get('section1', 'k4'))
# cys1

八 hashlib模块

1、什么是哈希hash
  hash一类算法，该算法接受传入的内容，经过运算得到一串hash值
  hash值得特点：
1.1 只要传入的内容一样，得到的hash值必然一样--->要用明文传输密码文件完整性校验
1.2 不能由hash值反解成内容----->把密码做成hash值，不应该在网络传输明文密码
1.3 只能使用的hash算法不变，无论效验的内容有多大，得到的hash值长度是固定的

2、hash的用途
特点1.2用于账户密码密文传输与验证
特点1.1和1.2用于文件完整性效验

3、如何用

import hashlib

m = hashlib.md5()
m.update('hello'.encode('utf-8'))  # 必须是Bytes类型数据
m.update('world'.encode('utf-8'))
m.update(b'liuqiao')
res = m.hexdigest()  # 'helloworld'最终update合到一起的值
print(res)

# 文件过大的情况，用for循环
# with open('wenjian',mode='rb') as f:
#     for line in f:
#         f.read()
#         m1.update(lin2)
# 提高速度，用f.seek和read(2000)

# 模拟撞库,前提是知道密码的哈希值，建密码库，对比哈希值得正确性。
cryptograph = 'f5656ef3fe3a9235162f0dc974031b66'

password = [
    'liuhelloworld',
    'he',
    'helloworld',
    'helloworldliuqiao',
]

dic = {}
for p in password:
    m = hashlib.md5(p.encode('utf-8'))
    dic[p] = m.hexdigest()
print(dic)

# 模拟撞库得到密码
for k, v in dic.items():
    if v == cryptograph:
        print('撞库成功,密码是：', k)

# 提升撞库的成本（密码加盐）

    m=hashlib.md5()
    m.update('zd'.encode('utf-8'))
    m.update('helloworldliuqiao'.encode('utf-8'))

九 suprocess模块

import subprocess  # 系统调用命令，就是cmd

# 'dir c:'查看文件信息的命令，'stdout'正确执行命令后内容，'stderr'是错误执行命令后的内容
obj = subprocess.Popen('dir c:', shell=True,
                       stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE, )

print(obj)
res = obj.stdout.read()
print(res.decode('gbk'))  # 调用的系统命令，windows是默认的'gbk'，解码要用'gbk'

err_res = obj.stderr.read()
print(err_res.decode('gbk'))

十 logging模块

看视频

十一 re模块

# 一、动机
# 1.文本处理已经成为计算机常见工作之一
# 2.对文本内容的搜索，定位，提取是逻辑比较复杂的工作
# 3.为了快速方便的解决上述问题，产生了正则表达式技术

# 二、简介
# 1.定义
# 既文本的高级匹配模式，提供搜索，替换等功能。其本质是由一系列字符和特殊符号构成
# 的字串，这个字串即正则表达式。
# 2.原理
# 通过普通字符和有特定含义的字符，来组成字符串，用以描述一定的字符串规则，
# 比如：重复，位置等，来表达某类特定的字符串。进而匹配
s = 'hh：lqiao@qq.cn'
print(re.findall('\w+@\w+\.cn', s))
# ['lqiao@qq.cn']
# ps:正则表达式在python中也可以匹配中文

# 三、元字符使用

# 1、普通字符(除了元字符以外的普通字符，跟\w区分）
# 匹配规则：每个普通字符匹配其对应的字符
print(re.findall('ab', 'abcdefg'))
# ['ab']

# 2、或关系
# 元字符：|
# 匹配规则：匹配|两侧任意的正则表达式即可
print(re.findall('com|cn', 'https://www.baidu.com.cn'))
# ['com', 'cn']

# 3、匹配单个字符
# 元字符：.
# 匹配规则：匹配除换行外的任意一个字符
print(re.findall('张.丰', '张三丰，张四丰 张五丰'))
# ['张三丰', '张四丰', '张五丰']

# 4、匹配字符集
# 元字符：[字符集]
# 匹配规则：匹配字符集中的任意一个字符
# [abc#!好]表示[]中的任意一个字符
# [0-9],[a-z],[A-Z]表示区间内的任意一个字符
# [#?0-9a-z]混合书写，一般区间表达写在后面
print(re.findall('[aeiou]', 'How are you!'))
# ['o', 'a', 'e', 'o', 'u']

# 5、匹配字符集反集
# 元字符：[^字符集]
# 匹配规则：匹配除了字符集以外的任意一个字符
print(re.findall('[^0-9]', 'use 007 Port'))
# ['u', 's', 'e', ' ', ' ', 'P', 'o', 'r', 't']

# 6、匹配字符串开始位置
# 元字符：^
# 匹配规则：匹配目标字符串的开头位置
print(re.findall('^Jame', 'Jame,hello'))
# ['Jame']
print(re.findall('^Jame', 'hello,Jame,hello'))
# []未匹配到

# 7、匹配字符串的结束位置
# 元字符：$
# 匹配规则：匹配目标字符串的结尾位置
print(re.findall('Jame$', 'Hi,Jame'))
# ['Jame']

# 规则技巧：^和$必然出现在正则表达式的开头和结尾处。
# 如果两者同时出现，则中间的部分必须匹配整个目标字符串的全部内容，也叫完全匹配或叫绝对匹配
print(re.findall('^Jame$', 'Jame'))
# ['Jame']

# 8、匹配字符重复
# 元字符：*
# 匹配规则：匹配前面的字符出现0次或多次
print(re.findall('wo*', 'woooo~~w'))
# ['woooo', 'w']  *只控制o,o的0次或多次
print(re.findall('[A-Z][a-z]*', 'How are you Fine Jam'))  # 小写字母重复多次或0次，大写字母开头
# ['How', 'Fine', 'Jam']

# 元字符：+
# 匹配规则：匹配前面的字符出现1次或多次
print(re.findall('[A-Z][a-z]+', 'Hello World'))  # 小写字母出现一次以上
# ['Hello', 'World']
print(re.findall('[A-Z][a-z]+', 'I am Y'))
# [] 小写字母0次，所以匹配不出来

# 元字符：？
# 匹配规则：匹配前面的字符出现0次或1次
print(re.findall('-?[0-9]+', 'Jame,age；18，-26'))
# ['18', '-26']
print(re.findall('-?[0-9]+', '233 d d , -33,34  -44'))  # 匹配数字，含负数
# ['233', '-33', '34', '-44']

print(re.findall('[^ ]+', 'Port-9 Error #404# %@ST'))  # 除了空格以外的出现了一次或者多次
# ['Port-9', 'Error', '#404#', '%@ST']

# 元字符：{n}
# 匹配规则：匹配前面的字符出现n次
print(re.findall('1[0-9]{10}', 'Jame:13882334448'))  # 1开头，数字出现10次
# ['13882334448']
print(re.findall('ab{3}', 'abb abbbb ab'))  # b出现3次
# ['abbb']

# 元字符：{m,n}
# 匹配规则：匹配前面的字符出现m-n次
print(re.findall('[1-9][0-9]{5,10}', 'qq:1259296994'))  # 5到10（含）的数都能收到
# # ['1259296994']
print(re.findall('[1-9][0-9]{5,10}', 'qq:1259296'))  # 5到10（含）的数都能收到
# ['1259296']
# ['1259296994']

# 9、匹配任意（非）数字字符
# 元字符：\d\D
# 匹配规则：\d 匹配任意数字字符，\D匹配任意非数字字符
print(re.findall('\d{1,5}', 'Mysql:3306,http:80'))
# ['3306', '80']
print(re.findall('\D', 'Mysql:3306,http:80'))
# ['M', 'y', 's', 'q', 'l', ':', ',', 'h', 't', 't', 'p', ':']
print(re.findall('\D+', 'Mysql:3306,http:80'))
# ['Mysql:', ',http:']

# 10、匹配任意（非）普通字符
# 元字符：\w\W
# 匹配规则：\w匹配普通字符，\W匹配非普通字符
# 说明：普通字符指数字，字母，下划线，汉字，utf-8字符都可以
print(re.findall('\w+', 'server_port = 8888'))
# ['server_port', '8888']
print(re.findall('\W+', 'server_port = 8888'))
# [' = ']

# 11、匹配任意（非）空字符
# 元字符：\s\S
# 匹配规则：\s 匹配空字符，\S匹配非空字符
# 说明：空字符指 空格\r\n\t\v\f字符
print(re.findall('\w+\s+\w+', 'hello   world'))
# ['hello   world']
print(re.findall('\S+', 'hello   world'))
# ['hello', 'world']

# 12、匹配开头结尾位置
# 元字符：\A\Z
# 匹配规则：\A表示开头位置，\Z表示 结尾位置

# 13、匹配（非）单词的边界位置
# 元字符：\b\B
# 匹配规则：\b表示单词边界，\B表示非单词边界
# 说明：单词边界指数字字母（汉字）下划线与其他字符的交界位置
print(re.findall(r'\bis\b', 'This is a test.'))
# ['is']

# 总结
# 匹配字符：. [] [^] \d \D \w \W \s \S
# 匹配重复：* + ？ {n} {m,n}
# 匹配位置：^ $ \A \Z \b \B
# 其他：|  ()  \

# 四、正则表达式的转义
# 1、如果使用正则表达式匹配特殊字符则需要加\表示转义，就匹配元字符需要前面加\
# 2、在编程语言中，常使用原生字符串书写正则表达式避免多重转义的麻烦
# python字符串----》 正则  ------》 目标字符串
# '\\$\\d+'   解析为   \$\d+    匹配    '$100'
# '\\$\\d+'   等同于   r'\$\d+'

# 五、贪婪模式和非贪婪模式
# 1、定义
# 贪婪模式：默认情况下，匹配重复的元字符总是尽可能多的向后匹配内容。比如：* + ？ {m,n}
# 总是向0次和多次，会向多次索取；{m,n}可以实m次，但向n次索取
# 非贪婪模式（懒惰模式）：让匹配重复的元字符尽可能少的向后匹配内容
# 2、贪婪模式转换为非贪婪模式
# 在匹配重复元字符后加'?'号即可
# *？  +？  ？？  {m,n}?

print(re.findall(r'\(.+\)', '(abcd)efgh(higk)'))
# ['(abcd)efgh(higk)']
print(re.findall(r'\(.+?\)', '(abcd)efgh(higk)'))
# ['(abcd)', '(higk)']

# 六、正则表达式分组

# 1.定义
# 在正则表达式中，以()建立正则表达式的内部分组，子组是正则表达式的一部分，
# 可以作为内部整体操作对象

# 2.作用
# 可以被作为整体操作，改变元字符的操作对象
print(re.search(r'(ab)+', 'ababababab').group()) # +的作用不在b上了，是作用整体'ab'上
# ababababab
# 可以通过编程语言某些接口获取匹配内容中，子组对应的内容部分
print(re.search(r'(https|http|ftp|file)://\S+', 'https://www.baidu.com').group(1))
# https
# 3、捕获组
# 可以给正则表达式的子组起一个名字，表达该子组的意义。
# 这种有名称的子组即为捕获组。
# 格式：(?P<name>pattern)
print(re.search(r'(?P<pig>ab)+', 'ababababab').group('pig'))
# ab
# 一个正则表达式中可以包含多个子组
# 子组可以嵌套，但是不要重叠或者嵌套结构复杂
# 子组序列号一般从外到内，从左到右计数

# 七、正则表达式匹配原则

# 1、正确性，能够正确的匹配出目标字符串
# 2、排他性，除了目标字符串之外尽可能少的匹配其他内容
# 3、全面性，尽可能考虑到目标字符串的所有情况，不遗漏

# 八、正则表达式模块使用

参考：re模块

十二 uuid模块

https://www.cnblogs.com/liuqingzheng/articles/9872350.html