模块

模块

返回首页

模块就是我们的Py文件。

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.path.getsize(path) 返回path的大小
'''

os模块方法使用演练：

import os

# print(os.getcwd()) #获取当期路径
######################################
# f=open("test.txt","w")  #在当前路径下创建一个文件
# print(os.getcwd()) #获取test.txt文件路径
### chdir是修改路径
### os.chdir(r"C:UsersAdministratorPycharmProjectspy_fullstack_s4day32") # cd
# os.chdir(r"/Users/george/PycharmProjects/Python/day22模块二") # 修改路径后
# f=open("test2.txt","w")  #再创建test2.txt文件
# print(os.getcwd()) #这里获取的test2.txt路径是chdir后的路径

######################################
# os.makedirs("aaaaa/bbb/ccc") #生成多层递归目录
# os.removedirs("aaa/bbb")  #若目录为空，则删除，并递归到上一级目录，如果也为空，则删除。

######################################
###listdir显示当前文件夹的所有信息的
# print(os.listdir(r"/Users/george/PycharmProjects/Python/day22模块二"))

######################################
#####stat 获取文件/目录信息
# print(os.stat(r"/Users/george/PycharmProjects/Python/day22模块二/test2.txt"))
# '''
# os.stat_result(st_mode=33188, st_ino=4335923208, st_dev=16777222, st_nlink=1, st_uid=501, st_gid=20, st_size=0,
# st_atime=1619177783, st_mtime=1619177783, st_ctime=1619177783)
# '''

######################################

# "george"+os.sep+"image"

print(os.name)
print(os.system("ls"))

# abs=os.path.abspath("test.txt")
# print(os.path.basename(abs))
# print(os.path.dirname(abs))

s1=r"/Users/george/PycharmProjects"
s2=r"Python/day22模块二"
print(s1+os.sep+s2)

ret=os.path.join(s1,s2)   # 推荐方式
print(ret)

sys模块：调用解释器

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

import sys

print(sys.version)    #获取Python解释程序的版本信息
print(sys.platform)   #返回操作系统平台名称
print(sys.argv)       #命令行参数List，第一个元素是程序本身路径
print(sys.maxsize)
print(sys.path)       #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

# sys.exit(n)        退出程序，正常退出时exit(0)

hashlib摘要算法：

hashlib是通过一个函数，将任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

摘要算法可以辨别出数据舒是否被篡改过，因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推却很难，并且原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

常见的摘要算法MD5就是。

import hashlib

m=hashlib.md5()
# print(m)
m.update("alex".encode("utf8")) #update的意思就是给alex加密 #534b44a19bf18d20b71ecc4eb77c572f
print(m.hexdigest())  #用hexdigest查看加密的结果
m.update("alex".encode("utf8"))  #在m的基础之上，在加一个alex，这是的m是alexalex，所以两个m的值不一样
print(m.hexdigest())

n=hashlib.md5()
n.update("alex".encode("utf8"))
n.update("alex".encode("utf8"))
print(n.hexdigest())

n=hashlib.md5("salt".encode("utf8"))
n.update(b"alexalex")
print(n.hexdigest())

m=hashlib.sha1()

time时间模块：

在python中，通常有三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串。

1、时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量，看time.time()的type类型就知道它是浮点float类型。

2、元组(struct_time)：struct_time元组共有9个元素，分别为(年、月、日、时、分、秒、一年中第几周、一年中第几天、夏令时)。结构化时间是用来对时间进行操作的。

3、格式化的时间字符串(Format String)：“1996-09-07”。

##### 时间戳
time = time.time()  #---返回当前时间的时间戳
print(time)

##### 时间字符串
l = time.strftime("%Y-%m-%d %X") #当期时间
'1996-09-07 00:32:18'
print("当前时间为：",l)

##### 时间元组 
r=time.localtime()
# time.struct_time(tm_year=1996, tm_mon=9, tm_mday=7,
#                  tm_hour=0, tm_min=32, tm_sec=42, tm_wday=2,
#                  tm_yday=116, tm_isdst=0)
print(r)

random随机数模块：

random的方法有：random、randint、randrange、choice、sample、uniform、shuffle。

1、random是随机取0到1的一个浮点数。

2、randint和randrange是随机取范围内的一个整数，但是int是可以取最后一位，而range不能取最后一位。

3、choice是在choice的[]中，可以定义不同的数据类型，choice随机取。

4、sample是在列表区间内，随机取两个数，第二个参数是定义随机取几个。

5、uniform是在区间范围内随机取一个大于头且小于尾的浮点数。

6、shuffe是将定义的列表数据随机打乱次序。

import random

print(random.random()) #拿到一个0到1的浮点型数字
print(random.randint(1,4))  #[1,4] 在1到4之间随机取一个整数
print(random.randrange(1,3))  #[1,3) randint和randrange的区别是int可以取到列表范围最后一位，而range不行。
print(random.choice([11,"22",[222],26,3,4])) #在choice的[]中，可以定义不同的数据类型，choice随机取
print(random.sample([11,26,3,4],2))  #在列表区间内，随机取两个数，第二个参数是定义随机取几个
print(random.uniform(1,3))  #在区间范围内随机取一个大于头且小于尾的浮点数

item=[1,23,33]
random.shuffle(item)  #将item的列表数据随机打乱次序
print(item)

logging模块：

在默认情况下，Python的logging模块将日志打印到了标准输出中，且只显示大于等于Warning级别的日志。这说明默认的日志级别设置为Warning(日志级别等级Critical>Error>Warning>Info>Debug)，默认的日志格式为日志级别：Logger名称：用户输出消息。

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

logging.debug('debug message')
num=1000
logging.info('cost %s'%num)
logging.warning('warning messagegfdsgsdfg')
logging.error('error message')
logging.critical('critical message')

日志的配置：通过congfig函数和logger对象。

配置参数：

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

congfig函数：

import logging

### congfig函数
### level是等级，通过level定义logging的等级。
### format是格式，按照自己定义的格式显示输出，asctime是时间，lineno是调用日志输出函数的语句所在的代码行，messages是用户输入的信息。
### datefmt是指定日期时间格式。
### filename是用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
### filemode是文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s [%(lineno)s] %(message)s",
                    datefmt="%Y-%m-%d %H:%M:%S",
                    filename="logger2",
                    filemode="a"
                    )

logging.debug('debug message')
num=1000
logging.info('cost %s'%num)
logging.warning('warning messagegfdsgsdfg') 
logging.error('error message')
logging.critical('critical message')

logger对象：建议使用logger对象。

######## logger对象
def get_logger():
    logger=logging.getLogger()   #拿到logger对象
    lfh=logging.FileHandler("logger.log")  # 文件流向 创建一个handler，用于写入日志文件
    lsh=logging.StreamHandler()   # 屏幕流向 再创建一个handler，用于输出到控制台
    logger.setLevel(logging.DEBUG)  #设定输出等级
    fm=logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    logger.addHandler(lfh)   #logger对象可以添加多个lfh和lsh对象
    logger.addHandler(lsh)
    lfh.setFormatter(fm)   #设置lfh的日志格式，格式样子是fm定义的
    lsh.setFormatter(fm)
    return logger

Logger=get_logger()
Logger.debug('logger debug message')
Logger.info('logger info message')
Logger.warning('logger warning message')
Logger.error('logger error message')
Logger.critical('logger critical message')

json序列化模块：

对象(变量)从内存中变成可存储或传输的过程称之为序列化 。

eval的使用：

d={"河北":["廊坊","保定"],"湖南":["长沙","韶山"]}
s=str(d)  #将d数据转换成字符串
print(s,type(s))

with open("data","w") as f:
    f.write(s)  #将转换后的d保存到文件data中。

with open("data") as f2:
    s2=f2.read()  #读data文件中的数据
    d2=eval(s2)   #将读到的字符串数据转换成字典数据

print(d2["河北"]) #取字段key河北，得到河北的下属属地'{"河北":["廊坊","保定"],"湖南":["长沙","韶山"]}'
print(d2["湖南"])

json序列化：只有两个方法，一个序列化方法，一个反序列化方法。

序列化是将数据转换成对应的字符串形式的数据。

反序列化是将对应的字符串数据转换成对应的数据类型。

json.dumps和json.loads：

import json
# d1={"河北":["廊坊","保定"],"湖南":["长沙","韶山"]}
d2={'name':"george"}
########### dumps 序列化操作
# s1=json.dumps(d1)  # 将字典d转为json字符串---序列化 ，拿到的是unicode的数据，这时的d是一个字符串，可以被写进文件里。
s2=json.dumps(d2)  # 将字典d转为json字符串---序列化 ，拿到的是unicode的数据，这时的d是一个字符串，可以被写进文件里。
# print(s1,type(s1))
print(s2,type(s2))
### 写入文件操作
f_write=open("new",'w')
# f_write.write(s1)  #这时的s就被写进了new文件。
f_write.write(s2)  #这时的s就被写进了new文件。
f_write.close()
########### loads 反序列化操作
### 读文件操作
f_read = open("new")
data1 = f_read.read()
data2 = json.loads(data1)
print(data2["name"])

import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"george"}
json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)
print(json_str1)   #'10'
print(json_str2)   #'"hello"'
print(json_str3)   #'[1, 4, 6]'
print(json_str4)   #'[3, 5, 7]'
print(json_str5)   #'{"name": "yuan"}'

Pickle模块：只能在Python之间进行数据交换。

import pickle
import datetime

t=datetime.datetime.now()  #返回的是当期时间
# print(t)
d1={"data":t}
s1=pickle.dumps(d1)
# print(d1)
#
# json.dump(d,open("new4","w")) #这样的d是不能被json序列化的
#
d2={"name":"alvin"}
s2=pickle.dumps(d2)  #pickle处理出来的是字节数据
# print(s)
# print(type(s))
#
f=open('new5',"wb")
f.write(s2)   #pickle处理的数据在写入文本后，是不能查看的，也就是说pickle是无法读的。
f.write(s1)   #pickle处理的数据在写入文本后，是不能查看的，也就是说pickle是无法读的。
f.close()

f=open("new5","rb")
data=pickle.loads(f.read())  #pickle的读，只能用反序列化读取。
print(data)
print(data["name"])

re正则模块：

　　正则：对字符串的模糊匹配

　　key：元字符（有特殊功能的字符）

　　* 表示范围是多个，+ 表示范围是[1, +00]，？表示范围是[0，1]，{ } 表示的范围是{ n，m}

　　注意：* 和+ 的区别是起始点，*可以有零，+只能从1开始到正无穷。

　　d代表数字，将数字单个表示，d+代表数字，将数字整合在一起。

print(re.findall("d+","af5324jh523hgj34gkhg53453"))

　　点 "." ：匹配除换行符 以外的任意符号

print(re.findall("p....n","hello python"))
print(re.findall("p.*n","hello python"))

　　字符集 [ ]：是匹配[ ]里的任意一个数据。

print(re.findall("a[bc]d","hasdabdjhacd"))   #结果是abd和acd

 　   * + ? {} ：重复

print(re.findall("[0-9]{4}","af5324jh523hgj34gkhg53453"))

  ^:从字符串开始位置匹配

print(re.findall("^wang","wangdashj342jhg234"))

　　$：从字符串结尾匹配

print(re.findall("wang$","wangdashj342jhg234wang"))

　　( )：分组

print(re.findall("(ad)+","addd"))
print(re.findall("(ad)+wang","adddwangfsdui"))
print(re.findall("(?:ad)+wang","adadwangfsdui"))   # “?:” 是取消优先级
print(re.findall("(?:d)+wang","adad678423wang4234fsdui"))

 　  search;只匹配第一个结果

ret=re.search("d+","djksf34asd3")
print(ret.group())

      match:只在字符串开始的位置匹配

ret=re.match("d+","423djksf34asd3")
print(ret.group())

  split 分割

s2=re.split("d+","fhd3245jskf54skf453sd",2)
print(s2)
ret3=re.split("l","hello yuan")
print(ret3)

　　sub: 替换

ret4=re.sub("d+","A","hello 234jkhh23",1)
print(ret4)
ret4=re.subn("d+","A","hello 234jkhh23")
print(ret4)

 compile: 编译方法

c=re.compile("d+")
ret5=c.findall("hello32world53") #== re.findall("d+","hello32world53")
print(ret5)

--------- END --------