Python_模块

Posted 2020-12-26 liutianyuan

模块

模块的概念：

　　为了编写可维护的代码，我们将函数分组飞别放在不同的文件里，这样每个文件的代码相对较少。

　　在Python中一个.py文件就是一个模块。

　　使用模块可以大大提升代码的可维护性，其次编写代码不必从零开始。当一个模块编写完之后就可以被其他地方调用

模块分为三种：

　　　　　　1、python标准库

　　　　　　2、第三方模块

　　　　　　3、自定义模块

模块的导入方法：

import语句

import  modular #直接在import 后面加上调用模块的名字

　　当我们使用import语句时，Python解释器会通过自己的搜索路径来找到对应的文件， 路径就存在sys.path里面。

[‘‘, ‘/usr/lib/python3.4‘, ‘/usr/lib/python3.4/plat-x86_64-linux-gnu‘,
‘/usr/lib/python3.4/lib-dynload‘, ‘/usr/local/lib/python3.4/dist-packages‘, ‘/usr/lib/python3/dist-packages‘]　

2、form .... import  语句

from modular import name1 

　　这个声明不会把整个modular模块导入到当前的命名空间中，只会将它里面的name1单个引入到执行这个声明的模块的全局符号表。

3、form .... import *

from modular import *

　　这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

4、运行本质

1.import test

2.form test import add

　　无论1还是2，首先通过sys.path找到test.py,然后执行test脚本（全部执行），区别是1会将test这个变量名加载到名字空间，而2只会将add这个变量名加载进来。

 

 

time 模块（* * * *）

在Python中通常有三种方式来表现时间：

　　1、时间戳

　　2、格式化的时间字符串

　　3、元组

时间戳 : 通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

import time
print(time.time) #显示当前时间戳

------------------结构化时间

print(time.localtime()) #当前时间 以格式化的形式显示
#time.struct_time(tm_year=2018, tm_mon=6, tm_mday=9, tm_hour=18, tm_min=25, tm_sec=5, tm_wday=5, tm_yday=160, tm_isdst=0)
t=time.localtime()
print(t.tm_year) #2018年
print(t.tm_wday)#周六 因为是从0开始计算 所以加1为一周的第几天
#-----#结构化时间---UTC
print(time.gmtime()) #与time.localtime()一样  只是时区不同

 

#将结构化时间转换成时间戳
print(time.mktime(time.localtime()))

#------将结构化时间转成字符串时间strftime
# %Y 年  %m月  %d日  %X其他时间
print(time.strftime("%Y---%m-%d %X",time.localtime()))

#------将字符串时间转成结构化时间strptime
print(time.strptime("2016:12:24:17:50:36","%Y:%m:%d:%X"))

 

import time
 
# 1 time() :返回当前时间的时间戳
time.time() 
 
#----------------------------------------------------------
 
# 2 localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
time.localtime() #time.struct_time(tm_year=2018, tm_mon=*, tm_mday=**, tm_hour=**,
# tm_min=**, tm_sec=**, tm_wday=**, tm_yday=**, tm_isdst=*)
time.localtime(1473525444.037215)
 
#----------------------------------------------------------
 
# 3 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。
 
#----------------------------------------------------------
 
# 4 mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))#1473525749.0
 
#----------------------------------------------------------
 
# 5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：‘Sun Jun 20 23:21:05 1993‘。
# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())#Sun Sep 11 00:43:43 2016
 
#----------------------------------------------------------
 
# 6 ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016
 
print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016
 
# 7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和
# time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个
# 元素越界，ValueError的错误将会被抛出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))
# 8 time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime(‘2011-05-05 16:37:06‘, ‘%Y-%m-%d %X‘))
 
#time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
#  tm_wday=3, tm_yday=125, tm_isdst=-1)
 
#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。
 
 
# 9 sleep(secs)
# 线程推迟指定的时间运行，单位为秒。
 
# 10 clock()
# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。
# 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行
# 时间，即两次时间差。

time模块方法

 

random模块（ * * ）

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和2
 
print(random.choice([1,‘23‘,[4,5]]))#在可迭代对象中随机取值 可以用来设置概率
 
print(random.sample([1,‘23‘,[4,5]],2))#随机取多个值
 
print(random.uniform(1,3))#任意返回的浮点数

item = [1,5,4,8,3,45]
random.shuffle(item)#随机打乱顺序
print(item)

def v_code():
    ret=""
    for i in range(5):
        num=random.randint(0,9)
        alf=chr(random.randint(65,122))
        s=str(random.choice([num,alf]))
        ret+=s
    return ret
print(v_code())

验证码

 os模块（* * * *）

在自动化测试中，经常需要查找操作文件，经常要对大量文件和大量路径进行操作，这就依赖于os模块操作。

 

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: (‘.‘)
os.pardir  获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘)    可生成多层递归目录
os.removedirs(‘dirname1‘)    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)    生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘)    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat(‘path/filename‘)  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果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所指向的文件或者目录的最后修改时间

os模块

 

sys模块（* * *）

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

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

进度条：

import sys,time 
for i in range(10):
    sys.stdout.write(‘#‘)  
    time.sleep(1)
    sys.stdout.flush()

 json&pickle (* * * *)

json&pickle是用来进行序列化的模块

 

　  json ：  用于字符串和Python数据类型之间的转换

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

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化。

 

json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

json 模块提供了4个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load

#----------------------------序列化
import json
 
dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
print(type(dic))#<class ‘dict‘>
 
j=json.dumps(dic)
print(type(j))#<class ‘str‘>
 
 
f=open(‘序列化对象‘,‘w‘)
f.write(j)  #-------------------等价于json.dump(dic,f)
f.close()
#-----------------------------反序列化<br>
import json
f=open(‘序列化对象‘)
data=json.loads(f.read())#  等价于data=json.load(f)

json 会将对象里如果有引号的话就将所有的单引号变为双引号然后将数据变为字符串

import json
#dct="{‘1‘:111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{‘one‘: 1}

dct=‘{"1":"111"}‘
print(json.loads(dct))

#conclusion:
#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

pickle

##----------------------------序列化
import pickle
 
dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
 
print(type(dic))#<class ‘dict‘>
 
j=pickle.dumps(dic)
print(type(j))#<class ‘bytes‘>
 
 
f=open(‘序列化对象_pickle‘,‘wb‘)#注意是w是写入str,wb是写入bytes,j是‘bytes‘
f.write(j)  #-------------------等价于pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open(‘序列化对象_pickle‘,‘rb‘)
 
data=pickle.loads(f.read())#  等价于data=pickle.load(f)
 
 
print(data[‘age‘])    

 Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

 re模块（* * * * *）

就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

字符匹配：

字符匹配有两种 一种是普通字符匹配，另外一种是元字符匹配。

1、普通字符匹配

#普通字符匹配
import re
re.findall(‘普通字符‘,‘这是普通字符匹配‘)
# [‘普通字符‘] 运行结果

2、元字符匹配

#元字符：. ^ $ * + ? { } [ ] | ( ) import re
 
ret=re.findall(‘a..in‘,‘helloalvin‘)  #  .  表示任何单个字符
print(ret)#[‘alvin‘]
 
 
ret=re.findall(‘^a...n‘,‘alvinhelloawwwn‘)#匹配字符串开头
print(ret)#[‘alvin‘]
 
 
ret=re.findall(‘a...n$‘,‘alvinhelloawwwn‘)#匹配字符串结尾
print(ret)#[‘awwwn‘]
 
 
ret=re.findall(‘abc*‘,‘abcccc‘)#贪婪匹配[0,+oo]  前一个字符0次或无限次扩展
print(ret)#[‘abcccc‘]
 
ret=re.findall(‘abc+‘,‘abccc‘)#贪婪匹配[1,+oo] 前一个字符1次或无限次扩展
print(ret)#[‘abccc‘]
 
ret=re.findall(‘abc?‘,‘abccc‘)#[0,1] 前一个字符0次或1次扩展
print(ret)#[‘abc‘]
 
 
ret=re.findall(‘abc{1,4}‘,‘abccc‘)#对于前一个字符重复次数在为m到n次
print(ret)#[‘abccc‘] 贪婪匹配 { } [ ] | ( ) 

　　注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

ret=re.findall(‘abc*?‘,‘abcccccc‘)#*号是0到无穷 惰性匹配下0次就可以匹配出结果
print(ret)#[‘ab‘]

元字符之字符集［］：

需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配

字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。
所有特殊字符在字符集中都失去其原有的特殊含义。用反斜杠转义恢复特殊字符的特殊含义。

#--------------------------------------------字符集[]

import re

ret=re.findall(‘a[bc]d‘,‘acd‘)
print(ret)#[‘acd‘]
 
ret=re.findall(‘[a-z]‘,‘acd‘) # 从a到z匹配出对应的字符
print(ret)#[‘a‘, ‘c‘, ‘d‘]
 
ret=re.findall(‘[.*+]‘,‘a.cd+‘) #在[]中.*+没有意义，当做普通字符进行匹配
print(ret)#[‘.‘, ‘+‘]
 
#在字符集里有功能的符号: - ^  
ret=re.findall(‘[1-9]‘,‘45dha3‘)  #1到9
print(ret)#[‘4‘, ‘5‘, ‘3‘]
 
ret=re.findall(‘[^ab]‘,‘45bdha3‘) #^表示取反值 不要ab
print(ret)#[‘4‘, ‘5‘, ‘d‘, ‘h‘, ‘3‘]
 
ret=re.findall(‘[d]‘,‘45bdha3‘)#是转义符 d  匹配任何十进制数；它相当于类 [0-9]。
print(ret)#[‘4‘, ‘5‘, ‘3‘]

　元字符中的转义符  

反斜杠后边跟元字符去除特殊功能,比如.
反斜杠后边跟普通字符实现特殊功能,比如d

d  匹配任何十进制数；它相当于类 [0-9]。
D 匹配任何非数字字符；它相当于类 [^0-9]。
s  匹配任何空白字符；它相当于类 [ fv]。
S 匹配任何非空白字符；它相当于类 [^ fv]。
w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
  匹配一个特殊字符边界，比如空格 ，&，＃等

 

logging模块（* * * *）

logging,是用来纪录日志的模块，可以自动帮我们纪录程序运行中出现的错误，出了问题可以方便我们后来去日志中查找原因，在实际开发中非常好用，下面来简单的看一下用法。

import logging
#---------------------------------- logging.basicConfig
logging.basicConfig(
    level=logging.DEBUG,    #控制logging等级 注意等级要大写 否则报错
    filename="logger.log",    # 将logging显示的内容保存到一个文件里 注意这个文件默认是追加模式
    filemode="w",           #将文件模式变为写模式
    format="[%(lineno)s]  %(asctime)s %(filename)s  %(message)s" #更改文件的格式
)
#logging的五个等级 默认等级为logging.warning
logging.debug(‘hello‘)
logging.info(‘hello‘)
logging.warning(‘warning message‘)
logging.error(‘error message‘)
logging.critical(‘critical message‘)

　　日志格式都有哪些内容：

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

除了logging 还有一种logger的方法可以进行即在屏幕上输出，又可以在文件里输出 同时也可以写到多个文件

#--------------------------------------------logger
logger = logging.getLogger() #括号内没有参数默认为root用户
#---------------------------logger的设置
fh = logging.FileHandler("logger_test")# 在文件内输出
ch = logging.StreamHandler()    #在屏幕上输出

fm = logging.Formatter("%(asctime)s %(name)s %(message)s") #输出格式

fh.setFormatter(fm) #将输出格式设置为fm的格式
ch.setFormatter(fm)#将输出格式设置为fm的格式
logger.setLevel("DEBUG") #设置默认等级

logger.addHandler(fh)
logger.addHandler(ch)

# -----------------------------------
logger.debug("debug")
logger.info("info")
logger.warning("warning")
logger.error("error")
logger.critical("critical")

 

hashlib模块

 hashlib是一个加密模块，提供了常见的加密算法，比如MD5，SHA1，SHA256等，它通过一个函数，把任意长度的数据转换为一个长度固定的数据串，常用来保存密码等，比如将用户的密码用MD5加密后，保存到数据库，用户登录时先计算用户输入的明文口令的MD5，然后和数据库存储的MD5对比，如果一致，说明密码输入正确，如果不一致，密码肯定错误。

import hashlib

obj = hashlib.md5()
obj.update("hello".encode("utf8"))  # 假设密码是hello 传入函数

print(obj.hexdigest()) #5d41402abc4b2a76b9719d911017c592




obj = hashlib.md5("passwd".encode("utf8")) #对原始密码加一个复杂字符串来提高安全性，俗称“加盐”：
obj.update("hello".encode("utf8")) 

print(obj.hexdigest()) #88d2208c2b69afffa484ae7b78e9efb1