内置模块:time, datetime, random, json, pickle, os, sys, hashlib, collections, re

1.time模块

import time

time.time() # 时间戳  浮点数

time.sleep() # 睡眠

time.gmtime()/time.localtime() #结构化时间 数据类型是命名元祖

time.strftime('格式化','结构化时间')

time.strptime('字符串','格式化')

time.mktime('结构化时间') #结构化时间转时间戳

# 将时间戳转换成字符串时间

print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(1564028611.631374)))

# 将字符串时间转换成时间戳

print(time.mktime(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S")))

2. datetime

1. 获取当前日期和时间

form datetime import datetime

print(datetime.now())

print(datetime(2018,5,20,13,14)) #获取指定日期和时间

2. datetime 与时间戳的转换

form datetime import datetime

print(datetime.now().timestamp()) # 转时间戳

import time

from datetime import datetime

print(datetime.fromtimestamp(time.time()))

3. str 与 datetime的转换

print(datetime.strptime("2019-10-10 22:23:24","%Y-%m-%d %H:%M:%S")) # 将字符串转换成datetime

print(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) # 将datetime转换成字符串

print(str(datetime.now()))

4. datetime加减

from datetime import datetime, timedelta

print(datetime.now() + timedelta(days=1))

print(datetime.now() - timedelta(hours=3))

3. random 随机模块

import random

print(random.random()) # 0~1之间的浮点数

print(random.uniform(1,10)) #1~10之间的浮点数

print(random.randint(1,50)) #1~50之间的整数(闭区间)

print(random.randrange(1,5,2)) #(起始,终止,步长)

print(random.choice([1,2,3,4,5,]))#随机选择一个

print(random.choices([1,2,3,4,5,],k=2))#随机选两个,会有重复数字,列表形式

print(random.sample((1,2,3,4,5),k=2))#随机选两个,不会有重复数字,列表形式

lst = [1,2,3,4,5,6,7,8,9,0]

random.shuffle(lst) # 打乱顺序

print(lst)

随机产生验证码:

import random

def y_code():

    code = ''

    for i in range(4):

        num = chr(random.randint(48,57))

        # 取数字

        alf = chr(random.randint(97,122))

        # 取小写字母

        alf_upper = chr(random.randint(65,90))

        # 取大写字母

        s = str(random.choice([num,alf,alf_upper]))

        code = ''.join([code,s])

    return code

print(y_code())

4. 序列化模块

将一种数据结构（如字典、列表)等转换成一个特殊的序列（字符串或者bytes）的过程就叫做序列化.

主要用途：文件读写数据，网络传输数据。

4.1 json模块

json模块是将满足条件的数据结构转化成特殊的字符串，并且也可以反序列化还原回去。

json序列化只支持部分Python数据结构：dict,list, tuple,str,int, float,True,False,None

用于网络传输：dumps、loads

用于文件写读：dump、load

4.1.1 dumps、loads

1. 将字典类型转换成字符串类型

import json

dic = {'key1':'1','key2':2}

str_dic = json.dumps(dic)

print(str_dic,type(str_dic))  # 字符串

2. 将字符串类型的字典转换成字典类型

dic1 = json.loads(str_dic)

print(dic1,type(dic1))

3. 还支持列表类型

import json

lit = [1,2,"3",4]

str_lst = json.dumps(lit)

print(str_lst,type(str_lst))

lst = json.loads(str_lst)

print(lst,type(lst))

4.1.2 dump、load

1. 讲对象转换成字符串写入到文件中

dic = {'key1':1}

with open('a1.txt','a',encoding='utf-8')as f:

    json.dump(dic,f)

2. 将文件中的字符串类型的字典转换成字典

with open('a1.txt','r',encoding='utf-8')as f1:

    dic1 = json.load(f1)

print(dic1)

4.1.3 json序列化存储多个数据到同一个文件中

with open('a1.txt','r',encoding='utf-8')as f1:

    for i in f1:

        lst = json.loads(i)

        print(lst)

4.2 pickle模块

pickle模块是将Python所有的数据结构以及对象等转化成bytes类型，然后还可以反序列化还原回去。

pickle模块是只能Python语言识别的序列化模块。

用于网络传输：dumps、loads

用于文件写读：dump、load

4.2.1 dumps、loads

import json

dic = {'key1':'1','key2':2}

str_dic = pickle.dumps(dic)

print(str_dic,type(str_dic))  # 类似字节

dic1 = pickle.loads(str_dic)

print(dic1,type(dic1))

4.2.2 dump、load

with open('a1.txt','ab')as f:

    pickle.dump(dic,f)

with open('a1.txt','rb')as f1:

    dic1 = pickle.load(f1)

print(dic1)

4.2.3 pickle序列化存储多个数据到一个文件中

import pickle

dic = {"1":2}

f = open("info","wb")

s = "\n".encode("utf-8")

f.write(pickle.dumps(dic)+ s)

f.write(pickle.dumps(dic)+ s)

f.write(pickle.dumps(dic)+ s)

f.close()

f1 = open("info","rb")

for i in f1:

    print(pickle.loads(i))

5. os模块

os模块是与操作系统交互的一个接口

os模块四组:

1. 工作目录

import os

print(os.getcwd()) # 当前工作路径  ***

os.chdir("F:\s24\day06") # 路径切换 ***

print(os.curdir)  # 当前目录

print(os.pardir)  # 当前目录的父级目录

2. 文件夹

import os

os.mkdir("ttt") # 创建一个文件夹  ***

os.rmdir("ttt") # 删除一个文件夹,若不为空则无法删除,报错  ***

os.makedirs("ttt/sss/ddd/ee")  # 递归创建文件夹     ***

os.removedirs("ttt/sss/ddd/ee")  # 递归删除文件夹,若为空删除,不为空不删除   ***

print(os.listdir(r"F:\s24\day17"))  # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印***

3. 文件

import os

os.remove()  # 删除一个文件  ***

os.rename("oldname","newname")  # 重命名文件/目录  ***

4. 路径

import os

print(os.path.abspath(r"01 今日内容.py"))  # 通过相对路径获取绝对路径  ***

print(os.path.split(os.path.abspath(r"01 今日内容.py")))  #将路径以最后一个\切割(路径,文件名)

print(os.path.dirname(r"F:\s24\day17\01 今日内容.py"))  # 获取路径 ***

print(os.path.basename(r"F:\s24\day17\01 今日内容.py")) # 获取文件名 ***

print(os.path.exists(r"F:\s24\day17\01 今日内容.py"))  # 判断这个路径是否存在  ***

print(os.path.isdir(r"F:\s24\day17"))     # 判断是不是路径  ***

print(os.path.isfile(r"01 今日内容.py"))  # 判断是不是文件  ***

print(os.path.isabs(r"F:\s24\day17\01 今日内容.py"))     # 判断是不是绝对路径 ***

print(os.path.join("D:\\\\","ttt","bbb"))                # 路径拼接 *****

print(os.path.getatime(r"F:\s24\day17\04 序列化.py"))      # 最后的修改时间

print(os.path.getctime(r"F:\s24\day17\04 序列化.py"))      # 最后的访问时间

print(os.path.getmtime(r"F:\s24\day17\04 序列化.py"))      # 最后的访问时间

print(os.path.getsize(r"F:\s24\day09"))                       # 获取当前文件的大小   ***

6. sys模块

sys模块是与python解释器交互的一个接口

import sys

if sys.argv[-1] == "alex":

    print("dsb")

else:

    print("cjb")

print(sys.argv[-1])

# 当前文件运行['F:/s24/day17/06 sys.py'] ***

import sys

print(sys.exit(1))   #退出程序，正常退出时exit(0),错误退出sys.exit(1)

print(sys.version)  # 获取解释器版本

print(sys.path)     # 添加自定义模块查找路径 *****

print(sys.platform)   # *** 区分操作系统然后进行相关逻辑操作

7. hashlib模块

加密和校验

md5,sha1,sha256,sha512

1.只要明文相同密文就是相同的

2.只要明文不相同密文就是不相同的

3.不能反逆(不能解密) -- md5中国人破解了

加密:

1.加密的内容

2.将要加密的内容转成字节

import hashlib

md5 = hashlib.md5()  # 加密初始化

md5.update("alex123".encode("utf-8"))

print(md5.hexdigest())

加盐(固态/动态)

import hashlib

md5 = hashlib.md5("alex".encode("utf-8"))

md5.update("alex123".encode("utf-8"))

print(md5.hexdigest())

8. collections模块

1.namedtuple生成可以使用名字来访问元素内容的tuple

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p = Point(1, 2)

print(p)

# Point(x=1, y=2)

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

from collections import deque

q = deque(['a', 'b', 'c'])

q.append('x')

q.appendleft('y')

print(q)

# deque(['y', 'a', 'b', 'c', 'x'])

队列: 先进先出

栈: 先进后出

3.OrderedDict: 有序字典

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])

print(od)

# OrderedDict([('a', 1), ('b', 2), ('c', 3)])

4.defaultdict: 带有默认值的字典

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:

    if value>66:

        my_dict['k1'].append(value)

    else:

        my_dict['k2'].append(value)

5.Counter: 计数器，主要用来计数

from collections import Counter

c = Counter('abcdeabc')

print(c)

# Counter({'a': 2, 'b': 2, 'c': 2, 'd': 1})

9. re模块 (正则表达式)

# \w 匹配字母（包含中文）或数字或下划线

import re

name = "宝元-meet_123 "

print(re.findall("\w",name))

# ['宝', '元', 'm', 'e', 'e', 't', '_', '1', '2', '3']

# \W 匹配非字母（包含中文）或数字或下划线

# \s 匹配任意的空白符

# \S 匹配任意非空白符

# \d 匹配数字

# \D 匹配非数字

# \A 从字符串开头匹配

# \Z 匹配字符串的结束，如果是换行，只匹配到换行前的结果

# \n 匹配一个换行符

# \t 匹配一个制表符

# ^ 匹配字符串的开始

# $ 匹配字符串的结尾

# . 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

import re

name = "宝元-meet_123\t \n"

print(re.findall(".",name))

# ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '\t', ' ']

print(re.findall(".",name,re.DOTALL))

# ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '\t', '\n']

# [...] 匹配字符组中的字符

print(re.findall("[a-z]",s))

# [^...] 匹配除了字符组中的字符的所有字符

# * 匹配0个或者多个左边的字符。

# + 匹配一个或者多个左边的字符。

# ？ 匹配0个或者1个左边的字符，非贪婪方式。

# {n} 精准匹配n个前面的表达式。

# {n,m} 匹配n到m次由前面的正则表达式定义的片段，贪婪方式

# a|b 匹配a或者b

# () 匹配括号内的表达式，也表示一个组

import re

print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))

# ['alex', ' wusir', ' 日天']

print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>')

# ['http://www.baidu.com']

1.findall 全部找到,返回一个列表

2.search 从字符串中任意位置进行匹配查找到一个就停止了,返回的是一个对象. 获取匹配的内容必须使用.group()进行获取

3.match 只在字符串开始位置进行匹配

4.split 分隔可按照任意分隔符进行分隔

5.sub 替换

6.compile 定义匹配规则

obj = re.compile("\w")

print(obj.findall("meet_宝元_常鑫垃圾"))

7.finditer 返回一个迭代器

import re

g = re.finditer('al',"alex_alsb,al22,aladf")

print(next(g).group())

print([i.group() for i in g])

# al

# ['al','al','al']

巴特西