python----元类

一、动态语言
- 1.python 为动态语言定义：它是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语言目前非常具有活力
- 2.动态语言：可以在运行的过程中，修改代码
  - 静态语言：编译时已经确定好代码，运行过程中不能修改
- 3.运行中动态改变代码：
  - 1.动态赋值
    - a=10 后面可以修改 a=False 等
  - 2.实例对象动态添加属性
    - a=类() a.name="张三"
  - 3.实例对象动态添加方法
    - def test():
      - pass
    - a.test=test
    - a.test()
  - 4.添加方法其他方式
    - import types
    - def test(self):
      - print(self.name)
    - a.test=types.MethodType(test,a) -->可以把对象传入到添加方法中的self参数中，调用时无需加self参数
    - a.test()
  - 5.动态添加类的静态方法和类方法
    - @classmethod
    - def test1(cls):
      - print("类方法")
    - 类.test1=test1
    - @staticmethod
      - def test2():
    - print("静态方法")
    - 类.test2=test2
  - 6.动态删除属性和方法
    - del 实例对象（类）.属性名删除类或实例对象属性
    - delattr(对象或类,"属性") 删除类或实例对象属性
    - del 实例对象.方法 delattr(实例对象,"方法") 只能删除类外动态添加的方法，也不能删除类方法和静态方法
  - 7.在类中使用__slots__变量限制添加实例对象属性和方法
    - class Test:
    - __slots__=("属性方法1","属性方法2"...)
    - 那么在类外实例对象，和类中将不能添加 __slots__变量外的属性方法
二、元类
- 1.类就是一组用来描述如何生成一个对象的代码段。
- 2.类同样也是一种对象，也就是类对象
- 3.元类就是创建类这种对象的东西。type就是Python的内建元类
- 4.Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来，这个类就是type。
- 5.使用type（元类）创建类
  - 1.格式：type(类名, 由父类名称组成的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)
  - 2.创建有类属性的类
    - 类名=type("类名",(object,),{"name:"张山"}) 添加的属性是类属性，并不是实例属性。
  - 3.使用type创建带有方法的类
    - def eat(self):
      - print("吃")
    - 类名=type("类名",(object,),{"name:"张山"},"eat":eat)
  - 4.添加类方法，实例方法
    - @classmethod
    - def test1(cls):
      - print("类方法")
    - @staticmethod
      - def test2():
    - print("静态方法")
    - 类名=type("类名",(object,),{"test1":test1,"test2":test2})
  - 5.自定义元类
    - metaclass采用这种方法，这个模块中的所有类都会通过这个元类来创建
    - class UpperAttrMetaClass(type):
      - def __new__(cls, future_class_name, future_class_parents, future_class_attr):
      - # 遍历属性字典，把不是__开头的属性名字变为大写
      - newAttr = {}
      - for name, value in future_class_attr.items():
        
        if not name.startswith("__"):
        
        newAttr[name.upper()] = value
      - # 方法1：通过'type'来做类对象的创建
      - # return type(future_class_name, future_class_parents, newAttr)
      - # 方法2：复用type.__new__方法
      - # 这就是基本的OOP编程，没什么魔法
      - # return type.__new__(cls, future_class_name, future_class_parents, newAttr)
      - # 方法3：使用super方法
      - return super(UpperAttrMetaClass, cls).__new__(cls, future_class_name, future_class_parents, newAttr)
    - class Foo(object, metaclass=UpperAttrMetaClass):
    - bar = 'bip'
    - #判断对象有没有这个属性或方法 hasattr(对象,"属性方法")
    - print(hasattr(Foo,"bar")) -->False
    - print(hasattr(Foo,"BAR")) -->True 自定义元类把属性改为大写了
三、拓展
- 1.内建属性
  - __init__,__str__,__call__,__del__,__bases__,__new__
  - __dict__ 查看实例属性,__doc__ 查看类的文档，子类不继承,__repf__ 类实例回车或者 print(repr(类实例))
  - __class__ 查看对象是由什么创建的如类由元类创建实例对象由类创建整数由 int 创建
  - __getattribute__ 属性拦截器
  - class test(object):s
    - def __init__(self):
    - self.name = "张三"
    - self.age = 18
    - #属性访问时拦截器
    - def __getattribute__(self,obj):
      - if obj == "age":
        
        print("访问age属性被拦截")
        
        return 2
      - else:
        
        return object.__getattribute__(self,obj)
    - def show(self):
      - print(self.name,self,age)
  - s = test()
  - print(s.name) -->张三
  - print(s.age) 被拦截--> 2
  - print(s.show) -->张三 2
- 2.工具函数模块
  - 1.import functools
    - func(*args,**kwargs):
      - pass
    - new_func=functools.partical(fun,1,2,3,name="张三") --》给函数设置默认参数，返回新函数，旧函数不变
  - 2.使用装饰器时，被装饰后的函数其实已经是另外一个函数了。由于函数的doc发生了改变，对测试结果有一些影响
    - 比如 test.__doc__ 拿到的不再是自己的帮助文档，而是内嵌函数的帮助文档
    - import functools 在装饰器内嵌函数上添加@functools.wraps(func)
    - test.__doc__ 拿到的是自己的帮助文档，

猜你喜欢