17、Python面向对象高级

2023-08-28 15:02:52

一、isinstance和issubclass

type()：不会认为子类实例是一种父类类型；
isinstance()：认为子类实例是一种父类类型。
issubclass()：判断是否为其子类。

class Foo(object):

    pass

class Bar(Foo):

    pass

print(type(Foo()) == Foo)

# True

print(type(Bar()) == Foo)

# False

# isinstance参数为对象和类

print(isinstance(Bar(), Foo))

# True

print(issubclass(Bar, Foo))

# True

print(issubclass(Foo, object))

# True

二、反射(hasattr和getattr和setattr和delattr)

1、反射在类中的使用

反射就是通过字符串来操作类或者对象的属性。反射本质就是在使用内置函数，其中反射有以下四个内置函数：

hasattr：判断一个方法是否存在与这个类中
getattr：根据字符串去获取obj对象里的对应的方法的内存地址，加"()"括号即可执行
setattr：通过setattr将外部的一个函数绑定到实例中
delattr：删除一个实例或者类中的方法

class People:

    country = 'China'

    def __init__(self, name):

        self.name = name

    def eat(self):

        print('%s is eating' % self.name)

peo1 = People('nick')

print(hasattr(peo1, 'eat'))  # peo1.eat

# True

print(getattr(peo1, 'eat'))  # peo1.eat

# <bound method People.eat of <__main__.People object at 0x1043b9f98>>

print(getattr(peo1, 'xxxxx', None))

# None

setattr(peo1, 'age', 18)  # peo1.age=18

print(peo1.age)

# 18

print(peo1.__dict__)

# {'name': 'egon', 'age': 18}

delattr(peo1, 'name')  # del peo1.name

print(peo1.__dict__)

# {'age': 18}

2、反射在模块中的使用

动态导入一个模块__import__，并且动态输入函数名然后执行相应功能。

注意：getattr,hasattr,setattr,delattr对模块的修改都在内存中进行，并不会影响文件中真实内容。

# dynamic.py

imp = input("请输入模块:")

commons = __import__(imp)  # 等价于import imp

# commons = __import__(imp, fromlist=True)  # 模块名可能不是在本级目录中存放着,改用这种方式就能导入成功

inp_func = input("请输入要执行的函数：")

f = getattr(commons, inp_func, None)  # 作用:从导入模块中找到你需要调用的函数inp_func,然后返回一个该函数的引用.没有找到就烦会None

f()  # 执行该函数

r = hasattr(commons, 'age')  # 判断某个函数或者变量是否存在

print(r)

setattr(commons, 'age', 18)  # 给commons模块增加一个全局变量age = 18，创建成功返回none

setattr(commons, 'age', lambda a: a + 1)  # 给模块添加一个函数

delattr(commons, 'age')  # 删除模块中某个变量或者函数

3、实例：基于反射机制模拟web框架路由

需求：比如我们输入<www.xxx.com/commons/f1> ，返回f1的结果。

# 动态导入模块，并执行其中函数

url = input("url: ")

target_host,target_module, target_func = url.split('/')

m = __import__('aaa.' + target_module, fromlist=True)

inp = url.split("/")[-1]  # 分割url,并取出url最后一个字符串

if hasattr(m, inp):  # 判断在commons模块中是否存在inp这个字符串

    inp= getattr(m, inp)  # 获取inp的引用

    inp()  # 执行

else:

    print("404")

三、getattr、setattr和delattr和getattribute事件

__getattr__：只有在使用点调用属性且属性不存在的时候才会触发。比较有用
__delattr__：删除属性的时候会触发
__setattr__：添加/修改属性会触发它的执行
当你自己写__getattr__、__delattr__、__setattr__方法，系统会调用你写的方法，如果没写，系统调用默认

class Foo:

    x = 1

    def __init__(self, y):

        self.y = y

    def __getattr__(self, item):

        print('----> from getattr:你找的属性不存在')

    def __setattr__(self, key, value):

        print('----> from setattr')

        # self.key = value  # 这就无限递归了,你好好想想

        # self.__dict__[key] = value  # 应该使用它

    def __delattr__(self, item):

        print('----> from delattr')

        # del self.item  # 无限递归了

        self.__dict__.pop(item)

f1 = Foo(10)

# ----> from setattr

print(f1.__dict__ )  # 因为你重写了__setattr__，凡是赋值操作都会触发它的运行，你啥都没写，就是根本没赋值。除非你直接操作属性字典，否则永远无法赋值

# {}

f1.z = 3

# ----> from setattr

print(f1.__dict__)

# {}

f1.__dict__['a'] = 3  # 我们可以直接修改属性字典，来完成添加/修改属性的操作（不会触发__setattr__）

del f1.a

# ----> from delattr

print(f1.__dict__)

# {}

getattribute

查找属性无论是否存在，都会执行。

class Foo:

    def __init__(self, x):

        self.x = x

    def __getattribute__(self, item):

        print('不管是否存在，我都会执行')

f1 = Foo(10)

f1.x

# 不管是否存在，我都会执行

f1.xxxxxx

# 不管是否存在，我都会执行

当__getattribute__与__getattr__同时存在，只会执行__getattrbute__，除非__getattribute__在执行过程中抛出异常AttributeError

class Foo:

    def __init__(self, x):

        self.x = x

    def __getattr__(self, item):

        print('执行的是我')

        # return self.__dict__[item]

    def __getattribute__(self, item):

        print('不管是否存在,我都会执行')

        raise AttributeError('哈哈')

f1 = Foo(10)

f1.x

# 不管是否存在,我都会执行

# 执行的是我

f1.xxxxxx

# 不管是否存在,我都会执行

# 执行的是我

四、setitem和getitem和delitem__

__setitem__:中括号赋值时触发
__getitem__:中括号取值时触发
__delitem__：中括号删除时触发
__delattr__：.删除时触发

class Foo:

    def __init__(self, name):

        self.name = name

    def __getitem__(self, item):

        print('getitem执行', self.__dict__[item])

    def __setitem__(self, key, value):

        print('setitem执行')

        self.__dict__[key] = value

    def __delitem__(self, key):

        print('del obj[key]时，delitem执行')

        self.__dict__.pop(key)

    def __delattr__(self, item):

        print('del obj.key时，delattr执行')

        self.__dict__.pop(item)

f1 = Foo('sb')

f1['age'] = 18

# setitem执行

f1['age1'] = 19

# setitem执行

f1['age']

# getitem执行 18

f1['name'] = 'tank'

# setitem执行

del f1.age1

# del obj.key时，delattr执行

del f1['age']

# del obj[key]时，delitem执行

print(f1.__dict__)

# {'name': 'tank'}

五、format：自定制格式化字符串

date_dic = {

    'ymd': '{0.year}:{0.month}:{0.day}',

    'dmy': '{0.day}/{0.month}/{0.year}',

    'mdy': '{0.month}-{0.day}-{0.year}',

}

class Date:

    def __init__(self, year, month, day):

        self.year = year

        self.month = month

        self.day = day

    def __format__(self, format_spec):

        # 默认打印ymd的{0.year}:{0.month}:{0.day}格式

        if not format_spec or format_spec not in date_dic:

            format_spec = 'ymd'

        fmt = date_dic[format_spec]

        return fmt.format(self)

d1 = Date(2016, 12, 29)

print(format(d1))

# 2016:12:29

print('{:mdy}'.format(d1))

# 12-29-2016

六、del：析构方法

会在对象被删除之前自动触发

class People:

    def __init__(self, name, age):

        self.name = name

        self.age = age

        self.f = open('test.txt', 'w', encoding='utf-8')

    def __del__(self):

        print('run======>')

        # 做回收系统资源相关的事情

        self.f.close()

obj = People('egon', 18)

del obj  # del obj会间接删除f的内存占用，但是还需要自定制__del__删除文件的系统占用

# run=-====>

七、slots

使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的，而每个实例的是独立的)。

__slots__是一个类变量，变量值可以是列表，元祖，或者可迭代对象，也可以是一个字符串(意味着所有实例只有一个数据属性)

字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__。

class Foo:

    __slots__ = 'x'

f1 = Foo()

f1.x = 1

f1.y = 2  # 报错

print(f1.__slots__ )  # f1不再有__dict__

当你定义__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。使用__slots__后不能再给实例添加新的属性了，只能使用在__slots__中定义的那些属性名。

注意：__slots__的很多特性都依赖于普通的基于字典的实现。另外，定义了__slots__后的类不再支持一些普通类特性了，比如多继承。

大多数情况下，你应该只在那些经常被使用到的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象。

class Bar:

    __slots__ = ['x', 'y']

n = Bar()

n.x, n.y = 1, 2

n.z = 3  # 报错

八、doc：返回类的注释信息

class Foo:

    '我是描述信息'

    pass

print(Foo.__doc__)

# 我是描述信息

该属性无法被继承

class Foo:

    '我是描述信息'

    pass

class Bar(Foo):

    pass

print(Bar.__doc__)  # 该属性无法继承给子类

# None

九、call：会在调用对象时自动触发。

构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者类()()

class Foo:

    def __init__(self):

        print('__init__触发了')

    def __call__(self, *args, **kwargs):

        print('__call__触发了')

obj = Foo()  # 执行 __init__

# __init__触发了

obj()  # 执行 __call__

# __call__

十、init和new：类构造器

__new__方法的第一个参数是这个类，而其余的参数会在调用成功后全部传递给__init__方法初始化。

__new__方法（第一个执行）先于__init__方法执行：

class A:

    pass

class B(A):

    def __new__(cls):

        print("__new__方法被执行")

        return super().__new__(cls)

    def __init__(self):

        print("__init__方法被执行")

b = B()

# __new__方法被执行

# __init__方法被执行

绝大多数情况下，我们都不需要自己重写__new__方法，但在当继承一个不可变的类型（例如str类,int类等）时，它的特性就尤显重要了。我们举下面这个例子：

# 1、使用init的情况：

class CapStr1(str):

    def __init__(self, string):

        string = string.upper()

a = CapStr1("I love China!")

print(a)

# I love China!   无变化 ！！！！！！！

# 2、使用__new__的情况

class CapStr2(str):

    def __new__(cls, string):

        string = string.upper()

        return super().__new__(cls, string)

a = CapStr2("I love China!")

print(a)

# I LOVE CHINA!

十一、str和repr

str：执行str函数或print函数触发

class Foo:

    def __init__(self, name, age):

        """对象实例化的时候自动触发"""

        self.name = name

        self.age = age

    def __str__(self):

        print('打印的时候自动触发，但是其实不需要print即可打印')

        return f'{self.name}:{self.age}'  # 如果不返回字符串类型，则会报错

obj = Foo('nick', 18)

print(obj)  # obj.__str__() # 打印的时候就是在打印返回值

# 打印的时候自动触发，但是其实不需要print即可打印

# nick:18

repr：执行repr函数或者交互式解释器触发

如果__str__没有被定义，那么就会使用__repr__来代替输出。
注意：这俩方法的返回值必须是字符串，否则抛出异常。

class School:

    def __init__(self, name, addr, type):

        self.name = name

        self.addr = addr

        self.type = type

    def __repr__(self):

        return 'School(%s,%s)' % (self.name, self.addr)

    def __str__(self):

        return '(%s,%s)' % (self.name, self.addr)

s1 = School('oldboy1', '北京', '私立')

print('from repr: ', repr(s1))

# from repr:  School(oldboy1,北京)

print('from str: ', str(s1))

# from str:  (oldboy1,北京)

print(s1)

# (oldboy1,北京)

s1  # jupyter属于交互式

# School(oldboy1,北京)

十二、module和class

__module__ 表示当前操作的对象在那个模块
__class__表示当前操作的对象的类是什么

# lib/aa.py

class C:

    def __init__(self):

        self.name = 'SB'

# index.py

from lib.aa import C

obj = C()

print(obj.__module__)  # 输出 lib.aa，即：输出模块

print(obj.__class__)  # 输出 lib.aa.C，即：输出类

十三、实现文件上下文管理(enter和exit)

with语句，即上下文管理协议，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法。

使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处。

__exit__()中的三个参数分别代表异常类型，异常值和追溯信息。with语句中代码块出现异常，则with后的代码都无法执行。

class Open:

    def __init__(self, name):

        self.name = name

    def __enter__(self):

        print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):

        print('with中代码块执行完毕时执行我啊')

        print(exc_type)

        print(exc_val)

        print(exc_tb)

try:

    with Open('a.txt') as f:

        print('=====>执行代码块')

        raise AttributeError('***着火啦，救火啊***')

except Exception as e:

    print(e)

# 出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量

# =====>执行代码块

# with中代码块执行完毕时执行我啊

# <class 'AttributeError'>

# ***着火啦，救火啊***

# <traceback object at 0x1065f1f88>

# ***着火啦，救火啊***

如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行。

class Open:

    def __init__(self, name):

        self.name = name

    def __enter__(self):

        print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):

        print('with中代码块执行完毕时执行我啊')

        print(exc_type)

        print(exc_val)

        print(exc_tb)

        return True

with Open('a.txt') as f:

    print('=====>执行代码块')

    raise AttributeError('***着火啦，救火啊***')

print('0' * 100)  # ------------------------------->会执行

# 出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量

# =====>执行代码块

# with中代码块执行完毕时执行我啊

# <class 'AttributeError'>

# ***着火啦，救火啊***

# <traceback object at 0x1062ab048>

# 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

#

模拟open

class Open:

    def __init__(self, filepath, mode='r', encoding='utf-8'):

        self.filepath = filepath

        self.mode = mode

        self.encoding = encoding

    def __enter__(self):

        # print('enter')

        self.f = open(self.filepath, mode=self.mode, encoding=self.encoding)

        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):

        # print('exit')

        self.f.close()

        return True

    def __getattr__(self, item):

        return getattr(self.f, item)

with Open('a.txt', 'w') as f:

    print(f)

    f.write('aaaaaa')

    f.wasdf  #抛出异常，交给__exit__处理

# <_io.TextIOWrapper name='a.txt' mode='w' encoding='utf-8'>

十四、描述符(get和set和delete)

描述符是可以实现大部分python类特性中的底层魔法，包括@classmethod，@staticmethd，@property甚至是__slots__属性。

描述符是很多高级库和框架的重要工具之一，描述符通常是使用到装饰器或者元类的大型框架中的一个组件。

描述符本质就是一个新式类，在这个新式类中，至少实现了__get__()，__set__()，__delete__()中的一个，这也被称为描述符协议

__get__()：调用一个属性时，触发
__set__()：为一个属性赋值时，触发
__delete__()：采用del删除属性时，触发

描述符的作用是用来代理另外一个类的属性的。包含这三个方法的新式类称为描述符，由这个类产生的实例进行属性的调用/赋值/删除，并不会触发这三个方法

class Foo:

    def __get__(self, instance, owner):

        print('触发get')

    def __set__(self, instance, value):

        print('触发set')

    def __delete__(self, instance):

        print('触发delete')

f1 = Foo()

f1.name = 'nick'

f1.name

del f1.name

#无任何输出结果！！！

必须把描述符定义成这个类的类属性，不能定义到构造函数中。

class ST:

    """描述符Str"""

    def __get__(self, instance, owner):

        print('Str调用')

    def __set__(self, instance, value):

        print('Str设置...')

    def __delete__(self, instance):

        print('Str删除...')

class IN:

    """描述符Int"""

    def __get__(self, instance, owner):

        print('Int调用')

    def __set__(self, instance, value):

        print('Int设置...')

    def __delete__(self, instance):

        print('Int删除...')

class People:

    name = ST()

    age = IN()

    def __init__(self, name, age):  # name被ST类代理，age被IN类代理

        self.name = name

        self.age = age

p1 = People('alex', 18)

# Str设置...

# Int设置...

p1.name  # Str调用

p1.name = 'nick'  # Str设置...

del p1.name  # Str删除...

p1.age  # Int调用

p1.age = 18  # Int设置...

del p1.age  # Int删除...

print(p1.__dict__)  # {}

print(People.__dict__)

# {'__module__': '__main__', 'name': <__main__.ST object at 0x0000000002167490>, 'age': <__main__.IN object at 0x000000000234A700>, '__init__': <function People.__init__ at 0x00000000023A4280>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

print(type(p1) == People)  # True

print(type(p1).__dict__ == People.__dict__)  # True

1、使用描述符

众所周知，python是弱类型语言，即参数的赋值没有类型限制，下面我们通过描述符机制来实现类型限制功能。

class Typed:

    def __init__(self, name, expected_type):

        self.name = name

        self.expected_type = expected_type

    def __get__(self, instance, owner):

        print('get--->', instance, owner)

        if instance is None:

            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):

        print('set--->', instance, value)

        if not isinstance(value, self.expected_type):

            raise TypeError('Expected %s' % str(self.expected_type))

        instance.__dict__[self.name] = value

    def __delete__(self, instance):

        print('delete--->', instance)

        instance.__dict__.pop(self.name)

class People:

    name = Typed('name', str)

    age = Typed('name', int)

    salary = Typed('name', float)

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

try:

    p1 = People(123, 18, 3333.3)

except Exception as e:

    print(e)

# set---> <__main__.People object at 0x1082c7908> 123

# Expected <class 'str'>

try:

    p1 = People('nick', '18', 3333.3)

except Exception as e:

    print(e)

# set---> <__main__.People object at 0x1078dd438> nick

# set---> <__main__.People object at 0x1078dd438> 18

# Expected <class 'int'>

p1 = People('nick', 18, 3333.3)

# set---> <__main__.People object at 0x1081b3da0> nick

# set---> <__main__.People object at 0x1081b3da0> 18

# set---> <__main__.People object at 0x1081b3da0> 3333.3

2、类的装饰器:无参

def decorate(cls):

    print('类的装饰器开始运行啦------>')

    return cls

@decorate  # 无参：People = decorate(People)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1 = People('nick', 18, 3333.3)

# 类的装饰器开始运行啦------>

3、类的装饰器:有参

def typeassert(**kwargs):

    def decorate(cls):

        print('类的装饰器开始运行啦------>', kwargs)

        return cls

    return decorate

@typeassert( name=str, age=int, salary=float)  # 有参：1.运行typeassert(...)返回结果是decorate，此时参数都传给kwargs 2.People=decorate(People)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

p1 = People('nick', 18, 3333.3)

# 类的装饰器开始运行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}

4、描述符与类装饰器结合使用

class Typed:

    def __init__(self, name, expected_type):

        self.name = name

        self.expected_type = expected_type

    def __get__(self, instance, owner):

        print('get--->', instance, owner)

        if instance is None:

            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):

        print('set--->', instance, value)

        if not isinstance(value, self.expected_type):

            raise TypeError('Expected %s' % str(self.expected_type))

        instance.__dict__[self.name] = value

    def __delete__(self, instance):

        print('delete--->', instance)

        instance.__dict__.pop(self.name)

def typeassert(**kwargs):

    def decorate(cls):

        print('类的装饰器开始运行啦------>', kwargs)

        for name, expected_type in kwargs.items():

            setattr(cls, name, Typed(name, expected_type))

        return cls

    return decorate

@typeassert(name=str, age=int,  salary=float)  # 有参：1.运行typeassert(...)返回结果是decorate，此时参数都传给kwargs 2.People=decorate(People)

class People:

    def __init__(self, name, age, salary):

        self.name = name

        self.age = age

        self.salary = salary

print(People.__dict__)

# 类的装饰器开始运行啦------> {'name': <class 'str'>, 'age': <class 'int'>, 'salary': <class 'float'>}

# {'__module__': '__main__', '__init__': <function People.__init__ at 0x00000000023C4280>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, 'name': <__main__.Typed object at 0x000000000238F8B0>, 'age': <__main__.Typed object at 0x000000000238FF40>, 'salary': <__main__.Typed object at 0x000000000238FFA0>}

p1 = People('nick', 18, 3333.3)

# set---> <__main__.People object at 0x0000000001E07490> nick

# set---> <__main__.People object at 0x0000000001E07490> 18

# set---> <__main__.People object at 0x0000000001E07490> 3333.3

5、利用描述符原理自定制@property

实现延迟计算（本质就是把一个函数属性利用装饰器原理做成一个描述符：类的属性字典中函数名为key，value为描述符类产生的对象）

class Lazyproperty:

    def __init__(self, func):

        self.func = func

    def __get__(self, instance, owner):

        print('这是我们自己定制的静态属性，r1.area实际是要执行r1.area()')

        if instance is None:

            return self

        else:

            print('--->')

            value = self.func(instance)

            setattr(instance, self.func.__name__, value)  # 计算一次就缓存到实例的属性字典中

            return value

class Room:

    def __init__(self, name, width, length):

        self.name = name

        self.width = width

        self.length = length

    @Lazyproperty  # area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符'

    def area(self):

        return self.width * self.length

r1 = Room('alex', 1, 2)

print(r1.area)  # 先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法

# 这是我们自己定制的静态属性，r1.area实际是要执行r1.area()

# --->

# 2

print(r1.area)  # 先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

# 2

6、自定制@classmethod

class ClassMethod:

    def __init__(self, func):

        self.func = func

    def __get__(self, instance, owner):  # 类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,

        def feedback(*args, **kwargs):

            print('在这里可以加功能啊...')

            return self.func(owner, *args, **kwargs)

        return feedback

class People:

    name = 'nick'

    @ClassMethod  # say_hi=ClassMethod(say_hi)

    def say_hi(cls, msg):

        print('你好啊,帅哥 %s %s' % (cls.name, msg))

People.say_hi('你是那偷心的贼')

p1 = People()

# 在这里可以加功能啊...

# 你好啊,帅哥 nick 你是那偷心的贼

p1.say_hi('你是那偷心的贼')

# 在这里可以加功能啊...

# 你好啊,帅哥 nick 你是那偷心的贼

7、自定制@staticmethod

class StaticMethod:

    def __init__(self, func):

        self.func = func

    def __get__(self, instance, owner):  # 类来调用，instance为None，owner为类本身，实例来调用，instance为实例，owner为类本身

        def feedback(*args, **kwargs):

            print('在这里可以加功能啊...')

            return self.func(*args, **kwargs)

        return feedback

class People:

    @StaticMethod  # say_hi = StaticMethod(say_hi)

    def say_hi(x, y, z):

        print('------>', x, y, z)

People.say_hi(1, 2, 3)

# 在这里可以加功能啊...

# ------> 1 2 3

p1 = People()

p1.say_hi(4, 5, 6)

# 在这里可以加功能啊...

# ------> 4 5 6

十五、元类(metaclass)

元类:负责产生该对象的类称之为元类，即元类可以简称为类的类

用class关键字创建一个类，用的默认的元类type，因此以前说不要用type作为类别判断

class People:  # People=type(...)

    country = 'China'

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def eat(self):

        print('%s is eating' % self.name)

print(type(People))

<class 'type'>

1、type实现

创建类的3个要素：类名，基类，类的名称空间
People = type(类名，基类，类的名称空间)

class_name = 'People'  # 类名

class_bases = (object,)  # 基类

class_dic = {}  # 类的名称空间

class_body = """

country='China'

def __init__(self,name,age):

    self.name=name

    self.age=age

def eat(self):

    print('%s is eating' %self.name)

"""

exec(class_body, {}, class_dic, )  #执行class_body中的代码，然后把产生的名字丢入class_dic字典中

print(class_name)  # People

print(class_bases)  # (<class 'object'>,)

print(class_dic)  # 类的名称空间

# {'country': 'China', '__init__': <function __init__ at 0x10a0bc048>, 'eat': <function eat at 0x10a0bcd08>}

People1 = type(class_name, class_bases, class_dic)

print(People1)  # <class '__main__.People'>

obj1 = People1(1, 2)

obj1.eat()  # 1 is eating

2、自定义元类控制类

自定义元类控制类的产生过程，类的产生过程其实就是元类的调用过程。

分析用class自定义类的运行原理（而非元类的的运行原理）：

拿到一个字符串格式的类名class_name='People'
拿到一个类的基类们class_bases=(obejct,)
执行类体代码，拿到一个类的名称空间class_dic={...}
调用People=type(class_name,class_bases,class_dic)

class Mymeta(type):  # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

    def __init__(self, class_name, class_bases, class_dic):

        print('self:', self)  # 现在是People

        print('class_name:', class_name)

        print('class_bases:', class_bases)

        print('class_dic:', class_dic)

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类type的功能

class People(object, metaclass=Mymeta):  # People=Mymeta(类名,基类们,类的名称空间)

    country = 'China'

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def eat(self):

        print('%s is eating' % self.name)

# self: <class '__main__.People'>

# class_name: People

# class_bases: (<class 'object'>,)

# class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': <function People.__init__ at 0x000000000234EF70>, 'eat': <function People.eat at 0x0000000002352040>}

应用：我们可以控制类必须有文档。

class Mymeta(type):  # 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类

    def __init__(self, class_name, class_bases, class_dic):

        if class_dic.get('__doc__') is None or len(

                class_dic.get('__doc__').strip()) == 0:

            raise TypeError('类中必须有文档注释，并且文档注释不能为空')

        if not class_name.istitle():

            raise TypeError('类名首字母必须大写')

        super(Mymeta, self).__init__(class_name, class_bases,   class_dic)  # 重用父类的功能

try:

    class People(object, metaclass=Mymeta ):  # People  = Mymeta('People',(object,),{....})

        #     """这是People类"""

        country = 'China'

        def __init__(self, name, age):

            self.name = name

            self.age = age

        def eat(self):

            print('%s is eating' % self.name)

except Exception as e:

    print(e)

# 类中必须有文档注释，并且文档注释不能为空

3、自定义元类控制类的实例化

类的调用，即类实例化就是元类的调用过程，可以通过元类Mymeta的__call__方法控制。

继承的查找顺序:子类->Class –>object–> Mymeta->type

class Mymeta(type):

    def __call__(self, *args, **kwargs):

        print(self)  # self是People

        print(args)  # args = ('nick',)

        print(kwargs)  # kwargs = {'age':18}

        # return 123

        # 1. 先造出一个People的空对象，申请内存空间

        # __new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。

        obj = self.__new__(self)  # 虽然和下面同样是People，但是People没有，找到的__new__是父类的

        # 2. 为该对空对象初始化独有的属性

        self.__init__(obj, *args, **kwargs)

        # 3. 返回一个初始化好的对象

        return obj

class People(object, metaclass=Mymeta):  # People = Mymeta()，People()则会触发__call__

    country = 'China'

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def eat(self):

        print('%s is eating' % self.name)

#     在调用Mymeta的__call__的时候，首先会找自己（如下函数）的，自己的没有才会找父类的

#     def __new__(cls, *args, **kwargs):

#         # print(cls)  # cls是People

#         # cls.__new__(cls) # 错误，无限死循环，自己找自己的，会无限递归

#         obj = super(People, cls).__new__(cls)  # 使用父类的，则是去父类中找__new__

#         return obj

obj = People('nick', age=18)

# <class '__main__.People'>

# ('nick',)

# {'age': 18}

print(obj.__dict__)

# {'name': 'nick', 'age': 18}

4、练习：使用元类修改属性为隐藏属性

class Mymeta(type):

    def __init__(self, class_name, class_bases, class_dic):

        # 加上逻辑，控制类Foo的创建

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)

    def __call__(self, *args, **kwargs):

        # 加上逻辑，控制Foo的调用过程，即Foo对象的产生过程

        obj = self.__new__(self)

        self.__init__(obj, *args, **kwargs)

        # 修改属性为隐藏属性

        obj.__dict__ = {

            '_%s__%s' % (self.__name__, k): v

            for k, v in obj.__dict__.items()

        }

        return obj

class Foo(object, metaclass=Mymeta):  # Foo = Mymeta(...)

    def __init__(self, name, age, sex):

        self.name = name

        self.age = age

        self.sex = sex

obj = Foo('nick', 18, 'male')

print(obj.age)  # 'Foo' object has no attribute 'age'

print(obj.__dict__)

# {'_Foo__name': 'egon', '_Foo__age': 18, '_Foo__sex': 'male'}

5、利用元类实现单例模式

NAME = 'nick'

AGE = 18

class Mymeta(type):

    def __init__(self,class_name,class_bases,class_dict):

        super().__init__(class_name,class_bases,class_dict)

        self.__instance = self(NAME,AGE)

    def __call__(self,*args,**kwargs):

        if len(args) == 0 and len(kwargs) == 0:

            return self.__instance

        obj = object.__new__(self)

        self.__init__(obj,*args,**kwargs)

        return obj

class People(metaclass=Mymeta):

    def __init__(self,name,age):

        self.name = name

        self.age = age

peo1 = People()

peo2 = People()

下载视频

码农公寓

一、isinstance和issubclass

二、反射(hasattr和getattr和setattr和delattr)

1、反射在类中的使用

2、反射在模块中的使用

3、实例：基于反射机制模拟web框架路由

三、__getattr__、__setattr__和__delattr__和__getattribute__事件

__getattribute__

四、__setitem__和__getitem和__delitem__

五、__format__：自定制格式化字符串

六、__del__：析构方法

七、__slots__

八、__doc__：返回类的注释信息

九、__call__：会在调用对象时自动触发。

十、__init__和__new__：类构造器

十一、__str__和__repr__

__str__：执行str函数或print函数触发

__repr__：执行repr函数或者交互式解释器触发

十二、__module__和__class__

十三、实现文件上下文管理(__enter__和__exit__)