"Inheritance" is not from classes

In Python, it doesn't matter what you put in the class definition. These can be strings, numbers, objects, variables. In the third Python, you can even pass named arguments.

Implementation

First you need to be disappointed: in Python you cannot inherit from classes, i.e. It is impossible to transfer to the class constructor type parameters parameter, in which there are non-classes . However, it is not stipulated anywhere that you will include a class definition.
There is nothing difficult in the implementation of the code above, for this you just need to create a metaclass in which nonclasses from bases will be filtered out (which can be further used at your discretion). I think an example will explain everything, copy & run :

Copy Source | Copy HTML

1. # coding: utf-8
3. class Metaclass (type):
5. '' ' <br/> Metaclass prints all objects from which the class <br/> inherits and which are not classes. <br/> '' '
7. def __new__ (cls, name, bases, dict):
8. import inspect
10. new_bases = []
11. for base in bases:
12. # filter classes
13. # the rest just print
14. if inspect .isclass (base):
15. new_bases.append (base)
16. else :
17. print base
19. return type . __new__ (cls, name, tuple (new_bases), dict)
22. class Print (object):
24. __metaclass__ = Metaclass
27. class String ( Print , 'Programming' , 'is' , 'all' , 'about' , 'architecture.' , '' ):
28. pass
30. class Numbers ( Print , 0 , 1 , 2. 718 , 3. 1459 , '' ):
31. pass
33. class More ( Print , None, True, 'or' , False, [ 'to be' , 'or' , 'not to be' ], '' ):
34. pass
36. the_end = 'The end.'
37. class End ( Print , the_end):
38. pass

Using named arguments in the class definition in the third Python, copy & run :

Copy Source | Copy HTML

1. # Python 3+
3. def metaclass (name, bases, dict, private = True):
4. print ( 'Private:' , private)
5. return type (name, bases, dict)
8. class MyClass (object, metaclass = metaclass , private = False):
10. pass

Feasibility

In most cases, this feature is not required at all. Moreover, the code becomes complicated and “magical”, which is not at all welcome. However, in some cases, it turns out to be indispensable, just like the metaclasses as a whole. In fact, there are two advantages:

1. Metaclass management and
2. Simplify API.

Management of class construction (and generally metaclasses)

Passing parameters to the metaclass directly in the class definition. Of course, you can pass the same parameters through the attributes of a regular class, but this clogs the class and does not always look readable. For example, let it be necessary to inherit either a full glass, or an empty one (it’s pulled by the ears, I didn’t think of a simple and clear one, but I couldn’t take it from the finished code). Copy & run :

Copy Source | Copy HTML

1. #coding: utf-8
3. class EmptyGlass : pass
4. class FullGlass : pass
7. class GlassMetaclass (type):
9. '' ' <br/> GlassMetaclass creates either the EmptyGlass class or FullGlass, <br/> depending on whether True or False is specified in the <br/> class definition . <br/> '' '
11. empty_glass = EmptyGlass
12. full_glass = FullGlass
14. def __new__ (cls, name, bases, dict):
15. if bases [- 1 ] is True: # is True, because we need exactly the True object
16. # full glass
17. bases = [cls.full_glass] + list (bases [: - 1 ])
18. elif bases [- 1 ] is False:
19. # empty
20. bases = [cls.empty_glass] + list (bases [: - 1 ])
22. return super ( GlassMetaclass , cls). __new__ (cls, name, tuple (bases), dict)
25. class Glass (object):
27. __metaclass__ = GlassMetaclass
30. if __name__ == '__main__' :
31. class MyGlass ( Glass , True): pass # full glass
32. class YourGlass ( Glass , False): pass # empty glass
34. print issubclass ( MyGlass , FullGlass ) # True
35. print issubclass ( YourGlass , EmptyGlass ) # True

API Simplification

Suppose we need to create a tree of classes (not a data structure, but simply a hierarchy). Let it be hierarchical regular expressions. In this case, each class is required to pass a string that will be compiled into a regular expression. In its classic form, this would look something like this:

Copy Source | Copy HTML

1. class Music (MyRe):
3. pattern = '/ music'
5. class Artist (MyRe):
7. pattern = '/ artist / \ d +'
9. class Song (MyRe):
11. pattern = '/ song / \ d +'
13. class Album (MyRe):
15. pattern = '/ album / \ d +'

Including strings directly in the class definition allows you to get more beautiful and clear code:

Copy Source | Copy HTML

1. class Music (MyRe, '/ music' ):
3. class Artist (MyRe, '/ artist / \ d +' ): pass
4. class Song (MyRe, '/ song / \ d +' ): pass
5. class Album (MyRe, '/ album / \ d +' ): pass

Conclusion

Passing parameters to metaclasses in class definitions, on the one hand, complicates the implementation of program code, on the other hand, allows us to build a more humane interface and continue to focus on solving problems. In other words, be one step closer to DSL.

Additional literature on metaclasses

1. Official documentation, Customizing class creation. docs.python.org/3.1/reference/datamodel.html#customizing-class-creation
2. Unifying types and classes in Python 2.2 #Metaclasses, Guido van Rossum. www.python.org/download/releases/2.2/descrintro/#metaclasses
3. PEP-3115, Metaclasses in Python 3000. www.python.org/dev/peps/pep-3115
4. Python Metaclasess: Who? Why? When ?, Mike C. Fletcher at PyCon 2004, presentation. www.vrplumber.com/programming/metaclasses-pycon.pdf