# 一序列化模块： 什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
# eval() 也是专门针对于字符串的 将字符串str当成有效的表达式来求值并返回计算结果。
# ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。 但是而使用eval就要担这个风险。
# 所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)
# 1import json***** Json模块提供了四个功能：dumps、dump、loads、load
#1 所有的语言都通用，序列化中的内容只能包含：字典 列表 数字 字符串
#2 如果是元组——自动转成列表的样子
# 1-1***** import json #(json 只有字典 列表 元祖)
# 1 dumps、loads 针对字符串 序列化和反序列化
# json.dumps() 转化成字符串
# ret = json.dumps({'k':(1,2,3),'k1':'wangyan'})
# print(repr(ret),type(ret))
# '{"k": [1, 2, 3], "k1": "wangyan"}' <class 'str'>
# json.loads() 转化成字符串
# ret1 = json.loads(ret)
# print(repr(ret1),type(ret1))
# {'k': [1, 2, 3], 'k1': 'wangyan'} <class 'dict'>
#dump() 对于文件的内容变成字符串的（写入的意思）
# 注意 json.dump( 里面必须加上文件句柄****f****)
# with open('wenjian','a') as f:
# json.dump({'k1':11,'k2':22},f)
# with open('wenjian',) as f:
# ret = json.load(f)
# print(ret)
# {'k1': 11, 'k2': 22}
# 1-2 ***import pickle
# 1序列化任何数据类型(json 只有字典 列表 元祖)，python专有的不能和其他语言兼容，
#2用pickle序列化的数据，反序列化也必须用pickle、
# 3结果是bytes
# import pickle
# ret = pickle.dumps({1,2,3,4})
# print(ret)
# b'x80x03cbuiltins
set
qx00]qx01(Kx01Kx02Kx03Kx04ex85qx02Rqx03.'
# ret1 = pickle.loads(ret)
# print(ret1)
# {1, 2, 3, 4}
# 1-3 import shelve
# 只提供一个open，shelve.open('文件名')拿到一个文件句柄，这个文件句柄就
# 可以当做字典操作
#1 正常情况下shelve打开的文件句柄感知不到值的修改，设置writeback = True就可以保存修改内容了
#2 正常情况下不支持多个人同时写，支持多个人同时读，如果只是读的化，就设置flag=‘r’
# 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)
# {'int': 10, 'float': 9.5, 'string': 'Sample data'}
# import shelve
# f = shelve.open('shelve_file', flag='r') #只读模式
# existing = f['key']
# f.close()
# print(existing)
# {'int': 10, 'float': 9.5, 'string': 'Sample data'}
# import shelve
# 可以写 案例1
# f1 = shelve.open('shelve_file')
# print(f1['key']) #原来的
# f1['key']['new_value'] = 'this was not here before'
# f1.close()
# 可以写案例2 wrtiteback =True
# f2 = shelve.open('shelve_file', writeback=True) #只写模式
# print(f2['key'])
# f2['key']['new_value'] = 'this was not here before'
# f2.close()
# 二 os 模块 os模块是与操作系统交互的一个接口
# 重要的记住的***表示
# import os
#1 os.getcwd() *** 获取当前工作目录，即当前python脚本工作的目录路径
# print(os.getcwd())
# D:python 资料171017每天视频资料day23day23
#2 os.makedirs ***('dirname1/dirname2') 可生成多层递归目录
#2 os.mkdir***('dirname') 生成单级目录；相当于shell中mkdir dirname
# ret = os.mkdir('yang')
# 不需要打印直接run 就行的
# print(os.mkdir('ww'))
# 都可以直接建立目录是和此文件并列的上一级目录里
# ret = os.makedirs('wang/luo')
# print(ret)
# os.makedirs('dir\dir2\dir3')
# 直接建立两层或者以上的目录 注意是\
# 3 os.removedirs***('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
# 3 os.rmdir***('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
# ret = os.rmdir('yang')
# print(ret)
# 删除上一级的目录'
# ret = os.rmdir('dir\dir2\dir3')
# 直接删除了 dir3
# os.removedirs('dir\dir2')
# 这样的就直接删除两个
# 4 os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
# 若果listdir()为空 显示当前的 当前目录的列表
# print(os.listdir())
# "D:/python 资料171017/每天视频资料/day23/day23/11.18模块大总结.py"
# ['1.复习.py', '11.17周末作业.py', '11.18模块大总结.py',
# '2.知识概要.py', '3.楔子.py', '4.初识面向对象.py', '5. 面向对象交互.py
# 5. 面向对象交互.py', 'ff.bak', 'ff.dat', 'ff.dir', 'shelve_file.bak', 'shelve_file.dat','
# ' 'shelve_file.dir', 'wang', 'wenjian', 'ww']
# lisdir(r'加路径 显示所有 的内容组成的列表')
# print(os.listdir(r'D:/python 资料171017/每天视频资料'))
#太多不写
# 5 os.remove() *** 删除一个文件
# 6 os.rename("oldname","newname") ***重命名文件/目录
# 7 os.stat('path/filename') 获取文件/目录信息
# 8os.stat()
# 9os.system("bash command") 没有返回值 且直接执行代码 把结果输出 运行shell命令，直接显示
# 10os.popen("bash command) 如果有结果就把结果返回回来 运行shell命令，获取执行结果
# print(ret.read)
# 11os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
# 12os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
# os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
# os.linesep 输出当前平台使用的行终止符，win下为"
",Linux下为"
"
# os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为:
# os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
# os.system("bash command") 运行shell命令，直接显示
# os.popen("bash command) 运行shell命令，获取执行结果
# os.environ 获取系统环境变量
## os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
# os.curdir 返回当前目录: ('.')
# os.pardir 获取当前目录的父目录字符串名：('..')
# 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的大小
# 一、collection模块
# 1 namedtuple:生成可以使用名字来访问元素内容的tuple
# 2.deque: 双端队列，可以快速的从另外的一侧追加和推出对象
# 3.Conter 计数器，主要用来奇数
# 4.OrderedDict :有序字典
# 5.defaultdict 带有默认值的字典
# 1、namedtuple：生成可以使用名字访问元素的元组，正常的元组可以通过索引进行取值，
# 但是很难看出元组元素所表示的意义，这就是namedtuple数据类型存在的意义。其用法如下实例：
# from collections import namedtuple#
# circle = namedtuple('P', ['x', 'y', 'r'])
# # # P可以取任意变量名，无实际用处，但不可或缺
# c1 = circle(2, 3, 5)
# # print(c1.x)
# 2
# print(c1.y)
# 3
# print(c1.r)
# 2、deque：主要针对列表 list可以高效的进行元素查找，但是对于追加和删除元素比较困难，尤其对于列表较大时
# 主要是因为列表为单向序列，遵循先进先出原则，只能在列表末尾进行元素的追加（append（））和删除（pop（））。
而deque就是为了高效解决列表的增加和删除元素的，除了具有append（）和pop（）外
# ，还具有appendleft（）和popleft（）方法，可以在列表的头部进行元素的增加和删除。
# from collections import deque
# q = deque(['a', 'b', 'c'])
# q.append('x')
# q.appendleft('y') # 在前面加
# print(q)
# 输出结果为：deque(['y', 'a', 'b', 'c', 'x'])
# q.pop()
# print(q)
# 输出结果为：deque([ 'a', 'b'])
# q.popleft() # 删前面
# print(q)
# 输出结果为：deque([ 'b', 'c'])
# 3、Counter：主要用来跟踪值出现的次数，返回无序的数据类型，用字典键值对进行记录结果，
# 其中元素为key，次数为value。
# from collections import Counter
# c = Counter('abcdeabcdabcaba')
# print(c)
# 输出结果为：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
# 4、OrderDict：使用dict时，key是无序的，无法对其进行迭代，而OrderDict可以使得其变成有序，
# key的顺序为插入时的顺序，非key本身的顺序。 输出是元祖的形式
# from collections import OrderedDict
# d = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# # 可以为这样的形式：
# d = OrderedDict({'a': 1, 'b': 2, 'c': 3})
# for key in d:
# print(key) # 输出结果为：a b c
# d['key'] = 'value' # 按照顺序添加在后面
# print(d)
# 输出结果为：OrderedDict([('a', 1), ('b', 2), ('c', 3), ('key', 'value')])
# 5、Defaultdict: 使用dict时，当key不存在，则会返回keyerror，若希望出现此情况时返回
defaultdict(list)
# 默认值则可用defaultdict。
# 这种方法就是自动可以添加一个k ,而常规的方法是 如果是没有ke的情况下，还得给ke对应值
# 加个列表
# 例子有如下值集合[11, 22, 33, 44, 55, 66, 77, 88, 99, 90]，将所有大于
# 这个defaultdict的关键是 dic1 = defaultdict(list) 必须转换成列表 关键
# from collections import defaultdict
# l = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
# dic1 = defaultdict(list)
# for i in l:
# if i > 66:
# dic1['k1'].append(i)
# if i < 66:
# dic1['k2'].append(i)
# print(dic1)
# {'k2': [11, 22, 33, 44, 55], 'k1': [77, 88, 99, 90]})
# dic = {'k1': 大于66, 'k2': 小于66}
# dic1 ={}
# for i in l :
# if i > 66:
# if 'k1' in dic1:
# dic1['k1'] .append(i)
# else:
# dic1['k1'] = [i]
# if i< 66:
# if 'k2' in dic1:
# dic1['k2'].append(i)
# else:
# dic1['k2'] = [i]
#
# print(dic1)
# {'k2': [11, 22, 33, 44, 55], 'k1': [77, 88, 99, 90]}
# 四 re 模块
# 1 findall 找所有 返回所有满足匹配条件的结果,放在列表里
# 2 finditer 迭代器 有返回值 需要 for group()
# 3 split 分割成列表
# 4 compile() 编译
# 5 search 从左到右 找到一个就停止
# 6 match 找到一个以什么开头的
# 7 sub 替换
# 8 subn 替换返回一个元祖
# import re
# findall和finditer
# ret = re.findall('a', 'eva egon yuan') # 返回所有满足匹配条件的结果,放在列表里
# print(ret)
#结果 : ['a', 'a']
# # 返回所有满足匹配条件的结果,放在列表里
# print(ret) 为啥报错 finditer 返回的是个迭代器 findall 返回的是一个列表
# 根据迭代器的惰性 不打不出ret = re.finditer('a', 'eva egon yuan') 来 又要生成列表 后边加group
# print(next(ret).group) 迭代器返回迭代器 目前类似range
# <built-in method group of _sre.SRE_Match object at 0x032FC758>
# for i in ret:
# print(i)
# <_sre.SRE_Match object; span=(2, 3), match='a'>
# print(i.group())
# a
# a
# 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']
# split
# ret= re.split('[ab]','abcd')
# print(ret)
# ['', '', 'cd']
# ret=re.split("d+","eva3egon4yuan")
# print(ret) #结果 ： ['eva', 'egon', 'yuan']
#
# ret=re.split("(d+)","eva3egon4yuan")
# print(ret) #结果 加上括号后切割保留切割对象仅此而已
# ： ['eva', '3', 'egon', '4', 'yuan']
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的
# search
# ret = re.search('a', 'eva egon yuan').group()
# print(ret)
# a
# ret = re.search("<(?P<tag_name>w+)>w+</(?P=tag_name)>","<h1>hello</h1>")
# print(ret.group())
# # <h1>hello</h1>
# print(ret.group('tag_name'))
# h1
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
# 以下也是一种写法 就是1 对应后边的h1
# ret = re.search(r"<(w+)>w+</1>","<h1>hello</h1>")
#如果不给组起名字，也可以用序号来找到对应的组，表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
# print(ret.group(1))
# print(ret.group()) #结果 ：<h1>hello</h1>
# match 区别search 在字符串的开头匹配 是个迭代器
# ret2 = re.match('a','aeva egon yuan')
# print(ret2)
# <_sre.SRE_Match object; span=(0, 1), match='a'>
# ret2 = re.match('a','aeva egon yuan').group()
# print(ret2)
# a
# sub 和subn 替换 区别多一个元祖 后边的数字n 多少次有返回值
# ret = re.sub('d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
# print(ret) #evaHegon4yuan4
# ret = re.subn('d', 'H', 'eva3egon4yuan4',1)#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
# print(ret) # ('evaHegonHyuan4', 2)
#
# compile() 编译
# obj = re.compile('d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
# ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
# print(ret.group()) #结果 ： 123
# 五 异常处理 *****
# nameError 使用一个还未被赋予对象的键
# attributeError 属性；特质 试图访问一个对象没有的树形，比如说foo。x ,但是foo没有属性x
# typeError 类型错误
# importError ，基本上是路径问题或者名称错误
# IndexError 下标索引超出序列边界，比如当x有三个三个元素，却试图访问 xp[5]
# keyError 试图访问字典里不存在的键
# keyboardInterrrupt Ctrl +c 放下
# syntaxError 传入对象类型与要求的不符合
# UnboundLocalError 试图访问一个还未被设置的局部变量，基本上市由于另有一个同名的全局变量导致你以为
# 正在访问它
# valueError 传入一个使用者不期望的值，及时值的类型是正确的。
# 常见单词 defined ：定义的 清晰的， name a is not defined
# 第一种
------------
# 六 random 选取数字
# 1 小数
# import random
# ret = random.random()
# print(ret)
# 0到1 之间的小数 特殊只能空默认
# print(random.uniform(1,2))
# 1到2 之间的小数
# 2 整数 取一个
# print(random.randint(1,4))
# [1:4)
# print(random.randrange(1,4))
# [1:3)
# print(random.randrange(1,7,2))
# 步长为2 取值
主要针对的是列表
# print(random.choice[1,3.4,5])
# 取一个
# 多取值
# print(random.sample([1,'23',44,[4,5]],2))
# 取2个 可以多取
# 打乱取
# item=[1,3,5,7,9]
# random.shuffle(item)
# print(item)
# 题目制作6个包括大小写字母和数字的任意个数
# import random
# l=[]
# for i in range(6):
# num = str(random.randint(1,9))
# alpha = chr(random.randint(65,90))
# alpha_lower = chr(random.randint(97,122))
# ret = random.choice([num,alpha,alpha_lower])
# l.append(ret)
# print(''.join(l))
大写A 到Z 65 90 小写 97 122
# 时间模块：
# 1.time.sleep(secs)
# (线程)推迟指定的时间运行。单位为秒。
# 2.time.time()
# 获取当前时间戳
# 3 时间戳(timstmap)、元组(struct_time)、格式化的时间(formatime)字符串：
# timestmap (时间戳):1345000
# 通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒
# 计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
# structime（结构化时间或者元祖时间）:
# 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 当前时区的名称
# %% %号本身
# formatime（格式化时间或者时）:1999-12-06’
# 三种表达方式互相转化 以结构化时间为核心转化，
#
# 时间戳 转化为 结构化时间
# 注意 时间戳 和 格式化时间是不能互相转化的。
# timestmap localtimegmtime structime(元)
# 结构化时间 转化为 时间戳
# structime mktime timestmap
#
# 格式化时间（字） 转化 结构化时间（元）
# formatime strptime structime
# 结构化时间（元） 转化 格式化时间（字）
# struct_time strftime formatime
# import time
# True_time = time.mktime(time.strptime('2017-10-15 08:20:33','%Y-%m-%d %H:%M:%s'))
# time_now = time.mktime(time.strptime('2017-11-15 04:20:33','%Y-%m-%d %H:%M:%s'))
# dif_time = time_now - True_time
# struct_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)
# 面向对象：
# 抄写
# 人狗大战
class Person:
def __init__(self,life_value,agge,name,job):
self.lv = life_value
self.agge = agge
self.name = name
self.job = job
def attack(self,dog_obj):
print('%s 攻击了%s'% (self.name,dog_obj.name))
dog_obj.lv -= self.agge
class Dog:
def __init__(self,life_value,agge,name,kind):
self.lv = life_value
self.agge = agge
self.name = name
self.kind = kind
def bit(self,person_obj):
print('%s 咬了%s' % (self.name,person_obj.name))
person_obj.lv -= self.agge
jin_boss = Person(200,20,'JJ','driver')
dog_h = Dog(180,30,'HH','Zangao')
jin_boss.attack(dog_h)
print(jin_boss.agge)
dog_h.bit(jin_boss)
print(jin_boss.agge)