内置方法补充以及序列模块初识

内置方法

__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）

单例模式

一个类，只有一个实例的时候，用单例模式

class Foo:
    __qwer = None

    def __init__(self, name, age):                 #初始化方法
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):        #构造方法
        if cls.__qwer is None:
            cls.__qwer = object.__new__(cls)
        return cls.__qwer


obj1 = Foo('wang', 18)
obj2 = Foo('rui', 20)
print(obj1.name, obj2.name)
#rui  rui
#无论实例化多少个对象，他们的内存地址是相同的，也就是说结果是最后一个对象的属性

__del__

析构方法：在删除一个类创建的对象的时候会先触发__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('qwerdf')

    def __del__(self):#析构方法：删除类创建的对象时先执行这个方法，再删除对象
         #做一些清理工作，比如文件的关闭，关闭网络链接，数据库的链接等
        self.file.close()
        print('执行了del')


f = Foo('wang', 18)
print(f)
#<__main__.Foo object at 0x00000248B55C0390>(对象的内存地址)
#执行了del

__len__

len()　　list，dict，set，str....

class Foo:
    def __len__(self):
        return 1
obj = Foo()
print(len(obj))
#1

class NumberOfPeople:
    def __init__(self, name, course):
        self.name = name
        self.course = course
        self.students = []
    def __len__(self):
        return len(self.students)
s1 = NumberOfPeople('终极一班','history')
s1.students.append('小明')
s1.students.append('小王')
print(len(s1))                 #2
print(s1.__len__())         #2

__eq__

根据__eq__方法里的代码去判断两边是否相等

class Student:
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    def __eq__(self, other):
        return self.__dict__ == other.__dict__


s1 = Student('小明', 'male')
s2 = Student('小明', 'male')
s3 = Student('小河', 'female')
print(s1 == s2)         #True
print(s2 == s3)         #False

__hash__

每次执行hash值都会变化

在一次执行的过程中对同一个值的hash总是不变的

字典为什么寻找快？？

dic={'name':'wang','age':18,'sex':male}

字典在内存是如何存储的？　　　　为什么字典的key必须可hash

会把字典的值转化成哈希值，然后把对应的哈希值存储在内存中，每个哈希值只有一个内存地址，所以每次寻找的时候会根据哈希值直接在内存地址中找

hash 算法

对于相同的值在一次程序的运行中是不会变化的

对于不同的值在一次程序的运行中总是不同的

set 的去重机制

对每一个元素进行hash，计算出一个内存地址

到这个内存地址上查看：

　　如果内存地址中没有这个值　　就将这个值存在内存地址中

　　如果内存地址中有这个值　　那么就判断两个值是否相等：如果相等，就舍弃后面的值。。如果不相等，就二次寻址再找一个新的内存地址存储这个值

 

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 = ['zhao','qian','sun','li']
obj_lst = []
for i in range(100):
    name = name_lst[i % 4]
    obj = Staff(name,i,'male','history')
    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

序列化：把一个数据类型转化成字符串、bytes类型的过程就是序列化

序列化的理由：当你需要把一个数据类型存储在文件中

　　　　　　　当你需要把一个数据类型需要网络传输的时候

import json
stu = {'name': '小明', 'sex': 'male'}
ret = json.dumps(stu)    #序列化的过程
print(stu, type(stu))
print(ret, type(ret))
d = json.loads(ret)         #反序列化的过程
print(d, type(d))
#{'name': '小明', 'sex': 'male'} <class 'dict'>
#{"name": "\u5c0f\u660e", "sex": "male"} <class 'str'>
#{'name': '小明', 'sex': 'male'} <class 'dict'>

import json
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,type(d))
#[1, 2, 3, 4, 'aaa', 'bbb'] <class 'list'>
#[1, 2, 3, 4, "aaa", "bbb"] <class 'str'>
#[1, 2, 3, 4, 'aaa', 'bbb'] <class 'list'>

import json
dic = {'name':'小明','sex':'male'}
str_dic1 = s= json.dumps(dic,ensure_ascii=False)
print(str_dic1)          #{"name": "小明", "sex": "male"}
with open('json_file','w',encoding='utf-8')as f:
    f.write(str_dic1)
with open('json_file','r',encoding='utf-8')as f:
    content = f.read()
ret = json.loads(content)
print(ret['name'])      #小明
#ensure_ascii = Falese是在文件中显示中文，原本的是ascii码

dump load 这两个方法是完全和文件打交道的

可以多次向文件dump，但是不能多次load

import json
dic = {'name':'小明','sex':'male'}
with open('json_file','w',encoding='utf-8')as f:
    json.dump(dic,f,ensure_ascii =False)
with open('json_file','r',encoding='utf-8')as f:
    dic = json.load(f)
print(dic,dic['name'])
#{'name': '小明', 'sex': 'male'}  小明

json 的优点：所有的语言都通用

json 的缺点：只支持非常少的数据类型

　　　　　　对数据类型的约束很苛刻，字典的key必须是字符串

　　　　　　只支持：数字、字符串、列表、字典

dumps(dic/list)　　dic/list---->str　　序列化方法

loads(str)　　　　str--->dic/list　　反序列化方法

dump(dic/list,f)　　dic/list--->文件　　序列化方法

load(f)　　　　　　文件--->dic/list　　反序列方法  多次dump进入文件的数据load会报错

参数：ensure_ascii = False  希望序列化的中文能以中文的形式保存在文件中

json 格式化

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

pickle

与json类似

import pickle
class Sports:
    def __init__(self,name,price):
        self.name = name
        self.price = price
basketball = Sports('basketball',111)
soccer = Sports('soccer',99)
ret = pickle.dumps(basketball)
print(type(ret))       #<class 'bytes'>
p = pickle.loads(ret)
print(p.name,p.price)  #basketball 111


with open('pickle_file','wb')as f:
    pickle.dump(basketball,f)   #写入文件保存
with open('pickle_file','rb')as f:
    sports = pickle.load(f)
print(sports.name)        #basketball    取出

pickle：dump、load

　　操作文件必须以+b打开

　　在load的时候，如果这个要被load 的内容所在的类不在内存中，会报错

　　pickle 支持多次dump和多次load（需要异常处理）

#pickle 能不能多次 dump
def my_dump(course):
    with open('pickle','ab') as f:
        pickle.dump(course,f)
my_dump(python)
my_dump(linux)
my_dump(mysql)

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