python内置类型和类_Python2和Python3中内置类型的子类化

也许一个元类为您完成所有这些单调的包装工作会使它更容易：class Perpetuate(type):

def __new__(metacls, cls_name, cls_bases, cls_dict):

if len(cls_bases) > 1:

raise TypeError("multiple bases not allowed")

result_class = type.__new__(metacls, cls_name, cls_bases, cls_dict)

base_class = cls_bases[0]

known_attr = set()

for attr in cls_dict.keys():

known_attr.add(attr)

for attr in base_class.__dict__.keys():

if attr in ('__new__'):

continue

code = getattr(base_class, attr)

if callable(code) and attr not in known_attr:

setattr(result_class, attr, metacls._wrap(base_class, code))

elif attr not in known_attr:

setattr(result_class, attr, code)

return result_class

@staticmethod

def _wrap(base, code):

def wrapper(*args, **kwargs):

if args:

cls = args[0]

result = code(*args, **kwargs)

if type(result) == base:

return cls.__class__(result)

elif isinstance(result, (tuple, list, set)):

new_result = []

for partial in result:

if type(partial) == base:

new_result.append(cls.__class__(partial))

else:

new_result.append(partial)

result = result.__class__(new_result)

elif isinstance(result, dict):

for key in result:

value = result[key]

if type(value) == base:

result[key] = cls.__class__(value)

return result

wrapper.__name__ = code.__name__

wrapper.__doc__ = code.__doc__

return wrapper

class MySet(set, metaclass=Perpetuate):

pass

s1 = MySet([1, 2, 3, 4, 5])

s2 = MySet([1, 2, 3, 6, 7])

print(s1.union(s2))

print(type(s1.union(s2)))

print(s1.intersection(s2))

print(type(s1.intersection(s2)))

print(s1.difference(s2))

print(type(s1.difference(s2)))