7.28 多态 反射 元类

Posted 2022-05-24 powertips

多态

1.什么是多态

多态指的是一类事物有多种形态

例如:

动物有多种形态:

人，狗，猪

在程序中多态指的是,不同对象可以响应相同方法,并可以有自己不同的实现方式

2.为什么需要多态

案例分析:

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')
        
peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()
func(peo)
func(dog)
func(pig)

通过上述案列可以直观的体会到多态的好处,并且它并不是一个新的知识点,python默认就是支持多态的

那么多态的带来的好处是什么?

1.增加了程序的灵活性

　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

2.增加了程序额可扩展性

　　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　

class Cat(Animal): #动物的另外一种形态：猫
    def talk(self):
        print('say miao')
def func(animal): #对于使用者来说，自己的代码根本无需改动
    animal.talk()
cat1=Cat() #实例出一只猫
func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao
'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

继承一章中指出,继承为多态提供了不要的支持,所有的动物 cat dog pig 它们都要先继承Animal类,这样一来,才能保证,它们都能响应talk方法,不至于在调用时发生异常;

当然如果子类的设计者,完全按照Animal中规定的内容去实现子类,即使没有继承关系的存在,使用者也一样可以像使用其他对象一样使用这个子类对象, 这需要设计者在设计实现类时更加谨慎!

3.鸭子类型

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种标准来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例2：其实大家一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

反射

1 什么是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2.python中的反射

反射是所有面向对象编程语言都具备的功能

python中通过以下四个函数来实现反射

hasattr(object,name) # 判断对象是否拥有某个属性
setattr(object,name,value) #为对象增加新的属性
getattr(object,name,default) #从对象中获取某个属性
delattr(object,name) #从对象中删除某个属性

参数object可以是任意对象,包括类

3.为什么需要反射

一个类在定义的时候,可能一些属性的设计并不是很完美,而后期需要作出修改,或是增加新属性时,使用反射的方式可以不需要修改源代码

反射的另一个优势:可插拔设计(重点)

不仅限于修改已有的属性,通过反(反省)也能够发现已经存在的属性,只要你给我一个对象我就能检查其拥有的属性,从而使用这些属性,而不需要提前了解这些对象,这大大提高了程序的扩展性

4.如何使用

案例1:

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr
f1=FtpClient('192.168.1.1')
# 反射f1中的方法 如果存在就调用
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')

案例2:

动态导入模块

元类

1.什么是元类

一切源自于一句话：python中一切皆为对象。既然如此类是不是也是对象呢?

class Teacher(object):
    school='tsinghua'

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

    def say(self):
        print('%s says welcome to the Beijing' %self.name)
        
t1=Teacher('egon',18)
print(type(t1)) #查看对象t1的类是<class '__main__.Teacher'>

所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象t1是调用类Teacher得到的

一切皆对象的话 类也必然是一个对象,验证一下

tcls = Teacher
li = [Teacher]
def func(cls):
    print(cls)
func(Teacher)
#完全没问题把他当做对象来使用 和其他对象没有任何区别

思考,t1是通过Teacher实例化得到的,那Teacher对象是哪个类实例化的呢?

print(type(Teacher))
#<class 'type'>

可以推导出===>产生Teacher的过程一定发生了：Teacher=type(...)

用于实例化产生类的类称之为元类 就是此时的type类;**

Teacher是通过type实例化得到的,既然如此,是不是可以自己调用type来实例化一个calss呢?

2.创建类的流程分析

class关键字在帮我们创建类时，必然帮我们调用了元类Teacher=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是

1、类名class_name=‘Teacher‘

2、基类们class_bases=(object,)

3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的

调用type时会依次传入以上三个参数

自己来实例化一个类

class_name = "Teacher"
class_code = """
def __init__(self,name,age):
    self.name=name
    self.age=age
def say(self):
    print('%s says welcome to the Beijing' %self.name)
"""
class_dict = 
exec(class_code,None,class_dict)

bases = (object,)

Teacher = type(class_name,bases,class_dict)
print(Teacher)

综上，class关键字帮我们创建一个类应该细分为以下四个过程

1.获取类名

2.获取基类

3.获取名称空间

4.实例化元类得到类

总结:元类即 用于产生类的类

3.自定义元类控制类的创建

思考 如果我想高度定制一个类 该如何实现 例如要求所有方法名称必须小写,类名称必须大写开头等等

创建类是有type完成的 type中必然包含了创建了的具体代码, 现在需要对这些代码进行修改,两种方式

1.修改type源代码 不可取

2.创建新的元类 使用自己的元类来创建类 从而实现定制类

一个类没有声明自己的元类，默认他的元类就是type，除了使用内置元类type，我们也可以通过继承type

来自定义元类，然后使用metaclass关键字参数为一个类指定元类

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    pass
class Teacher(object,metaclass=Mymeta): # Teacher=Mymeta('Teacher',(object),...)
    school='tsinghua'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the Beijing' %self.name)

需求

1.规范类名必须大写

2.类中必须包含文档注释

class MyMate(type):
    def __init__(self,name,bases,dic):
        print("run")
        if not dic.get("__doc__"):
            raise TypeError("类必须有文档注释!")
        if not name.istitle():
            raise TypeError("类名必须大写开头!")
        super().__init__(name,bases,dic)
class Foo(object,metaclass=MyMate):
    pass

项目中的应用

在优酷系统中需要根据类的信息来生成创建表的语句; 必需知道类何时被创建了,使用元类可以轻松的拦截类的创建过程,获取类相关信息来生成建表语句

class MyMetaClass(type):
    def __init__(self,name,bases,dic):
        table_name = name
        columns = self.transfer_columns(dic)
        sql = "create table if not exists %s(%s)" % (table_name,columns)
        # 自动建表
        try:
            OBDB().conn.execute(sql)
        except Exception as e:
            pass
        super().__init__(name,bases,dic)
        
        
        
        
        
        
        
        
s = 10  == s = int
a = type("int")
b = a
b()
c.__class__

4.自定义元类控制类的调用

__call__函数得执行时机

该方法会在调用对象是自动触发执行 (对象加括号)

class Foo:
    def __call__(self, *args, **kwargs):
        print("run")
f = Foo() #调用Foo得到f对象
f()#调用对象时 触发__call__的执行

通常调用一个普通对象是没有意义的,那__call__在什么时候用呢?

我们说类也是一个对象,那么Foo()是不是也执行了Foo的类中的__call__函数呢?

Foo的类是谁呢? 默认是元类type,通过mateclass来指定为自定义的元类来测试

#测试
class M(type):
    def __call__(self, *args, **kwargs):
        print("run mateclass __call__")
        pass
    pass
class A(metaclass=M):
    pass
print(A())
#输出 run mateclass __call__
#输出 None

覆盖__call__函数时的注意事项

第一行输出表明了,调用类A时,的确自动执行了__call__函数,

第二行输出一个空,这是为什么呢? 将__call__注释起来,再次测试,会发打印结果变成了一个对象!

必须明确创建对象的过程: 先创建空对象,执行初始化将属性存储到对象的名称空间中!
所以在__call__函数中必须完成这两步操作,同时将初始化完成的对象返回给调用者

一旦覆盖了__call__函数,就必须自己来完成上述的几个步骤

class MyMate(type):
    def __call__(self, *args, **kwargs):
        # 创建空对象
        # 调用init
        # 返回初始化后的对象
        obj = object.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj
class Foo(metaclass=MyMate):
    def __init__(self):
        print("初始化对象")
f = Foo()
print(f)

通过元类来控制一个类实例化对象的过程

只需覆盖__call__函数我们就能完成对实例化过程的控制

#需求:
#2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
#3.key作为用户自定义类产生对象的属性，且所有属性变成大写
class Mymetaclass(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError('must use keyword argument for key function')
        obj = object.__new__(self) #创建对象，self为类Chinese

        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj
class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)
p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)

补充:

产生类Teacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是实现了__call__方法,但是我们就算自己写该方法,类也可以被创建,这是因为type中已经有默认的__call__的实现了
该方法中同样需要做至少三件事

#伪代码
 class type:
     def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
         obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象
         self.__init__(obj,*args,**kwargs) 
         return obj

5.元类实现单例

什么是单例

单例是指的是单个实例,指一个类只能有一个实例对象

为什么要用单例

当一个类的实例中的数据不会变化时使用单例,数据是不变的

例如开发一个音乐播放器程序,音乐播放器可以封装为一个对象,那你考虑一下,当你切歌的时候,是重新创建一个播放器,还是使用已有的播放器?

因为播放器中的数据和业务逻辑都是相同的没有必要创建新的,所以最好使用单例模式,以节省资源

当两个对象的数据完全相同时 则没有必要占用两份资源

#使用classmethod 实现单例
class Player():
    def __init__(self):
        print("创建播放器了")
    __play = None
    @classmethod
    def get_player(cls):
        if not cls.__play:
            cls.__play = Player()
        return cls.__play


p1 = Player.get_player();
p1 = Player.get_player();
p1 = Player.get_player();
p1 = Player.get_player();

该方法无法避免使用者直接调用类来实例化,这样就不是单例了

使用元类实现单例模式

#在类定义时 自动执行init 在init中创建实例 call中直接返回已有实例
class MyMeta(type):
    __instance = None

    def __init__(self,name,bases,dic):
        if not self.__instance:
            self.__instance = object.__new__(self)
            self.__init__(self.__instance)

        super().__init__(name, bases, dic)


    def __call__(cls):
        return cls.__instance

class Player(metaclass=MyMeta):
    def __init__(self):
        print("创建播放器了")
Player()
Player()
# 仅执行一次创建播放器

6.元类之属性查找

当一个类既有父类又有元类时属性的查找顺序是什么样的?

回顾一下,在没有元类时属性的查找是基于MRO列表的顺序,这个点还是相同的,那我们为某个类增加元类后,元类中的属性,什么时候会被使用到呢?来看一个例子

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    n=444
    def __new__(cls, *args, **kwargs):
        pass
class Bar(object):
    n = 333
    def __new__(cls, *args, **kwargs):
        pass
class Foo(Bar):
    n=222
    def __new__(cls, *args, **kwargs):
        pass
class Teacher(Foo,metaclass=Mymeta):
    n=111
    def __new__(cls, *args, **kwargs):
        pass
    school='Tsinghua'
print(Teacher.__new__)
print(Teacher.n)

测试结果表明:属性查找的顺序依然是遵循MRO列表顺序,当顶级类object中不存在时会查找元类,元类没有时查找元类的父类也就是type类,

7.令人迷惑的__new__函数与__init__函数

class M(type):
    def __init__(self,clsname,bases,namespace):
        print("init")
    def __call__(self, *args, **kwargs):
        pass
    pass
class A(metaclass=M):
    n = 1
    pass
print(A.__name__)
print(A.__bases__)
print(A.__dict__)
"""输出
init
A
(<class 'object'>,)
'__module__': '__main__', 'n': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None
"""

我们已经知道__init__可以控制类的创建过程,但是现在我们看到的是,init中没有任何代码但是类的三个基本信息已经都有了,这说明类的创建其实已经完成了

class M(type):
    def __new__(cls, *args, **kwargs):
        print("new")
        #return type.__new__(cls,*args,**kwargs)
    def __init__(self,clsname,bases,namespace):
        print("init")
class A(metaclass=M):
    n = 1
print(A.__name__)
print(A.__bases__)
print(A.__dict__)
"""输出
new
Traceback (most recent call last):
  File "/Users/jerry/PycharmProjects/元类属性查找.py", line 43, in <module>
    print(A.__name__)
AttributeError: 'NoneType' object has no attribute '__name__'"""

执行了__new__函数但是并没有执行__init__,因为__new__函数是真正用于创建类的方法,只有创建类成功了才会执行init函数,new必须要有返回值且返回值类型为__type__时才会执行__init__函数,

将__new__中被注释的代码打开 一切正常! 再一次印证了第四节中的伪代码

**总结:元类中__new__是用于创建类对象的 __init__是用于初始化类的其他信息的**