饮冰三年-人工智能-Python-18Python面向对象

1 类与实例对方法和属性的修改

class Chinese:
    # 这是一个Chinese的类
    #定义一个类属性，又称为静态数据或者静态变量，相当于C#中的static
    country="China"
    # 定义一个初始化函数，
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender
    #定义一个方法
    def play(self,ballName):
        print('%s 正在打 %s' %(self.name,ballName))

#1类属性
print("----------开始修改类属性")
#1.1 查看类属性
print(Chinese.country) #China
#1.2 修改类属性
Chinese.country="中华人民共和国"
print(Chinese.country) #中华人民共和国
#1.3 删除类属性
del Chinese.country
print(Chinese.__dict__)
#{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x0000000001D30EA0>, 'play': <function Chinese.play at 0x000000000247C7B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
#1.4 添加类属性
Chinese.country="中国"
print(Chinese.__dict__)
#{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x0000000002300EA0>, 'play': <function Chinese.play at 0x000000000250C7B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'country': '中国'}

#2方法属性
print("----------开始修改方法属性")
#2.1 查看方法属性
p1=Chinese('张三',18,"男")
Chinese.play(p1,'篮球') #张三 正在打 篮球
#2.2 修改方法属性
def play(self,ballName,address):
    print('%s 在%s打%s' %(self.name,address,ballName))
Chinese.play=play
Chinese.play(p1,'篮球','操场') #张三 在操场打篮球
#2.3 删除类属性
del Chinese.play
print(Chinese.__dict__)
#{'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x0000000001D40EA0>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'country': '中国'}
#2.4 添加方法
def eat(self,food):
    print("%s 正在吃 %s" %(self.name,food))
Chinese.eat=eat
print(Chinese.__dict__)
# {'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x0000000001D40EA0>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None, 'country': '中国', 'eat': <function eat at 0x0000000001DFC7B8>}

#3实例类属性
print("----------开始修改实例类属性")
#3.1 查看实例类属性
p=Chinese('张三',18,"男")
print(p.country) #中国
#3.2 修改实例类属性
p.country="中华人民共和国"
print(p.country) #中华人民共和国
#3.3 删除实例类属性
del p.country
print(p.__dict__)
#{'name': '张三', 'age': 18, 'gender': '男'}
# 3.4 添加类属性
p.country="中国"
print(p.__dict__)
#{'name': '张三', 'age': 18, 'gender': '男', 'country': '中国'}

print("----------开始修改实例属性")
#4.1 查看实例类属性
p=Chinese('张三',18,"男")
print(p.name) #张三
#4.2 修改实例类属性
p.name="张三三"
print(p.name) #张三三
#4.3 删除实例类属性
del p.name
print(p.__dict__)
#{'age': 18, 'gender': '男'}
# 4.4 添加类属性
p.name="张三三"
print(p.__dict__)
#{'age': 18, 'gender': '男', 'name': '张三三'}

print("----------开始修改实例方法")
#4.1 查看实例方法
p=Chinese('张三',18,"男")
p.eat('包子')
# 张三 正在吃 包子
#4.2 修改实例类属性
def eat(self,food,address):
    print('%s在%s吃%s' %(self.name,address,food))
p.eat=eat
p.name="张三三"
p.eat(p,"包子","食堂") #张三三在食堂吃包子
#4.3 删除实例类属性
del p.eat
print(p.__dict__)
#{'name': '张三三', 'age': 18, 'gender': '男'}
# 4.4 添加实例方法属性
def study(self,cont):
    print('%s学%s' % (self.name,cont))
p.study = study
p.study(p,'python')
print(p.__dict__)
#张三三学python
# {'name': '张三三', 'age': 18, 'gender': '男', 'study': <function study at 0x0000000002526B70>}

　　类是什么时候被加载的,以及类名是什么时候生效的？

　　　　创建一个类的空间，然后从上到下加载内容（属性、方法）。然后把这个命名空间指向类名。

　　

 　　为什么Chinese.play与p.play的内存地址不一样？

　　　　p.play其实存的不是func的内存地址，而是存着func内存地址的一个变量的地址。类似：Chinese.play存的是你的家庭地址。而p.play存的是地址簿的第二页。　　　　

2 静态属性、静态方法、类方法

class Room:
    owner="China"
    # 这是一个房间的类
    def __init__(self,name,width,length,height):
        self.name=name
        self.width=width
        self.length =length
        self.height=height
    @property
    # 这是一个方法，但是通过@property装饰后，就变成了一个静态方法，可以通过.方法名调用
    def getArea(self):
        return self.width*self.length
    @classmethod
    # 这是一个方法，但是通过@classmethod装饰后，就变成了一个类方法，可以类调用，不用实例化
    def getOwner(cls):
        print("房产所有者"+cls.owner)
    @staticmethod
    # 这是一个方法，但是通过@staticmethod装饰后，就变成了一个静态方法，可以在调用处直接传递参数
    # 用户输入想要的面积和折扣，可以计算出价格
    def getPrice(area,discount):
       return area*20000*discount/10

r1=Room("天字一号房",10,20,2)
print('房间面积'+str(r1.getArea)) #房间面积200
#类方法：可以通过类名直接调用方法
Room.getOwner() #房产所有者China
#静态方法，可以传递一些与类关联不大的数据
print(r1.getPrice(r1.getArea,9)) #3600000.0

总结：

静态属性 @property	静态方法 @staticmethod	类方法 @classmethod
只读的，可以当属性使用	和类有关，和参数关系不密切	一个cls参数
实例.func	实例.func()	类.func()，类实例.func()

3 组合（大类包含小类） 什么有什么的关系

class School:
    # 这是一个学校类
    def __init__(self,name,address):
        self.name=name
        self.address=address
class Courses:
    # 这是一个课程类,组合了一个学校
    def __init__(self, name, cycle,price,schoolObj):
        self.name = name
        self.cycle = cycle
        self.price = price
        self.school = schoolObj
    def getInfo(self):
        print('%s 正在开设 %s' %(self.school.name,self.name))
school = School('北大','北京')
Courses('python','100','10',school).getInfo()

4 继承（子类继承父类） 什么是什么的关系

#继承一：抽象出共有的父类，实现继承
class Animal:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s会吃' %(self.name))
    def bark(self):
        print('%s会叫' %self.name)
class Dog(Animal):
    pass
class Cat(Animal):
    pass

dog=Dog("小黄")
dog.bark()
cat = Cat("伊丽莎白")
cat.eat()
#继承二：但是猫和狗的叫声不同，所以常用的是接口继承（父类只提供一个规范，子类在调用时需要实现这些规范）
# 如果是抽象方法，子类必须实现
import abc
class Animal(metaclass=abc.ABCMeta):
    def __init__(self,name):
        self.name=name
    @abc.abstractclassmethod
    def eat(self):
        print('%s会吃' %(self.name))
    def bark(self):
        print('%s会叫' %self.name)
class Dog(Animal):
    def bark(self):
        print('%s会汪汪叫' %self.name)
    #如果是抽象方法，子类必须实现
    def eat(self):
        pass
class Cat(Animal):
    def eat(self):
        print('%s会吃鱼儿' %self.name)

dog=Dog("小黄")
dog.bark()
cat = Cat("伊丽莎白")
cat.eat()

　　4.1 继承顺序

　　当类是经典类（class C1:）时，多继承情况下，深度优先（依次找到根节点）

　　当类是新式类（class C1(object):）时，多继承情况下，广度优先（最后一次才找到根节点）

　　原理：python会计算一个方法解析顺序（MRO）列表，可通过print(类名.__mro__)查看

　　4.2 子类中调用父类的方法

class Vehicle:
    def __init__(self,name,speed,load):
        self.name=name
        self.speed = speed
        self.load = load
    def run(self):
        print('%s开始启动' %(self.name))

class Subway(Vehicle):
    def __init__(self,name,speed,load,line):
        Vehicle.__init__(self,name,speed,load)
        self.line = line
    def run(self):
        Vehicle.run(self)
        print("时速："+self.speed)
class Car(Vehicle):
    # 使用super减少了self字段的传递，而且如果父类类名修改的话，子类继承不用改变
    def __init__(self,name,speed,load,brand):
        super().__init__(name,speed,load)
        self.brand = brand
    def run(self):
        super().run()
        print("品牌："+self.brand)

#测试数据
sub=Subway("地铁","300km/h","20000","2号线")
sub.run()

cr=Car("汽车","80km/h","5","红旗")
cr.run()

 5 多态

　　类的继承有两成意义：改变+扩展。多态就是累的这两层意义的一个具体的实现机制。在不考虑实例（子类）类型的情况下，使用子类。即调用不同的实例化对象下的相同方法，时间的过程不同

class H2O:
    def __init__(self,name,temp):
        self.name=name
        self.temp = temp
    def currentStatus(self):
        if self.temp < 0:
            print("在101.325kPa下,当前状态为：冰")
        elif self.temp == 0:
            print("在101.325kPa下,当前状态可能是：冰水混合物")
        elif self.temp < 100:
            print("在101.325kPa下,当前状态为：水")
        elif self.temp > 100:
            print("在101.325kPa下,当前状态为：水蒸气")
class Ice(H2O):
    pass
class Water(H2O):
    pass
class Steam(H2O):
    pass

ice = Ice("冰",-10)
water = Water("水",10)
steam= Steam("水蒸气",101)

ice.currentStatus();water.currentStatus();steam.currentStatus();

 6 封装 明确区分内外，其实不能真正不被外部访问。内部实现逻辑，外部无需知晓，并且为封装到内部的逻辑提供一个供外部访问的接口　　

　约定：_开头定义

　__开头，其实在外部调用的时候python默认修改了名“_类名_定义名“

class People:
    _plate="地球"
    def __init__(self,name,age):
        self.name=name
        self._age=age

p=People("张三",12)
print(p._plate) #地球
print(p._age)   #12
'''虽然以_开头但是还可以被访问到，因为这只是一种约定'''
class People2:
    __plate="地球"
    def __init__(self,name,age):
        self.name=name
        self.__age=age

p=People2("张三",12)
#print(p.__plate) #报错 AttributeError: 'People2' object has no attribute '__plate'
print(p._People2__plate)  #地球
print(p._People2__age)   #12
'''虽然以__开头不可以被直接访问到，但可以通过“_+类名+自定义名称'''
class People3:
    __plate="地球"
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    # 外部现在是无法通过属性名调用了，但是目前有一个需求：就是要获取年龄，这个时候还可以通过定义接口的方法实现
    def getAge(self):
        return self.__age;
p3=People3("张三",12)
print(p3.getAge())

没有必要的封装，不可取

7 反射：自省，自己检测自己。主要指程序可以访问、检测和修改它本身状态或行为的一种能力。

　　　　用字符串类型的变量名来访问变量值。类似XX.YY 这种形式，都可以通过反射来访问。类、对象、模块

# 反射：自省，自己检测自己。主要指程序可以访问、检测和修改它本身状态或行为的一种能力
class Animal:
    able="Run"
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s会吃' %(self.name))
    def bark(self):
        print('%s会叫' %self.name)
a1=Animal("Dog")
print(a1.name)
print(a1.__dict__["name"])
# a1.name 等价于 a1.__dict__["name"]
# 1 hasattr(object,name) 判断object中有没有一个name字符串对应的方法或属性
print(hasattr(a1,'able')) #True
print(hasattr(a1,'eat')) #True
print(a1.__dict__)  #{'name': 'Dog'}
# 虽然__dict__中没有eat方法，但是，这里只是检查能否调用到
# 2 getattr(object,name) 等价于 a1.属性或方法  获取对应的方法或属性
print(getattr(a1,'able')) #Run
print(getattr(a1,'eat')) #<bound method Animal.eat of <__main__.Animal object at 0x0000000002564630>>
# 如果没有就报错，通过默认参数的方法可以不报错
print(getattr(a1,'11111',"该属性不存在"))
print(getattr(a1,'2222',"该方法不存在"))
# 3 getattr(object,k,v) 等价于 a1.属性或方法=''  判断设置对应的方法或属性
setattr(a1,'able2','run')  #创建
setattr(a1,'able','drink') #修改
print(getattr(a1,'able')) #drink
print(getattr(a1,'able2')) #run
# 4 delattr(object,k,v) 删除对应的方法或属性
delattr(a1,'able')

# 反射：自省，自己检测自己。主要指程序可以访问、检测和修改它本身状态或行为的一种能力
class Animal:
    able="Run"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print('%s会吃' %(self.name))
    def bark(self):
        print('%s会叫' %self.name)

    def __getattr__(self, item):
        print("调用__getattr__(self, item)方法")
    # __setattr__()方法不常用，但可以通过重写该方法，实现自己特殊的需求，如类型只能是字符串
    def __setattr__(self, key, value):
        if key.strip()=="name":
            if type(value) is str:
                self.__dict__[key] = value
            else:
                print("name必须是字符串")
        else:
            self.__dict__[key] = value
    def __delattr__(self,item):
        self.__dict__.pop(item)
a1=Animal("Dog",12)
# __开头表示内置属性
# 修改属性
a1.__setattr__('name',15)
print(a1.__dict__) #{'name': 'Dog', 'age': 12}
del a1.name #调用__delattr__(self, item)方法
# 只有在属性不存在的时候会触发__getattr__
print(a1.abccccc)

# 导入其他模块进行反射
import pkage1.say as p

print(hasattr(p,"sayHello"))
print(getattr(p,"sayHello111","不存在"))

# 反射可以使代码更灵活，易于扩展
# Why？因为反射可以根据字符串去获取、访问变量

class Manager:
    # 定义成操作列表，列表的优势是可以通过下标索引来访问
    OPERATE_DIC = [
        ('创建班级', 'create_class'),
        ('创建课程', 'create_course'),
        ('创建学生', 'create_student'),
    ]

    def __init__(self, name):
        self.name = name

    def create_class(self):
        print("创建班级")

    def create_course(self):
        print("创建课程")

    def create_student(self):
        print("创建学生")


class Student:
    OPERATE_DIC = [
        ('选择班级', 'choose_class'),
        ('选择课程', 'choose_course'),
    ]

    def __init__(self, name):
        self.name = name

    def choose_class(self):
        print("选择班级")

    def choose_course(self):
        print("选择课程")


def login():
    userName = input("账号：")
    pwd = input("密码：")
    with open("用户表") as f:
        for line in f:
            user, password, role = line.strip().split("|")
            if user == userName and password == pwd:
                return user, role
        else:
            print("用户不存在")


def main():
    user, role = login()
    if user and role:
        print("欢迎%s：%s" % (role, user))
        # 根据用户角色反射出用户类--开始
        # 1：自己文件反射需要引入包
        import sys
        # 2：根据字符串去获取文件中的类（灵活的判断是Manager还是Student）
        cls = getattr(sys.modules["__main__"], role)
        # 3：根据类创建对象
        obj = cls(user)
        op_dic = obj.OPERATE_DIC
        # 4: 有了对象，调用发方法
        while True:
            #enumerate方法是将op_dic 组合为一个索引序列，同时列出数据和数据下标
            for num,i in enumerate(op_dic,1):
                print(num,i)
            chooseNum= int(input("请输入操作序号："))
            # 根据用户输入的操作序号，获取相应的操作方法名，字符串
            op_fun = op_dic[chooseNum-1][1]
            #通过对象的反射，对象.方法名 ；调用
            getattr(obj,op_fun)()
main()

# 反射场景：
# 表：网关、夜灯、呼叫器、上下线记录表
# 关系：一个网关下有多个夜灯、呼叫器，子表中通过（网关的id）关联网关表，
#       所有的设备（网关、夜灯、呼叫器）的上下线记录都会存储在上下线记录表中（设备id，设备类型）
#  我们根据记录表中的设备id要反向关联出是设备的详细信息，如何处理。
  from deviceApp import models as TModel
# 首先定义一个枚举类型（light【设备类型，网关表中存储的数据】，"NightLightDevice" Model类中的名字）
# @unique
# class DeviceType(Enum):
#     # 定义设备类型，根据设备类型对应不同
#     light = "NightLightDevice"
#     gate = "GatewayDevice"
#     call = "CallbuttonDevice"
    
    
    
#     deviceType = request['deviceType']  # 设备产品  例如call
# # 1. 根据deviceType关联枚举类型，利用反射获取相应的model类
#    cls = getattr(TModel, DeviceType[deviceType].value, None)
#    if cls:
#        # 如果model类存在，根据主键id，找到对应的设备实体
#        child_device_obj = cls.objects.get(id=deviceId)
#    else:
#        return failResultJson(msg='getattr-TModel对象失败')

8 二次加工标准类型

# 方法1，通过继承实现
class ListYK(list):
    # 添加一个新方法，求取中间值
    def show_middle(self):
        mid_index=int(len(self)/2)
        return self[mid_index]

    # 重写一个添加方法，只能添加字符串
    def append(self,p_object):
        if type(p_object) is str:
            # list.append(self,p_object)
            super().append(p_object)
l1=ListYK("hello")
print(l1.show_middle()) #l
l1.append("1")
l1.append(2)
print(l1) #['h', 'e', 'l', 'l', 'o', '1']

# 2授权：授权时包装的一个特性，包装一个类型通常是对已存在的类型的一些定制
# 授权的过程，及时所有更新的功能都是有新类的某部分来处理，但已存在的功能就授权给队形的默认属性
import time
class OpenNew:
    def __init__(self,filename,mode='r',encoding="utf-8"):
        self.file=open(filename,mode,encoding=encoding)
        self.filename=filename
        self.mode = mode
        self.encoding = encoding
    def __getattr__(self, item):
        return getattr(self.file,item)
    def write(self,line):
        t = time.strftime('%Y-%m-%d %T')
        self.file.write('%s %s' % (t, line))
f1=OpenNew("a.txt","w+","utf-8")
f1.write("111
")
f1.write("222")

9 __new__

class Single:
     def __new__(cls, *args, **kwargs):
         obj = object.__new__(cls)     #类名() 调用了new方法，开辟可一个空间给obj。
         print("init中的self：", obj)
         return obj
     def __init__(self):
         print("init中的self：",self)
sin=Single()

# 输出结果，
# init中的self： <__main__.Single object at 0x00CDA930>
# init中的self： <__main__.Single object at 0x00CDA930>

# 结论：line 8 ：类名() 调用了new方法，开辟可一个空间给obj。
#       然后把obj的空间给self。#       
#       line 6 ：执行__init__ 方法
#       最后把空间给调用者sin

class Single:
    ISINCTANCE=None
    def __new__(cls, *args, **kwargs):
        if not cls.ISINCTANCE:
            cls.ISINCTANCE = object.__new__(cls)
        return cls.ISINCTANCE

    def __init__(self, *args, **kwargs):
        pass


a = Single()
print(a)
b = Single()
print(b)

''' 输出结果
<__main__.Single object at 0x00F5FE70>
<__main__.Single object at 0x00F5FE70>
'''
# 结论，先定义属性，new的时候判断该属性是否有值，如果有值返回。没有值再new值

10 __getattribute__与__getattr__

#__getattribute__与__getattr__

# 1:只有__getattr__存在的情况下，只有获取的属性不存在，才触发此方法

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def getInfo(self):
        return "My name is %s,I am %s years old" % (self.name, self.age)
    def __getattr__(self,item):
        print("我是__getattr")

f = Foo("Mr.zhang", 18)
f.name
f.agea  #只有属性不存在的时候，才会触发

class Foo2:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def getInfo(self):
        return "My name is %s,I am %s years old" % (self.name, self.age)
    def __getattribute__(self, item):
        print("我是__getattribute__")

f2 = Foo2("Mr.zhang", 18)
f2.name
f2.agea
#不管是否存在，都会触发__getattribute__方法
class Foo3:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def getInfo(self):
        return "My name is %s,I am %s years old" % (self.name, self.age)

    def __getattribute__(self, item):
        print("我是__getattribute__")
        raise AttributeError("属性不存在，就会触发getattr方法")
    def __getattr__(self, item):
        print("我是__getattr")
print("F3=======>")
f3 = Foo3("Mr.zhang", 18)
f3.name
f3.agea
# 不管是否存在，都会触发__getattribute__方法,当都_getattribute__方法抛出AttributeError异常时，触发__getattr__方法

11 __item__

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def getInfo(self):
        return "My name is %s,I am %s years old" % (self.name, self.age)
    def __getitem__(self, item):
        print("我是__getitem__方法")
        return self.__dict__[item]
    def __setitem__(self, key, value):
         self.__dict__[key]=value
    def __delitem__(self, key):
        self.__dict__.pop(self.__dict__[key])


f = Foo("Mr.zhang", 18)
print(f["name"])
f["age"]="12"
print(f["age"])
del  f.age
print(f.__dict__)
'''
我是__getitem__方法
Mr.zhang
我是__getitem__方法
12
{'name': 'Mr.zhang'}
'''

12 __str__与__repr__

# 注意：这两个方法的返回值必须是字符串
# 如果__str__没有定义，那么就会__repr__替代
class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return ("我叫%s 今年%s岁了" %(self.name,self.age))

    def __repr__(self):
        return ("我今年%s岁了 叫%s " % (self.age,self.name))

f=Foo("杨可",26)
print(f)
#str函数或者print函数 --》obj.__str__()
#repr或者交互式解释器--》obj.__repr__()
#如果__str__没有被定义，那么就会使用__repr__来代替

13 __len__

class Student:
    def __len__(self):
        return len(self.name)
    def __init__(self,name):
        self.name=name

st=Student("张三")
print(len(st))
st=Student("尼古拉斯赵四儿")
print(len(st))

14 __hash__

class Employee:
    def __init__(self, name, sex, age, dept):
        self.name = name
        self.sex = sex
        self.age = age
        self.dept = dept

    def __hash__(self):
        return hash('%s%s' % (self.name, self.sex))

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True


employ_lst = []
for i in range(1000):
    if i % 3 == 0:
        employ_lst.append(Employee('张三', 'male', i, 'python'))
    elif i % 3 == 1:
        employ_lst.append(Employee('李四', 'male', i, 'python'))
    else:
        employ_lst.append(Employee('王五', 'male', i, 'python'))
employ_newList = set(employ_lst)
for i in employ_newList:
    print(i.name, i.sex, i.age)
'''
1：定义一个员工类（Employee）
2：对象的属性 : 姓名 性别 年龄 部门
3：重写__hash__方法
4：重写__eq__方法
5：初始化数据
6：set去重
'''

'''输出结果
李四 male 1
张三 male 0
王五 male 2
'''

15 查看实例的来源

from pkage1.Foo import Foo

f = Foo()
print(f.__module__)
print(f.__class__)
# pkage1.Foo
# <class 'pkage1.Foo.Foo'>

16 析构函数

class Foo:
    def __init__(self,name):
        self.name=name
    def __del__(self):
        print("析构函数")
f = Foo("zhangsan")
del f

17 __call__    利用 ()可以执行

class Foo:
    def __call__(self, *args, **kwargs):
        print("实例执行了call方法")
f=Foo()
f()
# 实例执行了call方法

class Foo:
    def __call__(self, *args, **kwargs):
        print("实例执行了call方法")


class Foooo:
    def __init__(self,cls):
        self.c=cls()  #实例化传递过来的cls，也就是Foo
        self.c()    # ()调用Foo中的__call__ 方法

Foooo(Foo)

18 迭代器协议

# 迭代器协议：有一个iter方法，有一个next方法，有Stopiteration终止
class Foo:

    def __init__(self,x,prv=0,cur=1):
        self.x=x
        self.prv = prv
        self.cur = cur
    def __iter__(self):
        return self
    def __next__(self):
        if self.x>100:
            raise StopIteration("越界了")
        self.x =  self.prv + self.cur
        self.prv =self.cur
        self.cur= self.x
        return self.cur
f =Foo(10)
print(f.__next__())
print(next(f))

print("====>")
for i in f:
    print(i)

# 1
# 2
# ====>
# 3
# 5
# 8
# 13
# 21
# 34
# 55
# 89
# 144

 19 上下文管理协议

# 上下文管理协议
# with obj as  f 等同于 f=obj.__enter__()
# 执行代码块
# 一：没有异常，整个代码块运行完毕后触发__exit__,它的三个参数都为None
# 二：出现异常，直接触发__exit__
#     a：如果__exit__的返回值为True，代表吞掉了异常
#     b：如果__exit__的返回值不为True，代表吐出来异常
#     c：__exit__的运行完毕，代表整个with语句执行完毕
class OpenNew:
    def __init__(self,name):
        self.name = name
    def __enter__(self):
        print('执行enter')
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("执行exit方法")
        print("3")
        print(aa)
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        print("4")
        return True
with OpenNew("a.txt") as  f:
    print('1')
    print('2')
print('5')

20 描述符

#描述符协议：描述符本质就是一个新式类，至少实现了__get__(),__set__(),__delete__()中的至少一个
# __get__(),调用属性时触发
# __set__(),为属性赋值是触发
# __delete__()，删除属性时触发
# 描述符作用：可以用来定义一个类的属性，
# 描述符的特性:由该类产生的实例变化时候不会调用这些个方法,定义另外一个属性时,会被调用
# 描述符分类：没有实现__set__()的叫非数据描述符，实现了__set__()和__get__()的叫数据描述符
# 注意事项：1：描述符本身和被代理类都是新式类，2：定义成类的属性，，不能定义到构造函数中
#定义一个描述符
class StrNew:
    def __get__(self, instance, owner):
        print("Str调用__get__")
    def __set__(self, instance, value):
        print("Str调用__set__")
    def __delete__(self, instance):
        print("Str调用__delete__")
class IntNew:
    def __get__(self, instance, owner):
        print("Int调用__get__")
    def __set__(self, instance, value):
        print("Int调用__set__")
    def __delete__(self, instance):
        print("Int调用__delete__")
class People:
    name=StrNew()
    age=IntNew()
    def __init__(self,name,age):
        self.name=name
        self.age=age
p=People('张三',15)
p.name
p.name="张三New"
del  p.name
p.age
p.age=15
del p.age

# 优先级
# 1：类属性>2：数据描述符>3:实例属性>4：非数据描述符>5：找不到属性触发__getattr__()
# print("1：类属性>2：数据描述符")
# People.name #调用类属性name 本质是调用描述符__get__()方法
# People.name="zhangsan" #它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的
# del People.name

print("2：数据描述符>3:实例属性")
p=People('张三',15)
p.name="lisi"
print(p.__dict__)  #{}
# 与实例相关的属性字典中没有name，因为name是一个数据描述符，优先级高于实例属性，操作都是跟描述符有关，与实例无关了

# python 是弱类型，可以通过描述将其设置为强类型
# 定义一个类型控制的描述符
class TypeControl:
    # 定义一个构造函数，用于初始化，字段名称（根据名称对其进行设置）和类型（设置值是做判断）
    def __init__(self,name,typeName):
        self.name=name
        self.typeName = typeName
    def __get__(self, instance, owner):
        print("调用__get__")
        return instance.__dict__[self.name]
    def __set__(self, instance, value):
        print("调用__set__")
        # //如果设置值的属性和定义的属性不一致，报错
        if not isinstance(value,self.typeName):
            raise TypeError
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print("调用__delete__")
        instance.__dict__.pop(self.name)

class People:
    name=TypeControl("name",str)
    age=TypeControl("age",int)
    def __init__(self,name,age):
        self.name=name
        self.age=age

p=People('张三',15)
p.name
del p.name

p=People('1',1)
p.name
del p.name

21 装饰器

# 装饰器=高阶函数+函数嵌套+闭包
# 高阶函数：传入参数或输出结果是一个函数
# 函数嵌套：函数中定义函数
import time
# 添加一个参数，如果参数是n就打n折
def disCount(n=1):
    def timmer(func):
        def wrapper(*args,**kwargs):
            startTime= time.time()
            res=func(*args,**kwargs)*n;
            endTime= time.time()
            print("今天是国庆节，每位客户打的折扣为："+str(n*10))
            return  res
        return wrapper
    return timmer
#@timmer  #语法糖，相当于#test=timmer(test)
@disCount(n=0.9)
def test(a,b):
    return a+b

print(test(100,200))

# 定义一个用户列表
userList=[{"name":"zhangsan","pwd":"333"},{"name":"lisi","pwd":"444"},{"name":"wangwu","pwd":"555"}]
currentUser={"name":"None","loginState":"False"}
def SignOut():
    currentUser = {"name": "None", "loginState": "False"}

def authority(func):
    def wapper(*args,**kwargs):
        if currentUser["name"] and eval(currentUser["loginState"]):
            res = func(*args,**kwargs)
            return res
        else:
            SignIn();
    return wapper
def index():
    print("欢迎来到登录页面")
@authority
def home():
    print("欢迎回家%s" %currentUser["name"])
@authority
def shopping_car():
    print("%s的购物车中有：苹果、葡萄。" %currentUser["name"])

def SignIn():
    print("请先登录")
    userName = input('用户名：').strip()
    userPwd = input('密码：').strip()
    for userInfo in userList:
        if userInfo["name"] == userName and userInfo["pwd"] == userPwd:
            currentUser["name"] = userName
            currentUser["loginState"] = "True"
    if currentUser["name"] and eval(currentUser["loginState"]):
        print("登录成功,")
    else:
        print("用户名或密码错误")
        SignIn()
index()
home()
shopping_car()

class TypeControl:
    # 定义一个构造函数，用于初始化，字段名称（根据名称对其进行设置）和类型（设置值是做判断）
    def __init__(self,name,typeName):
        self.name=name
        self.typeName = typeName
    def __get__(self, instance, owner):
        print("调用__get__")
        return instance.__dict__[self.name]
    def __set__(self, instance, value):
        print("调用__set__")
        # //如果设置值的属性和定义的属性不一致，报错
        if not isinstance(value,self.typeName):
            raise TypeError
        instance.__dict__[self.name]=value
    def __delete__(self, instance):
        print("调用__delete__")
        instance.__dict__.pop(self.name)

def typeAssert(**kwargs):
    def decorateClass(cls):
        for name,expected_type in kwargs.items():
            setattr(cls,name,TypeControl(name,expected_type)) #People.name = TypeControl('name',str)
        return cls
    return decorateClass

#传递字典参数，运行typeAssert(),返回decorateClass
# 继续执行@decorateClass
# 执行@decorateClass给类添加属性
@typeAssert(name=str,age=int)
class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

p=People('张三',15)
p.name
del p.name

22 自定义Property属性

class myProperty:
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        # 描述符中调用func函数
        # 直接用类调用会由于instance是None，导致运行func()报错
        if instance is None:
            return self
        return self.func(instance)
class Room:
    def __init__(self,name,length,width):
        self.name=name
        self.length=length
        self.width = width
    @myProperty #getArea=myProperty(getArea)
    def getArea(self):
        return self.width*self.length
r1=Room("卧室",6,4)
print(r1.getArea)
print(Room.getArea)
# 思路@myProperty相当于getArea=myProperty(getArea)
#1：定义一个getArea=myProperty(getArea)
#2：其中定义一个构造函数，接收传递过来的函数名并返回，相当于类的装饰器功能
#3：要想通过.方法名掉用方法。需要通过描述符（3:实例属性>4：非数据描述符）

class myProperty:
    def __init__(self,func):
        self.func=func
    def __get__(self, instance, owner):
        print("get")
        # 描述符中调用func函数
        # 直接用类调用会由于instance是None，导致运行func()报错
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res
class Room:
    def __init__(self,name,length,width):
        self.name=name
        self.length=length
        self.width = width
    @myProperty #getArea=myProperty(getArea)
    def getArea(self):
        return self.width*self.length
r1=Room("卧室",6,4)
print(r1.getArea)
print(Room.getArea)
print("=======>懒加载，只调用一次，原理：把getArea添加到r1的数据字典中，然后直接从字典中获取")
print(r1.getArea)
print(r1.getArea)
print(r1.getArea)

# 思路@myProperty相当于getArea=myProperty(getArea)
#1：定义一个getArea=myProperty(getArea)
#2：其中定义一个构造函数，接收传递过来的函数名并返回，相当于类的装饰器功能
#3：要想通过.方法名掉用方法。需要通过描述符（3:实例属性>4：非数据描述符）

 23 元类

# 我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类（元类可以简称为类的类），内置的元类为type
# print(type(Foo)) # 结果为<class 'type'>，证明是调用了type这个元类而产生的Foo，即默认的元类为type
#
# class关键字在帮我们创建类时，必然帮我们调用了元类OldboyTeacher=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是
# 1、类名class_name='Foo'
# 2、基类们class_bases=(object,)
# 3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的
# 调用type时会依次传入以上三个参数
class MyType(type):
    def __init__(self):
        print("")
    def __call__(self, *args, **kwargs):
        # 此时self 是Foo，
        #object.__new__(self) 相当于以Foo为类创建对象，即：产生f1
        obj=object.__new__(self)
        #调用Foo下面的init方法
        self.__init__(self,*args, **kwargs)
class Foo(metaclass=MyType):
    def __init__(self,name):
        self.name=name

 24 总结

• 面向对象的过程
  • 1 开辟一个空间__new__()，属于对象的
  • 2 把对象的空间传递给self，执行__init__()方法
  • 3 把对象空间返还给调用者
• 内置方法、双下方法、魔术方法 
  • 1 格式：__方法名__
  • 内置函数和类的内置方法之间联系紧密
  • 常见的内置方法有 __new__ __init__ __call__ __str__...
• set去重原理
  • set() 函数中会先调用对象的 __hash__() 方法，获取 hash 结果；
  • 如果 hash 结果相同，用比较操作符 == （也就是调用函数 __eq__()）判断二者的值是否相等；
  • 如果都相等，去重；否则，set() 认为二者不同，两个都保留到结果中。