什么是模块
常见的场景:一个模块就是一个包含了 python 定义和声明的文件,文件名就是模块名字加上. py 的后缀.但其实 import 加载的模块分为四个通用类别:
1 使用 python 编写的代码(.py 文件)
2 已被编译为共享库或 DLL 的 C 或 C++ 扩展
3 包好一组模块的包
4 使用 C 编写并链接到 python 解释器的内置模块
常用模块
下面列举 python 的常用模块
collections 模块
在内置数据类型(dict,list,set,tuple)的基础上,collections 模块还提供了几个额外的数据类型:Counter,deque,defaultdict,namedtuple 和 OrderedDict 等.
1.namedtuple: 生成可以使用名字来访问元素内容的 tuple
2.deque: 双端队列,可以快速的从另外一侧追加和推出对象
3.Counter: 计数器,主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
namedtuple
我
们知道 tuple 可以表示不变集合,例如,一个点的二维坐标就可以表示成:
但是,看到 (1, 2),很难看出这个 tuple 是用来表示一个坐标的.
>>> p = (
1
,
2
)
这时,namedtuple 就派上了用场:
类
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
>>> p.y
似的,如果要用坐标和半径表示一个圆,也可以用 namedtuple 定义:
deque 双端队列
#namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])
使用 list 存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为 list 是线性存储,数据量大的时候,插入和删除效率很低.
deque 是为了高效实现插入和删除操作的双向列表,适合用于队列和栈:
deque 除了实现 list 的 append() 和 pop() 外,还支持 appendleft() 和 popleft(),这样就可以非常高效地往头部添加或删除元素.
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])
OrderedDict 有序字典
使用 dict 时,Key 是无序的.在对 dict 做迭代时,我们无法确定 Key 的顺序.
如果要保持 Key 的顺序,可以用 OrderedDict:
注
>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
意,OrderedDict 的 Key 会按照插入的顺序排列,不是 Key 本身排序:
有如下值集合 [
>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']
defaultDict
..],将所有大于
11
,
22
,
33
,
44
,
55
,
66
,
77
,
88
,
99
,
90.
66
的值保存至字典的第一个key中,将小于
66
的值保存至第二个key的值中.
即: {'k1': 大于
66
, 'k2': 小于
66
}
原生字典解决方案default 字典解决
tip:使用 dict 时,如果引用的 Key 不存在,就会抛出 KeyError.如果希望 key 不存在时,返回一个默认值,就可以用 defaultdict
defaultdict 类的初始化函数接受一个类型作为参数,当所访问的键不存在的时候,可以实例化一个值作为默认值
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在,返回默认值
'N/A'
Counter 类的目的是用来跟踪值出现的次数.它是一个无序的容器类型,以字典的键值对形式存储,其中元素作为 key,其计数作为 value.计数值可以是任意的 Interger(包括 0 和负数).Counter 类和其他语言的 bags 或 multisets 很相似.
>>> from collections import defaultdict
>>> dd = defaultdict(list)
>>> dd
defaultdict(<type 'list'>, {})
>>> dd['foo']
[]
>>> dd
defaultdict(<type 'list'>, {'foo': []})
>>> dd['bar'].append('quux')
>>> dd
defaultdict(<type 'list'>, {'foo': [], 'bar': ['quux']})
counter
输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
c = Counter('abcdeabcdabcaba')
print c
时间模块
和时间有关系的我们就要用到时间模块.在使用模块之前,应该首先导入这个模块.
(线程)推迟指定的时间运行.单位为秒.
#常用方法
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): '1999-12-06'
%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 个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)
索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 如:2016
1 tm_mon(月) 1 - 12
2 tm_mday(日) 1 - 31
3 tm_hour(时) 0 - 23
4 tm_min(分) 0 - 59
5 tm_sec(秒) 0 - 59
6 tm_wday(weekday) 0 - 6
7 tm_yday(一年中的第几天) 1 - 366
8 tm_isdst(是否是夏令时) 默认 0
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)
几种时间格式的转换
#时间戳-->结构化时间
#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
#结构化时间-->字符串时间
#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)
计算时间差
#结构化时间 --> %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'
random 模块
生成随机验证码
>>> 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]
生成随机验证码
sys 模块
sys 模块是与 python 解释器交互的一个接口
sys.argv 命令行参数List,第一个元素是程序本身路径
sys.exit(n) 退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
异常处理和 status
序列化模块
import sys
try:
sys.exit(1)
except SystemExit as e:
print(e)
什么叫序列化——将原本的字典,列表等内容转换成一个字符串的过程就叫做序列化.
为什么要序列化
序列化的目的
1,以某种存储形式使自定义对象持久化;
2,将对象从一个地方传递到另一个地方.
3,使程序更具维护性.
json
Json 模块提供了四个功能:dumps,dump,loads,load
loads 和 dumps
load 和 dump
ensure_ascii 关键字参数
pickle
用于序列化的两个模块
json,用于字符串 和 python 数据类型间进行转换
pickle,用于 python 特有的类型 和 python 的数据类型间进行转换
pickle 模块提供了四个功能:dumps,dump(序列化,存),loads(反序列化,读),load (不仅可以序列化字典,列表... 可以把 python 中任意的数据类型序列化)
shelve 也是 python 提供给我们的序列化工具,比 pickle 用起来更简单一些.
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)
shelve
shelve 只提供给我们一个 open 方法,是用 key 来访问的,使用起来和字典类似.
这个模块有个限制,它不支持多个应用同一时间往同一个 DB 进行写操作.所以当我们知道我们的应用如果只进行读操作,我们可以让 shelve 通过只读方式打开 DB
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 只读
由于 shelve 在默认情况下是不会记录待持久化对象的任何修改的,所以我们在 shelve.open() 时候需要修改默认参数,否则对象的修改不会保存.
设置 writeback
writeback 方式有优点也有缺点.优点是减少了我们出错的概率,并且让对象的持久化对用户更加的透明了;但这种方式并不是所有的情况下都需要,首先,使用 writeback 以后,shelf 在 open() 的时候会增加额外的内存消耗,并且当 DB 在 close() 的时候会将缓存中的每一个对象都写入到 DB,这也会带来额外的等待时间.因为 shelve 没有办法知道缓存中哪些对象修改了,哪些对象没有修改,因此所有的对象都会被写入.
re 模块
python 正则详解: http://www.cnblogs.com/qflyue/p/8252528.html
os 模块
python 文件操作与 os 常用命令: http://www.cnblogs.com/qflyue/p/8110862.html
来源: https://www.cnblogs.com/qflyue/p/8259772.html