内置方法的进阶-day22
__new__ 构造方法 创建对象之初执行
# __new__ # 在init之前，实例化对象的第一步是__new__创建了一个空间 # class Foo: # def __init__(self): # 初始化方法 # # print('执行了init') # # def __new__(cls, *args, **kwargs): # 构造方法 # # # object.__new__(cls) # # print('执行了new') # # return object.__new__(cls) # # obj = Foo() # 创造一个对象 比喻成 捏小人 # new 是小人捏出来了 # init 给小人穿衣服 # 设计模式 常用的23种 # java里来的 # python # 推崇设计模式 java开发 # 贬低设计模式 纯python开发 # 单例模式 # 一个类 只有一个实例的时候 单例模式 # class Foo: # __instance = None # def __init__(self,name,age): # 初始化方法 # self.name = name # self.age = age # self.lst = [name] # def __new__(cls, *args, **kwargs): # 构造方法 # if cls.__instance is None: # cls.__instance = object.__new__(cls) # return cls.__instance # # obj1 = Foo('alex',20) # obj2 = Foo('egon',22) # print(obj1.lst,obj2.lst)
通过以上new方式判断。 实现了 2个对象的内存地址一模一样，从而实现了单例模式。
__del__ 删除对象执行
# class Foo: # def __init__(self,name,age): # self.name = name # self.age = age # self.file = open('file',mode = 'w') # def write(self): # self.file.write('sjahgkldhgl') # def __del__(self): # 析构方法 ： 在删除这个类创建的对象的时候会先触发这个方法，再删除对象 # # 做一些清理工作,比如说关闭文件，关闭网络的链接，数据库的链接 # self.file.close() # print('执行del了') # # f = Foo('alex',20) # print(f)
__len__
len() lst dict set str print('__len__' in dir(list)) print('__len__' in dir(dict)) print('__len__' in dir(set)) print('__len__' in dir(tuple)) print('__len__' in dir(str)) print('__len__' in dir(int)) print('__len__' in dir(float)) class Foo: def __len__(self): return 1 obj = Foo() print(len(obj)) class Class: def __init__(self,name,course): self.name = name self.course = course self.students = [] def __len__(self): return len(self.students) s1 = Class('1班','python') s1.students.append('wuyi') s1.students.append('yangyi') s1.students.append('wangfan') print(len(s1)) #重复使用节省代码
__hash__ 哈希
# class Foo(): # pass # # obj1 = Foo() # obj2 = Foo() # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj1)) # 内存地址 97649779257 # print(hash(obj2)) # 97649779271 # 1.每次执行hash值都会变化 # 2.在一次执行的过程中对同一个值得hash结果总是不变的 # 字典为什么寻址快 # dic = {'name':'alex','age':83,'sex':'不详'} # 字典在内存中是如何存储的？ # 为什么字典的key必须可hash # hash算法 # 1.对于相同的值在一次程序的运行中是不会变化的 # 2.对于不同的值在一次程序的运行中总是不同的 # set的去重机制 # new_lst = [1,2,3,4,5,6,7,8,9,0,10,111,238579] # lst = [2,2,43,53,238579,14780] # for i in lst: # if i in new_lst: # pass # else: # new_lst.append(i) # set = {1,2,'abc',3,4,5,6,7,8,9,'bca'} # 不能通过逐个判断值相等这件事儿来做去重工作 # hash算法也不是完全的靠谱 # set 的去重机制 # 1.对每一个元素进行hash计算出一个内存地址 # 2.到这个内存地址上查看 # 如果这块内存中没有值 # 将这个元素存到对应的内存地址上 # 如果这块内存中已经有值 # 判断这两个值是否相等 # 如果相等 就舍弃后面的值 # 如果不相等 就二次寻址再找一个新的空间来存储这个值
__eq__ 定制2个对象的属性关系是否相等。
# class Staff: # def __init__(self,name,sex): # self.name = name # self.sex = sex # def __eq__(self, other): # return self.__dict__ == other.__dict__ # alex = Staff('alex','不详') # alex2 = Staff('alex','不详') # alex22 = Staff('alex2','female') # print(alex == alex2) # alex.__eq__(alex2) # print(alex2 == alex22) # l1 = [1,2,3,4] # l2 = [1,2,3,4] # print(id(l1),id(l2)) # print(l1 == l2) # print(l1 is l2)
item系列
内置方法的例子
纸牌游戏
面试题
# 员工类 # 姓名 年龄 性别 部门 # 转岗位 # 姓名 年龄变化了 性别 部门 # 100个员工，去掉重复的 # 员工的姓名 性别 是相同的，就认为是同一个员工 class Staff: def __init__(self,name,age,sex,dep): self.name = name self.age = age self.sex = sex self.dep = dep def __hash__(self): return hash(self.name + self.sex) def __eq__(self, other): if self.name == other.name and self.sex == other.sex: return True name_lst = ['yuan','egon','nazha','peiqi'] obj_lst = [] for i in range(100): name = name_lst[i%4] obj = Staff(name,i,'male','python') obj_lst.append(obj) print(obj_lst) ret = set(obj_lst) print(ret) for i in ret: print(i.name,i.age)
常用模块
序列化模块 *****
# 模块 # 别人写好的功能放在一个文件里 # 内置模块 ： 安装python解释器的时候一起装上的 # 第三方模块、扩展模块 ：需要自己安装 # 自定义模块 ： 你写的py文件 # 序列化模块 # 序列 # 列表 # 元组 # 字符串 * # bytes * # 什么叫序列化 # 把一个数据类型转换成 字符串、byets类型的过程就是序列化 # 为什么要把一个数据类型序列化？ # {'name':'何青松'，'sex':'male'} # 当你需要把一个数据类型存储在文件中 # 当你需要把一个数据类型通过网络传输的时候 # 及其不安全的 # stu = {'name':'何青松','sex':'male'} # ret = str(stu) # print([ret]) # print([eval(ret)]) # 用户输入的、文件读入的、网络传入的 import json # stu = {'name':'何青松','sex':'male'} # ret = json.dumps(stu) # 序列化的过程 # print(stu,type(stu)) # print(ret,type(ret)) # # d = json.loads(ret) # 反序列化的过程 # print('d-->',d,type(d)) # lst = [1,2,3,4,'aaa','bbb'] # ret = json.dumps(lst) # 序列化的过程 # print(lst,type(lst)) # print(ret,type(ret)) # # d = json.loads(ret) # 反序列化的过程 # print('d-->',d,type(d)) # json的优点 # 所有的语言都通用 # 缺点 # 只支持非常少的数据类型 # 对数据类型的约束很苛刻 # 字典的key必须是字符串 # 只支持 ： 数字 字符串 列表 字典 # stu = {'name':'何青松','sex':'male',1:('a','b')} # ret = json.dumps(stu) # 序列化的过程 # print(stu,type(stu)) # print(ret,type(ret)) # d = json.loads(ret) # 反序列化的过程 # print('d-->',d,type(d)) import pickle # stu = {'name':'何青松','sex':'male',1:('a','b')} # ret = pickle.dumps(stu) # print(ret) # d = pickle.loads(ret) # print(d,type(d)) class Course(): def __init__(self,name,price): self.name = name self.price = price python = Course('python',29800) ret = pickle.dumps(python) print(ret) p = pickle.loads(ret) print(p.name,p.price)
二、序列化模块
什么叫序列化—--将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
为什么要有序列化模块？
比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将字典转换成字符串放到文件中。你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？没错，序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，但是你要怎么把一个字符串转换成字典呢？聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。eval()函数十分强大，但是eval是做什么的？官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设想。而使用eval就要担这个风险。所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)。
为什么要把其他数据类型转换成字符串?（使用序列化的场景）
1）能够在网络上传输的只能是bytes,
2）能够存储在文件里的只有bytes和str
序列化的目的：
1）以某种存储形式使自定义对象持久化；
2）将对象从一个地方传递到另一个地方；
3）使程序更具维护性；
1、json模块
json模块提供了四个功能：序列化（dumps和dump）、反序列化（loads和load）。如下示例：
import json
dic = {'key' : 'value','key2' : 'value2'}
ret = json.dumps(dic) # 序列化
print(dic,type(dic)) # {'key': 'value', 'key2': 'value2'} <class 'dict'>
print(ret,type(ret)) # {"key": "value", "key2": "value2"} <class 'str'>
res = json.loads(ret) # 反序列化
print(res,type(res)) # {'key': 'value', 'key2': 'value2'} <class 'dict'>
# json能够序列化的数据有什么特点，请看下面几个示例，并分析结果：
# 问题1:字典的key是整型，经过序列化和反序列化变成字符串类型
# 问题2:字典的value是元组，经过序列化和反序列化变成了列表类型
dic = {1 : [1,2,3], 2 : (4,5,'aa')}
ret = json.dumps(dic) # 序列化
print(dic,type(dic)) # {1: [1, 2, 3], 2: (4, 5, 'aa')} <class 'dict'>
print(ret,type(ret)) # {"1": [1, 2, 3], "2": [4, 5, "aa"]} <class 'str'>
res = json.loads(ret) # 反序列化
print(res,type(res)) # {'1': [1, 2, 3], '2': [4, 5, 'aa']} <class 'dict'>
# 问题3:set集合类型不能被json序列化
# 问题4:字典的键必须是字符串才能被json序列化
s = {1,2,'aaa'}
json.dumps(s) # 报错：TypeError: Object of type 'set' is not JSON serializable
json.dumps({(1,2,3):123}) # 报错：TypeError: keys must be a string
总结：json在所有的语言之间都通用：即json序列化的数据，在python上序列化了，那在java中也可以反序列化，所以json能够处理的数据类型是非常有限的，只有字符串，列表，字典，数字这几种类型，而且字典中的key只能是字符串。
# 向文件中记录字典
import json
dic = {'key' : 'value','key2' : 'value2'}
ret = json.dumps(dic) # 序列化（将序列化结果写入内存，下面从内存中读取写入文件）
with open('json_file','a') as f:
f.write(ret) # 向文件json_file中写入字典{"key": "value", "key2": "value2"}
# 从文件中读取字典
with open('json_file','r') as f:
str_dic = f.read() # 文件中读取后写入内存
dic = json.loads(str_dic) # 将内存中的字符串反序列化
print(dic) # 将反序列化的结果打印{'key': 'value', 'key2': 'value2'}
# dump和load是直接操作文件的，如下示例：
dic = {'key1' : 'value1','key2' : 'value2'}
with open('json_file','a') as f:
json.dump(dic,f) # 向文件json_file中写入：{"key1": "value1", "key2": "value2"}
with open('json_file','r') as f:
dic = json.load(f)
print(dic) # {'key1': 'value1', 'key2': 'value2'}
总结：如果你是处理和文件相关的（往文件里边写或者从文件里边读），那么可以用dump和load；如果是处理网络上传输的数据时，此时数据都是在内存里，这是就要用dumps和loads。
# 问题5 不支持连续的存 取
dic = {'key1' : 'value1','key2' : 'value2'}
with open('json_file','a') as f:
json.dump(dic,f)
json.dump(dic,f)
json.dump(dic,f)
with open('json_file','r') as f:
dic = json.load(f)
print(dic.keys())
总结：上面程序中虽然成功通过dump多次向文件中存入3个字典，但是load会报错# 也就是说load只能读取存一个字典的文件，嵌套字典也可以，但最外层只能是一个。
那么现在有个需求：就是想要把一个一个的字典放到文件中，再一个一个的取出来，该怎么实现？如下示例：
dic = {'key1' : 'value1','key2' : 'value2'}
with open('json_file','a') as f:
str_dic = json.dumps(dic)
f.write(str_dic+'\n')
str_dic = json.dumps(dic)
f.write(str_dic + '\n')
str_dic = json.dumps(dic)
f.write(str_dic + '\n')
with open('json_file','r') as f:
for line in f:
dic = json.loads(line.strip())
print(dic)
# 结果为：
# {'key1': 'value1', 'key2': 'value2'}
# {'key1': 'value1', 'key2': 'value2'}
# {'key1': 'value1', 'key2': 'value2'}
综上：json的dumps、loads-----在内存中做数据转换：
dumps 序列化 数据类型 转成 字符串；
loads 反序列化 字符串 转成 数据类型；
json的dump、load----直接将数据类型写入文件，直接从文件中读出数据类型：
dump 序列化 数据类型 写入 文件 反序列化；
load 反序列化 文件中 读出 数据类型；
json是所有语言都通用的一种序列化格式，只支持列表、字典、字符串、数字，且字典的key必须是字符串。
# ensure_ascii 关键字参数
dic = {'key':'你好'}
print(json.dumps(dic)) # {"key": "\u4f60\u597d"}
print(json.dumps(dic,ensure_ascii=False)) # "key": "你好"}
# json 的格式化输出
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
print(json_dic2)
# 结果为：
# {
# "age":16,
# "sex":"male",
# "username":[
# "李华",
# "二愣子"
# ]
# }
2、pickle模块
pickle模块提供了四个功能：序列化，存（dumps、dump）、反序列化，读（loads、load），此外，pickle模块不仅可以序列化字典，列表...它可以把python中任意的数据类型序列化。
import pickle
dic = {(1,2,3):{'a','b'},1:'abc'}
ret = pickle.dumps(dic) # dumps序列化的结果只能是字节
print(ret) # 结果为：b'\x80\x03}q\x00(K\x01K\x02K\x03\x87q\x01cbuiltins\nset\nq\x02]q\x03(X\x01\x00
\x00\x00aq\x04X\x01\x00\x00\x00bq\x05e\x85q\x06Rq\x07K\x01X\x03\x00\x00\x00abcq\x08u.'
print(pickle.loads(ret)) # {(1, 2, 3): {'b', 'a'}, 1: 'abc'}
# pickle模块的dump、load 的和文件操作
with open('pickle_file','wb') as f:
pickle.dump(dic,f)
with open('pickle_file','rb') as f:
ret = pickle.load(f)
print(ret,type(ret))
# pickle可以多次dump和load
dic = {(1,2,3):{'a','b'},1:'abc'}
dic1 = {(1,2,3):{'a','b'},2:'abc'}
dic2 = {(1,2,3):{'a','b'},3:'abc'}
dic3 = {(1,2,3):{'a','b'},4:'abc'}
with open('pickle_file','wb') as f:
pickle.dump(dic, f)
pickle.dump(dic1, f)
pickle.dump(dic2, f)
pickle.dump(dic3, f)
with open('pickle_file','rb') as f:
ret = pickle.load(f)
print(ret,type(ret))
ret = pickle.load(f)
print(ret,type(ret))
ret = pickle.load(f)
print(ret, type(ret))
ret = pickle.load(f)
print(ret, type(ret))
# ret = pickle.load(f) # EOFError: Ran out of input
# print(ret, type(ret)) # dump了4个字典，第5次load会报错
# 结果为：
# {(1, 2, 3): {'b', 'a'}, 1: 'abc'} <class 'dict'>
# {(1, 2, 3): {'b', 'a'}, 2: 'abc'} <class 'dict'>
# {(1, 2, 3): {'b', 'a'}, 3: 'abc'} <class 'dict'>
# {(1, 2, 3): {'b', 'a'}, 4: 'abc'} <class 'dict'>
# 改进
with open('pickle_file','rb') as f:
while True:
try:
ret = pickle.load(f)
print(ret,type(ret))
except EOFError:
break
总结：1）pickle模块序列化支持在python中几乎所有数据类型；
2）pickle模块的dumps/dump序列化的结果只能是字节；
3）只能在python中使用；
4）在和文件操作的时候，需要用rb wb的模式打开文件；
5）可以多次dump和多次load；
随机数模块
ps:部分内容来自于互联网整理，如有侵权请联系我们，我们会在看到通知后24小时内做出处理。
posted on
浙公网安备 33010602011771号