深入类和对象

川长思鸟来 2023-02-20 07:28 21阅读 0赞

# 深入类和对象 #

### 鸭子类型和多态 ###

##### 鸭子类型： #####

*  多态的概念是应用于Java和C\#这一类强类型语言中

*  动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用，这就是动态语言的鸭子类型，并不要求严格的继承体系，一个对象只要“看起来像鸭子，走路像鸭子”，就可以看做是鸭子。

a = [1,2]
    b = [2,3]
    c = (5,6)
    d = "avd"
    a.extend(b)
    print(a)
    a = [1,2]
    a.extend(c)# extend()扩展方法
    print(a)
    a = [1,2]
    a.extend(d)
    print(a)

变量1.extend(变量2)函数表示扩展变量的值，将变量2中的值扩展到变量1中并且类型转换成变量1的类型。  
无返回值

# 运行结果如下
    [1, 2, 2, 3]
    [1, 2, 5, 6]
    [1, 2, 'a', 'v', 'd']

*  多态：定义时的类型和运行时的类型不一样，就称为是多态。

class cat(object):
    	def info(self):
    		print('i am cat')
    class dog(object):
    	def info(self):
    		print('i am dog')
    class duck(object):
    	def info(self):
    		print('i am duck')
    animal_list = [cat,dog,duck]
    for animal in animal_list:
    	animal().info()

鸭子类型在运行之前cat都是在\[cat,dog,duck\]列表的里面被当作是变量，当运行的时候，只有加上()调用info()才明确cat是一个类

i am cat
    i am dog
    i am duck

### 抽象基类(abc模块) ###

##### 抽象基类介绍 #####

抽象基类就是类里定义了纯虚成员函数的类，纯虚函数只提供了接口，并没有具体的实现，抽象基类不能呗实例化(不能创建对象)，通常是作为基类供子类继承，子类中重写虚函数，实现具体的接口。  
抽象基类就是定义各种方法而不做具体实现的类，任何继承自抽象基类的类必须实现这些方法，否则无法实例化。

*  抽象基类应用场景

> 我们去检查某个类是否含有某种方法  
> 我们需要强调某个子类必须实现某些方法

*  1.检查某个类中是否含有某个方法

> 定义Demo类，类中含有\_\_len\_\_魔法方法  
> 导入抽象基类中的Sized类

''' abc模块：文件命名时不要以abc.py为模块名称 '''
    class demo(object):
        def __init__(self,li):
            self.li = li
        def __len__(self):
            return len(self.li)
    l = ['c','5','ghjkl']
    d = demo(l)
    # print(d)# 返回的是demo对象所在的地址<__main__.demo object at 0x000001F0DE70DD48>
    print(len(d))# 会触发__len__魔法方法会return len(self.li)
    # 如何判断demo中是否含有__len__魔法方法
    print(hasattr(d,"__len__"))# 判断d的内部是否含有__len__魔法方法，返回为True
    # 2.导入抽象基类中的Sized类
    from collections.abc import Sized
    # 判断d是否是Sized这个类
    print(isinstance(d,Sized))# d是Sized的类
    ''' 可以通过判断d是否是Sized这个子类，然后进一步判断d这个类是否含有__len__魔法方法 '''

3
    True
    True

注意：抽象基类虽然可以成为别的类的父类，但是别的类并不会继承抽象基类的方法和属性

*  2.强制某个子类必须实现父类的某些方法  
    例子：  
    定义父类Cache,并且封装CURD方法，强制子类重写该方法  
    重写方法前：

class CacheBase(object):
        def dele(self):
            raise NotImplementedError
        def crea(self):
            raise NotImplementedError
    class RedisBase(CacheBase):
        ''' 1.子类如果不重写父类方法访问时直接抛出异常 '''
        pass
    r = RedisBase()
    r.crea()# NotImplementedError
    r.dele()

File "E:\code\代码\python\python代码\1.py", line 66, in crea
        raise NotImplementedError

重写方法后：

class CacheBase(object):
        def dele(self):
            raise NotImplementedError
        def crea(self):
            raise NotImplementedError
    class RedisBase(CacheBase):
        ''' 1.子类如果不重写父类方法访问时直接抛出异常 '''
        def crea(self):
            print('create')
        def dele(self):
            print('dele')
    r = RedisBase()
    r.crea()
    r.dele()

create
    dele

定义一个子类Redis

import abc
    # 不是直接继承object，而是继承abc.ABCMeta
    class CacheBase(metaclass = abc.ABCMeta):
        @abc.abstractmethod
        def dele(self):
            pass
        def crea(self):
            pass
    class RedisBase(CacheBase):
        def crea(self):
            pass
        def dele(self):
            pass
    r = RedisBase()
    ''' 抽象基类：在实例化的时候检测 主动抛出异常：调用时才会检测 '''

### type和isinstance的区别 ###

type()不考虑继承关系  
isinstance()考虑继承关系

a = 1
    b = 'hjkl;'
    help(isinstance)
    print(isinstance(a,(int,str)))# 返回的是一个布尔值，可以引入一个元组，运行的是or运算
    help(type)
    print(type(a))# 说明是int类型

Help on built-in function isinstance in module builtins:
    
    isinstance(obj, class_or_tuple, /)
        Return whether an object is an instance of a class or of a subclass thereof.
    
        A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
        check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
        or ...`` etc.
    
    True
    Help on class type in module builtins:
    
    class type(object)
     |  type(object_or_name, bases, dict)
     |  type(object) -> the object's type
     |  type(name, bases, dict) -> a new type
     |
     |  Methods defined here:
     |
     |  __call__(self, /, *args, **kwargs)
     |      Call self as a function.
     |
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |
     |  __dir__(self, /)
     |      Specialized __dir__ implementation for types.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __instancecheck__(self, instance, /)
     |      Check if an object is an instance.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |
     |  __sizeof__(self, /)
     |      Return memory consumption of the type object.
     |
     |  __subclasscheck__(self, subclass, /)
     |      Check if a class is a subclass.
     |
     |  __subclasses__(self, /)
     |      Return a list of immediate subclasses.
     |
     |  mro(self, /)
     |      Return a type's method resolution order.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __prepare__(...)
     |      __prepare__() -> dict
     |      used to create the namespace for the class statement
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  __new__(*args, **kwargs)
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __abstractmethods__
     |
     |  __dict__
     |
     |  __text_signature__
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __base__ = <class 'object'>
     |      The most base type
     |
     |  __bases__ = (<class 'object'>,)
     |
     |  __basicsize__ = 864
     |
     |  __dictoffset__ = 264
     |
     |  __flags__ = 2148291584
     |
     |  __itemsize__ = 40
     |
     |  __mro__ = (<class 'type'>, <class 'object'>)
     |
     |  __weakrefoffset__ = 368
    
    <class 'int'>

class Father(object):
        pass
    class Son(Father):
        pass
    ls = Son()
    print(isinstance(ls,Son))
    print(isinstance(ls,Father))# isinstance考虑到了继承的关系
    print(type(ls) is Son)
    print(type(ls) is Father)# type()并不考虑继承关系
    print(f'Son_id:{id(Son)},Father_id:{id(Father)}')
    ''' is和==的区别 is是否引用同一个对象 ==判断值是否相等 '''

True
    True
    True
    False
    Son_id:2605524088920,Father_id:2605524094584

### 多继承 ###

##### 类属性和实例属性 #####

###### 基本查找顺序 ######

*  对象是可以向上进行查找，所以可以访问到类属性(当对象自己有该实例属性时，则输出是自己的)
 *  类不可以向下进行查找，所以只可以访问到类属性

class father(object):
        # 类属性
        cls_ins = 1
        def __init__(self,a,b):
            # 实例属性
            self.a = a
            self.b = b
            # self.cls_ins = 456789
    zs = father(3,4)
    print(zs.cls_ins,zs.a,zs.b)
    #print(father.a)
    father.cls_ins = 567890# 相当于覆盖
    zs.cls_ins = 456789# 相当于封装,在__init__方法中添加了一个实例属性
    print(father.cls_ins)
    print(zs.cls_ins)
    ''' 对象可以向上查找可以访问到类属性 类不可以向下查找所以只可以访问到类属性 '''

1 3 4
    567890
    456789

class mytest(object):
        ins = 'cls_ins'
        def __init__(self):
            self.ins = 'ins'
    t = mytest()
    print(mytest.ins)
    print(t.ins)
    ''' 当对象自己有该实例属性的时候，就直接输出自己的实例属性 当对象自己没有该属性的时候才会向类中查找 '''

cls_ins
    ins

###### 多继承查询顺序 ######

该多继承的执行顺序如何？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70_pic_center]  
MRO算法，DFS（深度优先）  
该菱形继承的执行顺序如何？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70_pic_center 1]  
在python2中引入了BFS（广度优先），在python新式类，引入了C3算法，通过className.\_\_mro\_\_来查看

# 菱形继承
    class d(object):
        pass
    class c(d):
        pass
    class b(d):
        pass
    class a(b,c):
        pass
    print(a.__mro__)

(<class '__main__.a'>, <class '__main__.b'>, <class '__main__.c'>, <class '__main__.d'>, <class 'object'>)

### python对象的自省机制 ###

自省是通过一定的机制查询到对象的内部结构  
python中比较常见的自省机制(函数用法)有：dir() type() hasattr() isinstance(),通过这些函数，我们可以在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性

class person(object):
        name = '灰太狼'
    class student(person):
        def __init__(self,school_name):
            self.school_name = school_name
    htl = student('fghjkl')
    print(htl.__dict__)# {'school_name': 'fghjkl'}当前对象的属性，返回的是字典{'属性':'当前属性的值'}
    print(dir(htl))# 返回的是一个列表，考虑了所有的成员，考虑到了继承的关系

{ 'school_name': 'fghjkl'}
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'school_name']

### super()函数 ###

多继承下，super函数查询父类的顺序如何？

class A(object):
        def __init__(self):
            print('A')
    class B(A):
        def __init__(self):
            print('B')
            # 重写父类的构造方法，在调用父类的方法
            super().__init__()
    b = B()

B
    A

class person(object):
        def __init__(self,name,age,weight):
            self.name = name
            self.age = age
            self.weight = weight
        def speak(self):
            print(f'{self.name}说:我{self.age}岁')
    class student(person):
        def __init__(self,name,age,weight,grade):
            #self.name = name
            #self.age = age
            #self.weight = weight
            # 软编码->父类的名字可以随便更改
            super().__init__(name,age,weight)
            # 硬编码
            # person.__init__(self,name,age,weight)
            self.grade = grade
        def speak(self):
            print(f'{self.name}说:我{self.age}岁,我在{self.grade}年级')
    s = student('erg',20,123,2)
    s.speak()

erg说:我20岁,我在2年级

class A(object):
        def __init__(self):
            print('A')
    class C(A):
        def __init__(self):
            print('C')
            super().__init__()
    class B(A):
        def __init__(self):
            print('B')
            super().__init__()
    class D(B,C):
        def __init__(self):
            print('D')
            super().__init__()
    if __name__ == '__main__':
        d = D()
        print(D.__mro__)

D
    B
    C
    A
    (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/2020101610522828.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201016104927150.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjcxNzMy,size_16,color_FFFFFF,t_70#pic_center