python全栈开发day17-常用模块collections,random,time,os,sys,序列化（json pickle shelve）

1.昨日内容回顾

　　1、正则表达式

　　　　　　    # 正则表达式 —— str
 　　　　          # 检测字符串是否符合要求
 　　　　　　   # 从大段的文字中找到符合要求的内容

　　　　　1）、元字符

　　　　　　　　#.　　# 匹配除换行符以外的所有字符

# \n,\t,\b

# \w,\s,\d    \W,\S,\D

　　　　　　　   # ^,$

# ab|a,()

　　　　　　　   #  [...],[^...]　

　　　　　2）、量词

　　　　　　　　# *

# +

# ?

　　　　　　　　# {n}

　　　　　　　　# {n,}

　　　　　　　　# {n,m}

　　　　　3）、贪婪匹配和惰性匹配　　

　　　　　　     .*?x  惰性匹配　

　　　　　4）、其他，转义\ 分组（）

　　　　　　　\转义，在python中，无论是正则表达式，还是待匹配内容，都是用字符串的形式表示，字符串中\也有特殊含义，需要转义。

如‘\d’ 就必须表示成‘\\d’,正则表达式中的'\\d'，就要表示成‘\\\\d’,太麻烦了写成r‘\d’ 正则中表示为r'\\d'

　　2、re模块

2.常用模块

　　0. re:

　　　　1、常用函数

　　　　1)、查询方法

　　　　　　re.findall('a','abcdad',flag=0) # 匹配能匹配的所有项，返回值为一个列表

　　　　　　re.search('a','abcdad')  # 返回匹配的第一个正则对象，用group()函数取值

　　　　　　re.match('\d','123ddd') # 和search类似，但是从头匹配，没有返回None

　　　　2)、替换

re.sub('\d','H','a2dfdf3',1) # 替换字符串符合匹配条件的字符，最后一个参数为替换次数，返回的是替换完成的字符串。

　　　　　　re.subn('\d','H','a2dfdf3') # 替换字符串中所有符合匹配条件的字符，返回一个元组，包含替换完成的字符串和替换次数。

　　　　3)、分割

　　　　　　re.split('[abc]','abcdef')  按匹配条件进行分割。

　　　　4)、编译

　　　　　　com = re.compile('\d+') 编译一个正则表达式，之后可以用com.上面的六个函数任何一个进行相应操作。

　　　　2、分组优先级查询

　　　　　　1）、findall优先级查询：优先返回分组里的查询结果列表，不是分组的查询结果在列表中返回''

　　　　　　2）、split优先级查询：加（）表示保留匹配项值至结果列表中。

　　　　　　取消分组优先级可以通过在分组括号（）里最前面加？：

　　　　3、？的四种用法

　　　　　　1）、在量词之后：是惰性匹配的标志

2）、量词：重复0次或1次

　　　　　　3）、分组命名 （?P<name>）引用的时候 (?P=name)

　　　　　　4）、findall，split优先级查询，取消分组优先级：（？：正则表达式）

　　1.collections

　　　　1）、namedtuple 可命名元组

　　　　2）、OrderedDict 有序字典

　　　　3）、defaultdict 默认字典

　　　　4）、deque 双端队列

　　　　5）、Counter 计数器

6）、queue 队列 黑盒 fifo

　　　　

from collections import *
# namedtuple
# tu = namedtuple('Point',['x','y'])
# tu1 = (1,2)
# print(tu1)
#
# OrderedDict
# o_dic = OrderedDict({'x':1,'y':2,'z':3})
# o_dic1 = OrderedDict(a=1,b=2,c=3)
# o_dic2 = OrderedDict([('a',1),('b',2),('c',3)])
#
# print(o_dic['x'])
# print(o_dic1)
# print(o_dic2)
# '''1
# OrderedDict([('a', 1), ('c', 3), ('b', 2)])
# OrderedDict([('a', 1), ('b', 2), ('c', 3)])'''

# # defaultdict
# d_dic = defaultdict(lambda: 10)
# print(d_dic['k'])

#
## deque
# d = deque()
# d.append(1)
# d.append(2)
# d.append(3)
# d.appendleft('a')
# print(d)
# d.popleft()
# print(d)
# d.pop()
# print(d)

##  Counter
# c =Counter('dciwenjdbvwbfuhqwd')
# print(c)
'''Counter({'w': 3, 'd': 3, 'b': 2, 'n': 1, 'q': 1, 'j': 1, 'v': 1, 'h': 1, 'e': 1, 'u': 1, 'i': 1, 'c': 1, 'f': 1})'''
import queue
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q)
print(q.get())
print(q)

print(q)

　　2.random

　　　　1）随机浮点数

# random.random() # 随机一个0-1之间的浮点数

　　　　　　# random.uniform(1,3)  #大于1小于3的小数

　　　　2）随机整数

　　　　　　print(random.randint(1,10)) # 返回大于等于1且小于等于10的整数
　　　　　　print(random.randrange(1,10,2)) # 返回大于等于1且小于10的奇数

　　　　3）随机取值

　　　　　　print(random.choice([1,2,[12,34],'a'])) # 随机返回列表或元组中一个元素
　　　　　　print(random.sample([1,2,[12,34],'a'],2)) # 随机返回列表或元组中参数设置的个元素

　　　　4）‘洗牌’

　　　　　　li = [1,2,3,4,5]
　　　　　　random.shuffle(li) # 打乱列表顺序
　　　　　　print(li)

　　3.time

　　　　

　　　　# print(time.time())
　　　　# print(time.sleep(1))
　　　　# 1526956073.6129677 时间戳 —— 机器计算
　　　　# 以秒为单位的 浮点型
　　　　# 1970 1 1 0 0 0 —— 伦敦的时间
　　　　# 1970 1 1 8 0 0 —— 北京的时间

　　　　1、几种时间格式之间的转换。

　　　　2 .计算时间差

　　　　

　　　　

def sub_time(ftime1,ftime2,time_format='%Y-%m-%d %H:%M:%S'):
    stamp_time1 = time.mktime(time.strptime(ftime1, time_format))
    stamp_time2 = time.mktime(time.strptime(ftime2, time_format))
    sub_stamp_time = stamp_time2-stamp_time1
    sub_struct_time = time.gmtime(sub_stamp_time)
    return '时间相差%s年%s月%s日%s小时%s分钟%s秒' % (
        sub_struct_time.tm_year - 1970,
        sub_struct_time.tm_mon - 1,
        sub_struct_time.tm_mday - 1,
        sub_struct_time.tm_hour,
        sub_struct_time.tm_min,
        sub_struct_time.tm_min
    )

print(sub_time('2018-05-21 09:34:00','2018-05-22 08:34:00'))

　　4.os

　与操作系统相关的OS：

1）、与工作路径相关的

os.getcwd() #当前执行的工作路径

os.chdir() # 更改当前执行的工作路径

　　　　　　　　os.curdir() # 返回当前目录   # .

os.pardir() # 返回当前目前的父目录  # .

　　　　　　　　

　　　　　　　　

import os
print(os.getcwd())
os.chdir('D:\Python\Projects\py笔记')
print(os.getcwd())
'''D:\Python\Projects\py笔记\day17
D:\Python\Projects\py笔记'''

2）、和操作文件文件夹相关的

# os.listdir('dirname')  # 以列表形式返回指定目录下的子文件夹，文件，隐藏文件名。

　　　　　　#os.mkdirs('dirname\d') # 递归创建文件夹

#os.mkdir('dirname') #生成单级目录

　　　　　　#os.removedirs('dirname') # 若目录为空，则删除，并递归至上一级目录，如为空，则删除，以次类推。

　　　　　　#os.rmdir('dirname')  #删除单级空目录，若目录不为空则无法删除，报错。

　　　　　　#os.remove('dirname') # 删除一个文件

　　　　　　#os.rename('dirname') # 重命名文件/目录

　　　　　　#os.stat('')  获取文件/目录信息

　　　　　　3）、和操作系统差异相关的。

　　　　　　#os.sep  输出操作系统特定的路径分隔符，win下为‘\\’,linux为‘/’

　　　　　　#os.linesep 输出当前平台使用的行终止符 ，win下为‘\t\n’,linux为‘\n’

　　　　　　#os.pathsep 输出用于分割文件路径的字符串，win下为‘；’,linux为‘：’

　　　　　　#os.name 输出字符串指示当前使用的平台。win-》‘nt’ ；Linux-》‘posix’

　　　　　　4）、和执行操作系统命令相关的

　　　　　　#os.system('bash command') 运行shell命令，直接显示

#os.popen('bash command').read() 运行shell命令，获取执行结果。

　　　　　　#os.environ 获取系统变量

　　　　　　5）、os.path

　　　　　　 #os.path.abspath(path) 　　返回path规范化的绝对路径

　　　　　　#os.path.split(path) 　　将path分割成目录和文件名二元组返回

　　　　　　#os.path.isabs(path)　　如果是path是绝对路径，返回True 否则返回False

　　　　　　#os.path.isfdir(path)      如果path是一个存在的目录，返回True 否则返回False

　　　　　　#os.path.isfile(path)      如果path是一个存在的文件，返回True 否则返回False

　　　　　　#os.path.exists(path)   如果path存在，返回True 否则返回False

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

　　　　　　#os.path.getatime(path) 　　返回path所指向的文件或目录的最后访问时间

　　　　　　#os.path.getmtime(path)       返回path所指向的文件或目录的最后修改时间

　　　　　　#os.path.getsize(path)          返回path大小，如果是文件夹返回大小不准确，全部为4096，如果是文件，则返回的是真实大小。

　　　　　　

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

os.stat 获取文件或目录信息 说明

　　5.sys

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

　　　　sys.argv 命令含参数List，第一个元素是程序本身的路径

　　　　sys.path  返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值。

　　　　sys.exit(n)  退出程序，正常退出时exit(0),错误退出sys.exit(1)

　　　　sys.version 获取Python解释程序的版本信息。

　　　　sys.platform 返回操作系统平台的名称

　　6.序列化模块json、pickle、shelve
　　　　什么叫序列化，将原本的列表、字典等内容转换成字符串，就叫做序列化。

　　　　1.数据存储，2网络传输，3，可维护

　　　　1）、json

　　　　　　数字

　　　　　   字符

　　　　　　列表（元组会转换成列表后序列化，反序列化后是列表）

　　　　　　字典（key值必须是str，否则不能被序列化）

这四种类型可以被序列化，其他的都不行，被json序列化后，与其他语言通用。

json.dumps()/json.loads() 在内存中转换

　　   json.dump()/json.load() 在文件和内存之间转换

2)、json的问题

　　　　　　1.有限的数据类型

　　　　　　2.字典的key必须为str

　　　　　　3.不能连续load

　　　　　　3）、序列化参数说明

　　　　　　

Serialize obj to a JSON formatted str.(字符串表示的json对象)
Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key
ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。)
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse).
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity).
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError.
sort_keys：将数据根据keys的值进行排序。
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

参数说明

　　　　import json
　　　　data = {'username':['李华','二愣子'],'sex':'male','age':16}
　　　　json_dic2 = json.dumps(data,skipkeys=False,ensure_ascii=False,indent=4,sort_keys=True,separators=(',',':'))
　　　　print(json_dic2)

3）、pickle

import pickle
data = {'username':['李华','二愣子'],'sex':'male','age':16}
with open('pickle','wb') as f:
    pickle.dump(data, f)
    pickle.dump(data, f)
    pickle.dump(data, f)

with open('pickle','rb') as f:
    while True:
        try:
            print(pickle.load(f))
        except:
            break

pickle例子

　　　　　4）、shelve

　　

import shelve
f = shelve.open('shelve')
f['key1'] = {'k1':1,2:'k2'}
f.close()

f = shelve.open('shelve')
print(f['key1'])
f.close()

　　　　

3.当日作业

4.预习和扩展