Python中常用模块一

时间:2022-07-30 23:43:41

浏览目录

一、re模块

先看一道例题:

我们平时登录注册要输电话号码,输入不符合电话号码规则,就会提示你输入错误。那么怎么判断电话号码是否符合输入条件呢?我们一般都会这样写。

Python中常用模块一Python中常用模块一
while True:
    phone_number=input("please input your phone nunber:")
    if len(phone_number) ==11 and phone_number.isdigit() \
            and (phone_number.startswith("13")
            or phone_number.startswith("17")
            or phone_number.startswith("17")
            or phone_number.startswith("18")):
        print("是合法的电话号码")
    else:
        print("是不合法的电话号码")
输入号码规则

是不是感觉还行啊,容易理解,也不难。那咱们看一个更简单的。

import re
phone_number=input("please input your phone number:")
if re.match("^(13|14|17|18)[0-9]{9}$",phone_number ):
    print("是合法的电话号码")
else:
    print("是不合法的电话号码")

哇!使用re 模块方法更简单。那么我们常用的re方法还有哪些呢?

import re
ret=re.findall("a","eva egon yuan")   #返回所有满足匹配条件的结果,放在列表里
print(ret)     #结果:['a', 'a']

ret=re.search("a","eva egon yuan").group()
print(ret)  #结果:a
#函数会在字符串内查找模式匹配,直到找到第一个匹配,然后返回一个包含匹配信息的对象,
#该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None

ret=re.match("a","abc").group()
print(ret)  #结果:a
#同search,不过尽在字符串开始处匹配

ret=re.split("[ab]","abcd")
print(ret)     #结果:['', '', 'cd']
#先按"a"分割得到""和"bcd",在对""和"bcd"分别按"b"分割

ret=re.sub("\d","H","eva3egon4yuan4",1)
print(ret)    #结果:evaHegon4yuan4
#将数字替换为"H",参数1表示只替换1个

ret=re.subn("\d","H","eva3egon4yuan4")
print(ret)   #结果:('evaHegonHyuanH', 3)
#将数字替换为"H",返回元组(替换的结果,替换了多少次)

obj=re.compile("\d{3}")    #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字
ret=obj.search("abc123eeee")  #正则表达式对象调用search,参数为待匹配的字符串
print(ret.group())  #结果:123

import  re
ret=re.finditer("\d","ds3sy4784a")
print(ret)          #<callable_iterator object at 0x000000E6BE57F5F8>
print(next(ret).group())  #3
print(next(ret).group())   #4
print([i.group() for i in ret])  #结果:['7', '8', '4']  #查看剩余的左右结果

注意:

1、findall的优先级查询

Python中常用模块一Python中常用模块一
import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']
优先级

2、split的优先级查询 

Python中常用模块一Python中常用模块一
import re
ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 : ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 : ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上()之后所切出的结果是不同的,
#没有()的没有保留所匹配的项,但是有()的却能够保留了匹配的项,
#这个在某些需要保留匹配部分的使用过程是非常重要的。
优先级

二、 collections 模块

 python中的扩展数据类型

在内置数据类型(dict、list、set、tuple)的基础上,collections模块还提供了几个额外的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple

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

Python中常用模块一Python中常用模块一
from collections import namedtuple
Point=namedtuple("Point",["x","y"])
p=Point(1,2)
print(p)    #结果:Point(x=1, y=2)
用坐标表示一个点
Python中常用模块一Python中常用模块一
from collections import namedtuple
Circle=namedtuple("circle",["x","y","r"])
d=Circle(2,3,2)
print(d)    #circle(x=2, y=3, r=2)
用坐标和半径表示一个圆

2.deque

双端队列,可以快速的从另外一侧追加和推出对象

使用list存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为list是线性存储,数据量大的时候,插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表,适合用于队列和栈:

Python中常用模块一Python中常用模块一
from collections import deque
q=deque(["a","b","c"])
q.append("x")
q.appendleft("y")
print(q)    #结果:deque(['y', 'a', 'b', 'c', 'x'])
先后输出

deque除了实现list的append()pop()外,还支持appendleft()popleft(),这样就可以非常高效地往头部添加或删除元素。

Python中常用模块一Python中常用模块一
from collections import deque
dq = deque([1,2])
dq.append('a')   # 从后面放数据  [1,2,'a']
dq.appendleft('b') # 从前面放数据 ['b',1,2,'a']
dq.insert(2,3)    #['b',1,3,2,'a']     #2为索引,3为数字
print(dq.pop())      # 从后面取数据
print(dq.pop())      # 从后面取数据
print(dq.popleft())  # 从前面取数据
print(dq)          #deque([1, 3])
顺序输出

3.Counter

计数器,主要用来计数

Python中常用模块一Python中常用模块一
from collections import Counter
c=Counter("abhdsfifhabaacsdfgsfa")
print(c)
#结果:Counter({'a': 5, 'f': 4, 's': 3, 'b': 2, 'd': 2, 'h': 2, 'i': 1, 'c': 1, 'g': 1})
#跟踪值出现的次数
跟踪值出现的次数

4.OrderedDict

有序字典

使用dict时,Key是无序的。如果想要保持key的顺序,就用OrderedDict。

Python中常用模块一Python中常用模块一
d=dict([("a","1"),("b",2),("c",3)])
print(d)   #结果:{'c': 3, 'b': 2, 'a': '1'}
# dict中的Key是无序的
dict中的Key是无序的
Python中常用模块一Python中常用模块一
from collections import OrderedDict
od=OrderedDict([("a","1"),("b","2"),("c","3")])
print(od)   #OrderedDict([('a', '1'), ('b', '2'), ('c', '3')])
#OrderedDict的Key是有序的
OrderedDict的Key是有序的
Python中常用模块一Python中常用模块一
od=OrderedDict()
od["z"]=1
od["y"]=2
od["x"]=3
print(od.keys()) #结果:odict_keys(['z', 'y', 'x'])
#按照插入的key的顺序返回
按照插入的key的顺序返回

5.defaultdict

带有默认值的字典

Python中常用模块一Python中常用模块一
from collections import defaultdict
dd=defaultdict(lambda:"N/A")
dd["key1"]="abc"
print(dd["key1"])  #key1存在  结果:abc
print(dd["key2"])  #key2不存在   结果:N/A
带有默认值的字典

三、time模块

常见的两种方法

1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

表示时间的三种方法

在Python中,通常有这三种方式来表示时间:时间戳、元组(struct_time)、格式化的时间字符串:

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

(2)格式化的时间字符串(Format String): ‘1995-10-04’

Python中常用模块一Python中常用模块一
%y 两位数的年份表示(00-99%Y 四位数的年份表示(000-9999%m 月份(01-12%d 月内中的一天(0-31%H 24小时制小时数(0-23%I 12小时制小时数(01-12%M 分钟数(00=59%S 秒(00-59%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
时间日期格式化符号

(3)元组(struct_time) :struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

Python中常用模块一

下面我们来看一下python中表示时间的几种格式:

Python中常用模块一Python中常用模块一
#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
          tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)
时间格式

注:时间戳是计算机能够识别的时间;时间字符串是人能够看懂的时间;元组则是用来操作时间的

几种格式之间的转化

Python中常用模块一

时间戳与结构化时间转化

Python中常用模块一Python中常用模块一
#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间,与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳 
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
时间戳与结构化时间的转化

结构化时间与字符串时间的转化

Python中常用模块一Python中常用模块一
#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传,则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
结构化时间与字符串时间的转化

Python中常用模块一

串时间的转化

Python中常用模块一Python中常用模块一
#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数,直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数,直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017' 
串时间的转化

来看一道例题:计算时间差

Python中常用模块一Python中常用模块一
import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))
计算时间差

四、random模块

random:随机数模块

random模块中常用的方法

Python中常用模块一Python中常用模块一
#导入模块
import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回,返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]
random常用方法 

例:生成随机验证码

Python中常用模块一Python中常用模块一
import random
def v_code():
    code=""
    for i in range(5):
        num=random.randint(0,9)   #生成0-9之间的整数
        alf_upper=chr(random.randint(65,90)) #生成65-90之间的整数,转化成字母
        alf_lower = chr(random.randint(97, 122))生成97-122之间的整数,转化成字母
        add=random.choice([num,alf_upper,alf_lower]) #从字母数字中随机选一个
        code="".join([code,str(add)])
    return code
print(v_code())
验证码

五、os模块

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

常用方法如下:

Python中常用模块一Python中常用模块一
'''
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下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command).read()  运行shell命令,获取执行结果
os.environ  获取系统环境变量

os.path
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常用方法

六、sys模块 

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

sys常用方法: 

Python中常用模块一Python中常用模块一
sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys常用方法 
Python中常用模块一Python中常用模块一
import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)
异常处理

七、序列化模块

序列化:将原本的字典、列表等内容转换成一个字符串的过程

序列化的目的:

 1、以某种存储形式使自定义对象持久化;

 2、将对象从一个地方传递到另一个地方。

 3、使程序更具维护性。

Json
Json模块提供了四个功能:dumps,dump,loads,load

优点:通用的序列化模块

缺点:只有很少的一部分数据类型能够通过Json转化成字符串

Python中常用模块一Python中常用模块一
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
dumps与loads
Python中常用模块一Python中常用模块一
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)
dump与load

Pickle

Pickle模块提供了四个功能:dumps,dump,loads,load

优点:所有的python中的数据类型都可以转化为字符串形式

缺点:pickle序列化的内容只有python能理解,且部分反序列化依赖python代码。

Python中常用模块一Python中常用模块一
import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)
pickle

Shelve

Shelve提供了open方法,是用key来访问的,使用起来和字典类似。

Python中常用模块一Python中常用模块一
import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)
shelve

这个模块有个限制,它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作,我们可以让shelve通过只读方式打开DB.

Python中常用模块一Python中常用模块一
import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)
shelve只读

由于shelve在默认情况下是不会记录待持久化对象的任何修改的,所以我们在shelve.open()时候需要修改默认参数,否则对象的修改不会保存。

Python中常用模块一Python中常用模块一
import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()
writeback

writeback方式有优点也有缺点。优点是减少了我们出错的概率,并且让对象的持久化对用户更加的透明了;但这种方式并不是所有的情况下都需要,首先,使用writeback以后,shelf在open()的时候会增加额外的内存消耗,并且当DB在close()的时候会将缓存中的每一个对象都写入到DB,这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了,哪些对象没有修改,因此所有的对象都会被写入。