Python中动态创建类的方法

发表于 | 分类于 | 831
字数统计 2.2k | 阅读时长 10

0x00 前言

在Python中，类也是作为一种对象存在的，因此可以在运行时动态创建类，这也是Python灵活性的一种体现。

本文介绍了如何使用type动态创建类，以及相关的一些使用方法与技巧。

0x01 类的本质

何为类？类是对现实生活中一类具有共同特征的事物的抽象，它描述了所创建的对象共同的属性和方法。在常见的编译型语言（如C++）中，类在编译的时候就已经确定了，运行时是无法动态创建的。那么Python是如何做到的呢？

来看下面这段代码：

  1. class A(object):
  2.     pass
  4. print(A)
  5. print(A.__class__)
  COPY

在Python2中执行结果如下：

  1. <class '__main__.A'>
  2. <type 'type'>
  COPY

在Python3中执行结果如下：

  1. <class '__main__.A'>
  2. <class 'type'>
  COPY

可以看出，类A的类型是type，也就是说:type实例化后是类，类实例化后是对象。

0x02 使用type动态创建类

type的参数定义如下：

type(name, bases, dict)

name: 生成的类名
bases: 生成的类基类列表，类型为tuple
dict: 生成的类中包含的属性或方法

例如：可以使用以下方法创建一个类A

  1. cls = type('A', (object,), {'__doc__': 'class created by type'})
  3. print(cls)
  4. print(cls.__doc__)
  COPY

输出结果如下：

  1. <class '__main__.A'>
  2. class created by type
  COPY

可以看出，这样创建的类与静态定义的类基本没有什么差别，使用上还更灵活。

这种方法的使用场景之一是：

有些地方需要传入一个类作为参数，但是类中会用到某些受外界影响的变量；虽然使用全局变量可以解决这个问题，但是比较丑陋。此时，就可以使用这种方法动态创建一个类来使用。

以下是一个使用的示例：

  2. import socket
  3. try:
  4.     import SocketServer
  5. except ImportError:
  6.     # python3
  7.     import socketserver as SocketServer
  9. class PortForwardingRequestHandler(SocketServer.BaseRequestHandler):
  10.     '''处理端口转发请求
  11.     '''
  13.     def handle(self):
  14.         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  15.         sock.connect(self.server) # self.server是在动态创建类时传入的
  16.         # 连接目标服务器，并转发数据
  17.         # 以下代码省略...
  19. def gen_cls(server):
  20.     '''动态创建子类
  21.     '''
  22.     return type('%s_%s' % (ProxyRequestHandler.__name__, server), (PortForwardingRequestHandler, object), {'server': server})
  25. server = SocketServer.ThreadingTCPServer(('127.0.0.1', 8080), gen_cls(('www.qq.com', 80)))
  26. server.serve_forever()
  COPY

在上面的例子中，由于目标服务器地址是由用户传入的，而PortForwardingRequestHandler类的实例化是在ThreadingTCPServer里实现的，我们没法控制。因此，使用动态创建类的方法可以很好地解决这个问题。

0x03 使用元类（metaclass）

类是实例的模版，而元类是类的模版。通过元类可以创建出类，类的默认元类是type，所有元类必须是type的子类。

下面是元类的一个例子：

  1. import struct
  3. class MetaClass(type):
  4.     def __init__(cls, name, bases, attrd):
  5.         super(MetaClass, cls).__init__(name, bases, attrd)
  7.     def __mul__(self, num):
  8.         return type('%s_Array_%d' % (self.__name__, num), (ArrayTypeBase,), {'obj_type': self, 'array_size': num, 'size': self.size * num})
  10. class IntTypeBase(object):
  11.     '''类型基类
  12.     '''
  13.     __metaclass__ = MetaClass
  14.     size = 0
  15.     format = ''  # strcut格式
  17.     def __init__(self, val=0):
  18.         if isinstance(val, str): val = int(val)
  19.         if not isinstance(val, int):
  20.             raise TypeError('类型错误：%s' % type(val))
  21.         self._net_order = True  # 默认存储的为网络序数据
  22.         self.value = val
  23.         self._num = 1
  25.     def __str__(self):
  26.         return '%d(%s)' % (self._val, self.__class__.__name__)
  28.     def __cmp__(self, val):
  29.         if isinstance(val, IntTypeBase):
  30.             return cmp(self.value, val.value)
  31.         elif isinstance(val, (int, long)):
  32.             return cmp(self.value, val)
  33.         elif isinstance(val, type(None)):
  34.             return cmp(int(self.value), None)
  35.         else:
  36.             raise TypeError('类型错误：%s' % type(val))
  38.     def __int__(self):
  39.         return int(self.value)
  41.     def __hex__(self):
  42.         return hex(self.value)
  44.     def __index__(self):
  45.         return self.value
  47.     def __add__(self, val):
  48.         return int(self.value + val)
  50.     def __radd__(self, val):
  51.         return int(val + self.value)
  53.     def __sub__(self, val):
  54.         return self.value - val
  56.     def __rsub__(self, val):
  57.         return val - self.value
  59.     def __mul__(self, val):
  60.         return self.value * val
  62.     def __div__(self, val):
  63.         return self.value / val
  65.     def __mod__(self, val):
  66.         return self.value % val
  68.     def __rshift__(self, val):
  69.         return self.value >> val
  71.     def __and__(self, val):
  72.         return self.value & val
  74.     @property
  75.     def net_order(self):
  76.         return self._net_order
  78.     @net_order.setter
  79.     def net_order(self, _net_order):
  80.         self._net_order = _net_order
  82.     @property
  83.     def value(self):
  84.         return self._val
  86.     @value.setter
  87.     def value(self, val):
  88.         if not isinstance(val, int):
  89.             raise TypeError('类型错误：%s' % type(val))
  90.         if val < 0: raise ValueError(val)
  91.         max_val = 256 ** (self.size) - 1
  92.         if val > max_val: raise ValueError('%d超过最大大小%d' % (val, max_val))
  93.         self._val = val
  95.     def unpack(self, buff, net_order=True):
  96.         '''从buffer中提取出数据
  97.         '''
  98.         if len(buff) < self.size: raise ValueError(repr(buff))
  99.         buff = buff[:self.size]
  100.         fmt = self.format
  101.         if not net_order: fmt = '<' + fmt[1]
  102.         self._val = struct.unpack(fmt, buff)[0]
  103.         return self._val
  105.     def pack(self, net_order=True):
  106.         '''返回内存数据
  107.         '''
  108.         fmt = self.format
  109.         if not net_order: fmt = '<' + fmt[1]
  110.         return struct.pack(fmt, self._val)
  112.     @staticmethod
  113.     def cls_from_size(size):
  114.         '''从整型大小返回对应的类
  115.         '''
  116.         if size == 1:
  117.             return c_uint8
  118.         elif size == 2:
  119.             return c_uint16
  120.         elif size == 4:
  121.             return c_uint32
  122.         elif size == 8:
  123.             return c_uint64
  124.         else:
  125.             raise RuntimeError('不支持的整型数据长度：%d' % size)
  127.     @classmethod
  128.     def unpack_from(cls, str, net_order=True):
  129.         obj = cls()
  130.         obj.unpack(str, net_order)
  131.         return int(obj)
  133. class ArrayTypeBase(object):
  134.     '''数组类型基类
  135.     '''
  136.     def __init__(self, val=''):
  137.         init_val = 0
  138.         if isinstance(val, int): 
  139.             init_val = val
  140.         else:
  141.             val = str(val)
  142.         self._obj_array = [self.obj_type(init_val) for _ in range(self.array_size)]  # 初始化
  143.         self.value = val
  145.     def __str__(self):
  146.         return str(self.value)
  148.     def __repr__(self):
  149.         return repr(self.value)
  151.     def __getitem__(self, idx):
  152.         return self._obj_array[idx].value
  154.     def __setitem__(self, idx, val):
  155.         self._obj_array[idx].value = val
  157.     def __getslice__(self, i, j):
  158.         result = [obj.value for obj in self._obj_array[i:j]]
  159.         if self.obj_type == c_ubyte:
  160.             result = [chr(val) for val in result]
  161.             result = ''.join(result)
  162.         return result
  164.     def __add__(self, oval):
  165.         if not isinstance(oval, str):
  166.             raise NotImplementedError('%s还不支持%s类型' % (self.__class__.__name__, type(oval)))
  167.         return self.value + oval
  169.     def __radd__(self, oval):
  170.         return oval + self.value
  172.     def __iter__(self):
  173.         '''迭代器
  174.         '''
  175.         for i in range(self.length):
  176.             yield self[i]
  178.     @property
  179.     def value(self):
  180.         result = [obj.value for obj in self._obj_array]
  181.         if self.obj_type == c_ubyte:
  182.             result = [chr(val) for val in result]
  183.             result = ''.join(result)
  184.         return result
  186.     @value.setter
  187.     def value(self, val):
  188.         if isinstance(val, list):
  189.             raise NotImplementedError('ArrayType还不支持list')
  190.         elif isinstance(val, str):
  191.             self.unpack(val)
  193.     def unpack(self, buff, net_order=True):
  194.         '''
  195.         '''
  196.         if len(buff) == 0: return
  197.         if len(buff) < self.size: raise ValueError('unpack数据长度错误：%d %d' % (len(buff), self.size))
  198.         for i in range(self.array_size):
  199.             self._obj_array[i].unpack(buff[i * self.obj_type.size:], net_order)
  201.     def pack(self, net_order=True):
  202.         '''
  203.         '''
  204.         result = ''
  205.         for i in range(self.array_size):
  206.             result += self._obj_array[i].pack()
  207.         return result
  209. class c_uint8(IntTypeBase):
  210.     '''unsigned char
  211.     '''
  212.     size = 1
  213.     format = '!B'
  215. class c_uint16(IntTypeBase):
  216.     '''unsigned short
  217.     '''
  218.     size = 2
  219.     format = '!H'
  221. class c_uint32(IntTypeBase):
  222.     '''unsigned int32
  223.     '''
  224.     size = 4
  225.     format = '!I'
  227. class c_uint64(IntTypeBase):
  228.     '''unsigned int64
  229.     '''
  230.     size = 8
  231.     format = '!Q'
  234. cls = c_ubyte * 5
  235. print(cls)
  236. val = cls(65)
  237. print(val)
  COPY

以上代码在Python2.7中输出结果如下：

  2. <class '__main__.c_ubyte_Array_5'>
  3. AAAAA
  COPY

在Python3中，metaclass的定义方法做了修改，变成了：

  2. class IntTypeBase(object, metaclass=MetaClass):
  3.     pass
  COPY

为了兼容性。可以使用six库中的方法：

  2. import six
  4. @six.add_metaclass(MetaClass)
  5. class IntTypeBase(object):
  6.     pass
  COPY

使用元类的优点是可以使用更加优雅的方式创建类，如上面的c_ubyte * 5，提升了代码可读性和技巧性。

0x04 重写__new__方法

每个继承自object的类都有__new__方法，这是个在类实例化时优先调用的方法，时机早于__init__。它返回的类型决定了最终创建出来的对象的类型。

请看以下代码：

  2. class A(object):
  3.     def __new__(self, *args, **kwargs):
  4.         return B()
  6. class B(object):
  7.     pass
  9. a = A()
  10. print(a)
  COPY

输出结果如下：

  1. <__main__.B object at 0x023576D0>
  COPY

可以看到，明明实例化的是A，但是返回的对象类型却是B，这里主要就是__new__在起作用。

下面的例子展示了在__new__中动态创建类的过程：

  2. class B(object):
  3.     def __init__(self, var):
  4.         self._var = var
  6.     def test(self):
  7.         print(self._var)
  9. class A(object):
  10.     def __new__(self, *args, **kwargs):
  11.         if len(args) == 1 and isinstance(args[0], type):
  12.             return type('%s_%s' % (self.__name__, args[0].__name__), (self, args[0]), {})
  13.         else:
  14.             return object.__new__(self, *args, **kwargs)
  16.     def output(self):
  17.         print('output from new class %s' % self.__class__.__name__)
  19. obj = A(B)('Hello World')
  20. obj.test()
  21. obj.output()
  COPY

结果输出如下：

  1. Hello World
  2. output from new class A_B
  COPY

这个例子实现了动态创建两个类的子类，比较适合存在很多类需要排列组合生成N多子类的场景，可以避免要写一堆子类代码的痛苦。

0x05 总结

动态创建类必须要使用type实现，但是，根据不同的使用场景，可以选择不同的使用方法。

这样做对静态分析工具其实是不友好的，因为在运行过程中类型发生了变化。而且，这也会降低代码的可读性，一般情况下也不推荐用户使用这样存在一定技巧性的代码。

分享
0 comments
Anonymous
Markdown is supported

Be the first guy leaving a comment!