python3 常用的模块学习 （第五周）

前言：

为什么要学习python3?

原因：

1、学习一门语言能力

2、通过该语言能力完成测试自动化以及独立完成自测框架知识

那么我要做什么呢？

1、每天花十个小时完成python3的学习

要在什么地方做呢？

广州

那到底要怎么做呢？

完成基本的python3的基础知识，从而再学习测试框架

总结：

1、基本了了解几个模块

tim模块、datetime模块、random模块、os模块、sys模块、shutil模块、json模块和pickle模块、re模块(正则表达式)

遗留问题：

1、clock() Python 3.8 已移除 clock() 方法 可以使用 time.perf_counter() 或 time.process_time() 方法替代

2、tzset() 少用

3、os.path.join(path1[,path2])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 #遗留问题

4、print(re.split('A*','hello world'))  # 对于一个找不到匹配的字符串而言，split 不会对其作出分割 结果不是:['hello world']  遗留问题

 

常用模块：

time 模块

定义：

时间戳

格式化的字符串

结构化的时间  元组(strut_time) 由9个元素组成 年月日时分秒 每周第几天，每年第几天，时区

import time
# time.time() 获取当地时间戳，返回用秒数来表示时间的浮点数
print("获取当地时间戳，返回用秒数来表示时间的浮点数:",time.time())

#time.localtime() 获取当地时间-->结构化时间
x = time.localtime() #可以传时间戳  1234544333  换算   1234544333/3600/24/365  + 1970年
print("获取当地时间",x)
print("指定返回参数",x.tm_year)

#time.strptime() 根据指定格式，获取结构化时间
print("根据指定格式，获取结构化时间:",time.strftime("%y-%m-%d %H:%M:%S",time.localtime(1611979105.0))) #用time.strftime模块进行格式化输出 结果：21-01-30 11:58:25
print("按照格式，已元组方式传值",time.strptime("2020-07-01", "%Y{y}%m{y}%d".format(y="-")))

#time.strftime() 根据结构时间，获取指定格式时间
t2 = time.localtime()
print(t2)
t3 = time.strftime("%Y{y}%m{y}%d".format(y="-"),t2)
print("根据结构时间，获取指定格式时间",t3)

# time.mktime() 根据结构时间，获取时间戳
t2 = time.localtime()
print(t2)
t4 = time.mktime(t2) #元组返回值获取时间戳
print(t4)

# time.sleep() 推迟执行的秒数
time.sleep(3) #推迟3秒执行

#time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time,其默认值为time.time()
print("其默认值为time.time()",time.gmtime())


#time.asctime()  函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串
print(time.asctime()) #默认获取当地时间
print(time.asctime(time.localtime(1234544333)))  #支持函数 gmtime() 或 localtime() 返回的时间值
print(time.asctime(time.gmtime()))  #支持函数 gmtime() 或 localtime() 返回的时间值
print(time.ctime(time.time()))  #函数接受时间戳

datetime模块

定义：时间加减

import datetime
print(datetime.date(2018, 8, 23))  #表示日期的类。常用的属性有year, month, day
print(datetime.time(18,55,35,2000))  #表示时间的类。常用的属性有hour, minute, second, microsecond(微秒) ## 默认值为00
print(datetime.datetime(2018, 8, 23, 18, 59, 55)) #日期时间
#datetime.now()  返回当前系统时间
print(datetime.datetime.now())
#datetime.timedelta() 时间间隔
print(datetime.timedelta(hours=5))
#在当前系统时间+5天
print(datetime.datetime.now() + datetime.timedelta(days=5))
#时间间隔
# 默认值：
# days=0, # 天
# seconds=0,  # 秒
# microseconds=0, # 微秒
# milliseconds=0, # 毫秒
# minutes=0,  # 分钟
# hours=0,  # 小时
# weeks=0 # 周

random模块

import random
#随机整数
print(random.randint(1,3)) #随机生成一个整数，范围是1、2、3
#随机取0-100间的偶数
print(random.randrange(1,101,2)) #2代表间隔一个数
#随机浮点数：
print(random.random())
print(random.uniform(1,10)) #1-10以内的浮点数
#随机字符
print(random.choice("hello")) #字符串随机找一个字符
#随机选取列表中的一个字符串值
print(random.choice(["apple",2,3])) #随机在列表取一个值
#多个字符中选取特定数量的字符
print(random.sample('hello',2)) #随机取两个字符值
#shuffle() 方法将序列的所有元素随机排序
items = [1,2,3,4,5,6,7]
print(items)
random.shuffle(items)
print(items)

#random生成验证码案例
checkcode = ""

for i in range(4):
    current = random.randint(0,4)
    if current == i:
        tmp = chr(random.randint(65,90))
    else:
        tmp = random.randint(0,9)
    checkcode += str(tmp)
print(checkcode)

os模块

import os
#获取当前工作目录
print("获取当前工作目录",os.getcwd())

# 切换当前路径
os.chdir("C:\\Users")
print("获取当前工作目录",os.getcwd())
os.chdir(r"C:\users")   #推荐
print("获取当前工作目录",os.getcwd())

# os.curdir 获取当前目录
print(os.curdir)
# os.pardir  获取当前目录的父目录
print(os.pardir)

# os.makedirs(r"E:\a\b\c\d") #递归创建目录
# os.removedirs(r"E:\a\b\c\d") #若目录为空，则删除，并递归到上一级目录，若也为空则删除
# os.mkdir(r"E:\a\b\c\d") #生成单级目录；相当于shell中mkdir dirname
# os.rmdir(r"E:\a\b\c\d")  #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
#print(os.listdir(".")) #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
# os.remove("文件名") #删除一个文件
# os.rename("oldname","newname") #重命名文件/目录
# os.stat("day1.py")  #获取文件/目录信息
# os.sep #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
# os.linesep  #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
# os.pathsep  #输出用于分割文件路径的字符串
# os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
# os.system("dir")  #运行shell命令，直接显示
# os.environ  #获取系统环境变量
# os.path.abspath("day1.py") # 返回path规范化的绝对路径
# os.path.split(r"E:\a\b\c\a.txt")   #将path分割成目录和文件名二元组返回
# os.path.dirname(r"E:\a\b\c\a.txt") #返回path的目录。其实就是os.path.split(path)的第一个元素  不考虑目录是否存在
# os.path.basename(r"E:\a\b\c\a.txt") #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 不考虑目录是否存在
# os.path.exists(r"E:\a\b\c\a.txt")  #如果path存在，返回True；如果path不存在，返回False
# os.path.isabs(r"E:\a) # 如果path是绝对路径，返回True
# os.path.isfile("path") #如果path是一个存在的文件，返回True。否则返回False
# os.path.isdir("path")  #如果path是一个存在的目录，则返回True。否则返回False
# os.path.join(path1[,path2])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 #遗留问题
# os.path.getatime("path")  #返回path所指向的文件或者目录的最后存取时间
# os.path.getmtime("path")  #返回path所指向的文件或者目录的最后修改时间

sys模块

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

shutil模块  

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

import  shutil
#shutil.copyfileobj()将文件内容拷贝到另一个文件中，可以部分内容shutil.copyfileobj(fsrc, fdst[, length])
# open("f1",encoding="utf-8")
# open("f2",encoding="utf-8")
#shutil.copyfileobj(f1, f2)


#shutil.copyfile() 拷贝文件
#shutil.copyfile("笔记2","新笔记3")

#shutil.copymode()  仅拷贝权限。内容、组、用户均不变

#shutil.copystat(src, dst) 拷贝状态的信息，包括：mode bits, atime, mtime, flags 没有copy新文件

#shutil.copy(src, dst)  拷贝文件和权限

#shutil.copy2(src, dst)  拷贝文件和状态信息


#递归的去拷贝文件
# shutil.copytree(src, dst)

#递归的去删除文件
#shutil.rmtree("dst")

#递归的去移动文件
#shutil.move(src, dst)


#shutil.make_archive()创建压缩包并返回保存在当前文件路径，例如：zip、tar
#shutil.make_archive("打包文件名","zip","E:\pythonProject")


#shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的
#zipfile 压缩解压
import zipfile
#
# # 压缩
# z = zipfile.ZipFile('laxi.zip', 'w')
# z.write('a.log')
# z.write('data.data')
# z.close()
#
# # 解压
# z = zipfile.ZipFile('laxi.zip', 'r')
# z.extractall()
# z.close()

# tarfile 压缩解压
# import tarfile
#
# # 压缩
# tar = tarfile.open('your.tar','w')
# tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip')
# tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip')
# tar.close()
#
# # 解压
# tar = tarfile.open('your.tar','r')
# tar.extractall()  # 可设置解压地址
# tar.close()

 

json模块 和 pickle 模块 用于序列化的两个模块

json模块

定义：

1、用于字符串 和 python数据类型间进行转换,

2、Json模块提供了四个功能：dumps、dump、loads、load

import json
# 1、dumps() 用于将dict类型的数据转成str，因为如果直接将dict类型的数据写入json文件中会发生报错，因此在将数据写入时需要用到该函数。
data_str = {"name": "小明", "age": 18,"sex":"男"}
test1 = json.dumps(data_str)
print(data_str,type(data_str))
print(test1,type(test1))

#注：若在数据写入json文件时，未先进行转换，报错如下
name_emb = {'a':'1111','b':'2222','c':'3333','d':'4444'}
json_emb = json.dumps(name_emb)#不转换就报错:write() argument must be str, not dict
f = open("E:/pythonProject/30day/test210130.json","w",encoding="utf-8")
#f.write(name_emb)
f.write(json_emb +"\n")  # +"\n" 换行
f.close()

# 2、dump() 用于将dict类型的数据转成str，并写入到json文件中，用法与dumps()一致


# 3、loads() 用于将str类型的数据转成dict
name_emb = {'a': '1111', 'b': '2222', 'c': '3333', 'd': '4444'}
jsDumps = json.dumps(name_emb)
jsLoads = json.loads(jsDumps)

print(name_emb,type(name_emb))
print(jsDumps,type(jsDumps))
print(jsLoads,type(jsLoads))


# 4、load() 用于从json文件中读取数据
jsObj = json.load(open("test210130.json","r",encoding="utf-8"))
print(jsObj)
print(type(jsObj))
for key in jsObj.keys():
    print('key:%s  value:%s' %(key,jsObj.get(key)))
#结果：
# {'a': '1111', 'b': '2222', 'c': '3333', 'd': '4444'}
# <class 'dict'>
# key:a  value:1111
# key:b  value:2222
# key:c  value:3333
# key:d  value:4444

pickle 模块 

定义：

1、用于python特有的类型 和 python的数据类型间进行转换

2、提供了四个功能：dumps、dump、loads、load

3、pickle可以存储什么类型的数据

a.所有python支持的原生类型：布尔值，整数，浮点数，复数，字符串，字节，None。

b.由任何原生类型组成的列表，元组，字典和集合。

c.函数，类，类的实例

import pickle

# 1、dumps() 将数据通过特殊的形式转换为只有python语言认识的字符串
data = ['aa', 'bb', 'cc']
p_str = pickle.dumps(data)
print(data,type(data))
print(p_str,type(p_str))

#2、dump() 将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
# 含义：pickle.dump（对象，文件，[使用协议]）
# 将要持久化的数据“对象”，保存到“文件”中，使用有3种协议，索引0为ASCII，1为旧式二进制，2为新式二进制协议，不同之处在于2要更高效一些。
# 默认dump方法使用0做协议
data = {'a': '1111', 'b': '2222', 'c': '3333', 'd': '4444'}
f1 = open("E:/pythonProject/30day/tmp.pk","wb") #wb的打开方式
pickle.dump(data,f1)
f1.close()

f2 = open("E:/pythonProject/30day/tmp.pk","rb") #用rb打开文件
b = pickle.load(f2) #load() 从“文件”中读取字符串，将他们反序列化转换为python的数据对象，可以像操作数据类型的这些方法来操作它们
print(b,type(b))


#load()
# 含义：pickle.load(文件)，将file中的对象序列化读出。
# 从“文件”中读取字符串，将他们反序列化转换为python的数据对象，可以像操作数据类型的这些方法来操作它们；
# 使用load()将数据从文件中序列化读出
fr = open("E:/pythonProject/30day/tmp.pk",'rb')
data1 = pickle.load(fr)
print('\n'+"反序列化1：%r" % data1)

data2 = pickle.load(fr)
print("反序列化2：%r" %data2+'\n')
fr.close()


#loads() 函数的功能：从string中读出序列化前的obj对象
data = ['aa', 'bb', 'cc']
loads_str = pickle.dumps(data)
print(loads_str,type(loads_str))
print(pickle.loads(loads_str),type(pickle.loads(loads_str)))

 

xml处理模块

# xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，

# 但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，

# 大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml

 

hmac 模块

定义：

1、它内部对我们创建 key 和 内容 再进行处理然后再加密

2、提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

#需要注意传入的key和message都是bytes类型，str类型需要首先编码为bytes。 digestmod  = "加密算法"
#encode 字符串转字节
#decode 字节转字符串
# h = hmac.new(b'12345', '宝塔镇河妖'.encode(encoding="utf-8"),digestmod = "MD5")
# print(h.hexdigest())

 

#re模块 （提供 Perl 风格的正则表达式模式）

定义：

1、 正则表达式：是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配

2、最常用的匹配语法

a、 re.match 从头开始匹配，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。

b、 re.search 匹配包含

c、 re.findall 把所有匹配到的字符放到以列表中的元素返回

d、 re.splitall 以匹配到的字符当做列表分隔符

e、 re.sub      匹配字符并替换

'.'
# 默认匹配除\n之外的任意一个字符，若指定flag
# DOTALL, 则匹配任意字符，包括换行


'^'
匹配字符开头，若指定flags
MULTILINE, 这种也可以匹配上(r"^a", "\nabc\neee", flags=re.MULTILINE)
re.match("^yao","yao123445")
re.search("^yao","12344yao123YAO445")
re.search("[A-Z][a-zA-Z]+O", "12344yaO123YAO445") #匹配纯字母的语法


'$'
匹配字符结尾，或e.search("foo$", "bfoo\nsdfsf", flags=re.MULTILINE).group()也可以

'*'
匹配 * 号前的字符0次或多次，re.findall("ab*", "cabb3abcbbac") #结果为['abb', 'ab', 'a']

'+'
匹配前一个字符1次或多次，re.findall("ab+", "ab+cd+abb+bba") #结果['ab', 'abb']

'?'
匹配前一个字符1次或0次
re.match("aal?","ajkjkjaaa") #结果为空
re.search("aal?","aajkjkjaaa") #匹配到后面的，因为aaa？ = aa 或 aal

'{m}'
匹配前一个字符m次
re.match("[0-9]{1,3}","a1j33kj345aaa")  #结果为空
re.search("[0-9]{3}","a1j33kj3456aaa")  #结果 345
re.findall("[0-9]{1,3}","a1j33kj345aaa") #结果1、33、345


'{n,m}' 匹配前一个字符n到m次，
re.findall("ab{1,3}","abb abc abbcbbb") #结果'abb', 'ab', 'abb']


'|'匹配 | 左或 | 右的字符
re.search("abc|ABC", "ABCBabcCD").group() #结果'ABC'
re.findall("abc|ABC", "ABCBabcCD")  #结果'ABC'和 'abc' 没有group()方法

'(...)'分组匹配，
re.search("(abc){2}a(123|456)c", "abcabca456c").group()  #结果 abcabca456c
re.search("(abc){2}(\|\|=){2}", "eeeeeabcabc||=||=||=").group() #结果 abcabc||=||=


'(?P<name>...)' 分组匹配
re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict()
#结果{'province': '3714', 'city': '81', 'birthday': '1993'}
re.split("[0-9]+", "abc1ef23gh567yy") #数字进行分割
#结果 ['abc', 'ef', 'gh', 'yy']
re.sub("[0-9]+","##","abc1ef23ghi567",count=2)
#结果：abc##ef##ghi567


#字符类
# [Pp]ython    匹配 "Python" 或 "python"
# rub[ye]    匹配 "ruby" 或 "rube"
# [aeiou]    匹配中括号内的任意一个字母
# [0-9]    匹配任何数字。类似于 [0123456789]
# [a-z]    匹配任何小写字母
# [A-Z]    匹配任何大写字母
# [a-zA-Z0-9]    匹配任何字母及数字
# [^aeiou]    除了aeiou字母以外的所有字符
# [^0-9]    匹配除了数字外的字符


#特殊字符类
# .    匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式
# \d    匹配一个数字字符。等价于 [0-9]
# \D    匹配一个非数字字符。等价于 [^0-9]
# \s    匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]
# \S    匹配任何非空白字符。等价于 [^ \f\n\r\t\v]
# \w    匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'
# \W    匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'

#正则表达式修饰符 - 可选标志
# re.I    使匹配对大小写不敏感
# re.L    做本地化识别（locale-aware）匹配
# re.M    多行匹配，影响 ^ 和 $
# re.S    使 . 匹配包括换行在内的所有字符
# re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
# re.X    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

 

#计算器代码（不包含括号计算）后续待优化

import re
def calculator(expression= "(1+2+3)-2*3+10/2"):
    print("1111",eval(expression))


import re
operatorDict = {
    '+': lambda x, y: float(x) + float(y),      #x,y是函数的两个变量，位于冒号的左边，冒号右边的表达式是函数的返回值。
    '-': lambda x, y: float(x) - float(y),
    '*': lambda x, y: float(x) * float(y),
    '/': lambda x, y: float(x) / float(y),
}

#print("11111",operatorDict)

def calWithOutBrackets(expression="1+2+3-2*3+10/2"):
    # 截断为数字和运算符的列表
    for i in operatorDict:
        expression = expression.replace(i, 's'+ i + 's') #+是拼接  计算符号两边加s
        #print("1111", expression)
    l = expression.split('s')
#    print("22222",l)
#calWithOutBrackets() 调试上一步
    # l2将填充为一个数字和运算的列表，数字可以带负号
    l2 = []
    i = 0
    while i < len(l):
        if l[i] == '':
            l2.append(l[i + 1] + l[i + 2])  # 带负号的数字
            i += 2
        else:
            l2.append(l[i])  # 不带负号的数字和运算符
        i += 1
    print("3333",l2)
#calWithOutBrackets()
    # 运算乘除
    i = 1
    while i < len(l2):
        if l2[i] in ['*', '/']:
            l2[i - 1:i + 2] = [operatorDict[l2[i]](l2[i - 1], l2[i + 1])]
        else:
            i += 2
#calWithOutBrackets()
    # 运算加减
    while len(l2) > 1:
        l2[0:3] = [operatorDict[l2[1]](l2[0], l2[2])]
    return print(str(l2[0]))

calWithOutBrackets()  

#以下代码可以计算括号值，但一起执行还有问题
    # expression = expression.replace(' ','')
    # check = re.search('\([^\(\)]+\)', expression)
    # while check:
    #     checkValue = check.group()
    #     print(checkValue)
    #     expression = expression.replace(checkValue, calWithOutBrackets(checkValue[1:-1]))
    #     check = re.search('\([^\(\)]*\)', expression)
    # else:
    #     return calWithOutBrackets(expression)

 

 

 

 

 

 

random模块