Subject: Re: The metaclass saga using Python | |
From: Vladimir Marangozov <Vladimir.Marangozov@imag.fr> | |
To: tim_one@email.msn.com (Tim Peters) | |
Cc: python-list@cwi.nl | |
Date: Wed, 5 Aug 1998 15:59:06 +0200 (DFT) | |
[Tim] | |
> | |
> building-on-examples-tends-to-prevent-abstract-thrashing-ly y'rs - tim | |
> | |
OK, I stand corrected. I understand that anybody's interpretation of | |
the meta-class concept is likely to be difficult to digest by others. | |
Here's another try, expressing the same thing, but using the Python | |
programming model, examples and, perhaps, more popular terms. | |
1. Classes. | |
This is pure Python of today. Sorry about the tutorial, but it is | |
meant to illustrate the second part, which is the one we're | |
interested in and which will follow the same development scenario. | |
Besides, newbies are likely to understand that the discussion is | |
affordable even for them :-) | |
a) Class definition | |
A class is meant to define the common properties of a set of objects. | |
A class is a "package" of properties. The assembly of properties | |
in a class package is sometimes called a class structure (which isn't | |
always appropriate). | |
>>> class A: | |
attr1 = "Hello" # an attribute of A | |
def method1(self, *args): pass # method1 of A | |
def method2(self, *args): pass # method2 of A | |
>>> | |
So far, we defined the structure of the class A. The class A is | |
of type <class>. We can check this by asking Python: "what is A?" | |
>>> A # What is A? | |
<class __main__.A at 2023e360> | |
b) Class instantiation | |
Creating an object with the properties defined in the class A is | |
called instantiation of the class A. After an instantiation of A, we | |
obtain a new object, called an instance, which has the properties | |
packaged in the class A. | |
>>> a = A() # 'a' is the 1st instance of A | |
>>> a # What is 'a'? | |
<__main__.A instance at 2022b9d0> | |
>>> b = A() # 'b' is another instance of A | |
>>> b # What is 'b'? | |
<__main__.A instance at 2022b9c0> | |
The objects, 'a' and 'b', are of type <instance> and they both have | |
the same properties. Note, that 'a' and 'b' are different objects. | |
(their adresses differ). This is a bit hard to see, so let's ask Python: | |
>>> a == b # Is 'a' the same object as 'b'? | |
0 # No. | |
Instance objects have one more special property, indicating the class | |
they are an instance of. This property is named __class__. | |
>>> a.__class__ # What is the class of 'a'? | |
<class __main__.A at 2023e360> # 'a' is an instance of A | |
>>> b.__class__ # What is the class of 'b'? | |
<class __main__.A at 2023e360> # 'b' is an instance of A | |
>>> a.__class__ == b.__class__ # Is it really the same class A? | |
1 # Yes. | |
c) Class inheritance (class composition and specialization) | |
Classes can be defined in terms of other existing classes (and only | |
classes! -- don't bug me on this now). Thus, we can compose property | |
packages and create new ones. We reuse the property set defined | |
in a class by defining a new class, which "inherits" from the former. | |
In other words, a class B which inherits from the class A, inherits | |
the properties defined in A, or, B inherits the structure of A. | |
In the same time, at the definition of the new class B, we can enrich | |
the inherited set of properties by adding new ones and/or modify some | |
of the inherited properties. | |
>>> class B(A): # B inherits A's properties | |
attr2 = "World" # additional attr2 | |
def method2(self, arg1): pass # method2 is redefined | |
def method3(self, *args): pass # additional method3 | |
>>> B # What is B? | |
<class __main__.B at 2023e500> | |
>>> B == A # Is B the same class as A? | |
0 # No. | |
Classes define one special property, indicating whether a class | |
inherits the properties of another class. This property is called | |
__bases__ and it contains a list (a tuple) of the classes the new | |
class inherits from. The classes from which a class is inheriting the | |
properties are called superclasses (in Python, we call them also -- | |
base classes). | |
>>> A.__bases__ # Does A have any superclasses? | |
() # No. | |
>>> B.__bases__ # Does B have any superclasses? | |
(<class __main__.A at 2023e360>,) # Yes. It has one superclass. | |
>>> B.__bases__[0] == A # Is it really the class A? | |
1 # Yes, it is. | |
-------- | |
Congratulations on getting this far! This was the hard part. | |
Now, let's continue with the easy one. | |
-------- | |
2. Meta-classes | |
You have to admit, that an anonymous group of Python wizards are | |
not satisfied with the property packaging facilities presented above. | |
They say, that the Real-World bugs them with problems that cannot be | |
modelled successfully with classes. Or, that the way classes are | |
implemented in Python and the way classes and instances behave at | |
runtime isn't always appropriate for reproducing the Real-World's | |
behavior in a way that satisfies them. | |
Hence, what they want is the following: | |
a) leave objects as they are (instances of classes) | |
b) leave classes as they are (property packages and object creators) | |
BUT, at the same time: | |
c) consider classes as being instances of mysterious objects. | |
d) label mysterious objects "meta-classes". | |
Easy, eh? | |
You may ask: "Why on earth do they want to do that?". | |
They answer: "Poor soul... Go and see how cruel the Real-World is!". | |
You - fuzzy: "OK, will do!" | |
And here we go for another round of what I said in section 1 -- Classes. | |
However, be warned! The features we're going to talk about aren't fully | |
implemented yet, because the Real-World don't let wizards to evaluate | |
precisely how cruel it is, so the features are still highly-experimental. | |
a) Meta-class definition | |
A meta-class is meant to define the common properties of a set of | |
classes. A meta-class is a "package" of properties. The assembly | |
of properties in a meta-class package is sometimes called a meta-class | |
structure (which isn't always appropriate). | |
In Python, a meta-class definition would have looked like this: | |
>>> metaclass M: | |
attr1 = "Hello" # an attribute of M | |
def method1(self, *args): pass # method1 of M | |
def method2(self, *args): pass # method2 of M | |
>>> | |
So far, we defined the structure of the meta-class M. The meta-class | |
M is of type <metaclass>. We cannot check this by asking Python, but | |
if we could, it would have answered: | |
>>> M # What is M? | |
<metaclass __main__.M at 2023e4e0> | |
b) Meta-class instantiation | |
Creating an object with the properties defined in the meta-class M is | |
called instantiation of the meta-class M. After an instantiation of M, | |
we obtain a new object, called an class, but now it is called also | |
a meta-instance, which has the properties packaged in the meta-class M. | |
In Python, instantiating a meta-class would have looked like this: | |
>>> A = M() # 'A' is the 1st instance of M | |
>>> A # What is 'A'? | |
<class __main__.A at 2022b9d0> | |
>>> B = M() # 'B' is another instance of M | |
>>> B # What is 'B'? | |
<class __main__.B at 2022b9c0> | |
The metaclass-instances, A and B, are of type <class> and they both | |
have the same properties. Note, that A and B are different objects. | |
(their adresses differ). This is a bit hard to see, but if it was | |
possible to ask Python, it would have answered: | |
>>> A == B # Is A the same class as B? | |
0 # No. | |
Class objects have one more special property, indicating the meta-class | |
they are an instance of. This property is named __metaclass__. | |
>>> A.__metaclass__ # What is the meta-class of A? | |
<metaclass __main__.M at 2023e4e0> # A is an instance of M | |
>>> A.__metaclass__ # What is the meta-class of B? | |
<metaclass __main__.M at 2023e4e0> # B is an instance of M | |
>>> A.__metaclass__ == B.__metaclass__ # Is it the same meta-class M? | |
1 # Yes. | |
c) Meta-class inheritance (meta-class composition and specialization) | |
Meta-classes can be defined in terms of other existing meta-classes | |
(and only meta-classes!). Thus, we can compose property packages and | |
create new ones. We reuse the property set defined in a meta-class by | |
defining a new meta-class, which "inherits" from the former. | |
In other words, a meta-class N which inherits from the meta-class M, | |
inherits the properties defined in M, or, N inherits the structure of M. | |
In the same time, at the definition of the new meta-class N, we can | |
enrich the inherited set of properties by adding new ones and/or modify | |
some of the inherited properties. | |
>>> metaclass N(M): # N inherits M's properties | |
attr2 = "World" # additional attr2 | |
def method2(self, arg1): pass # method2 is redefined | |
def method3(self, *args): pass # additional method3 | |
>>> N # What is N? | |
<metaclass __main__.N at 2023e500> | |
>>> N == M # Is N the same meta-class as M? | |
0 # No. | |
Meta-classes define one special property, indicating whether a | |
meta-class inherits the properties of another meta-class. This property | |
is called __metabases__ and it contains a list (a tuple) of the | |
meta-classes the new meta-class inherits from. The meta-classes from | |
which a meta-class is inheriting the properties are called | |
super-meta-classes (in Python, we call them also -- super meta-bases). | |
>>> M.__metabases__ # Does M have any supermetaclasses? | |
() # No. | |
>>> N.__metabases__ # Does N have any supermetaclasses? | |
(<metaclass __main__.M at 2023e360>,) # Yes. It has a supermetaclass. | |
>>> N.__metabases__[0] == M # Is it really the meta-class M? | |
1 # Yes, it is. | |
-------- | |
Triple congratulations on getting this far! | |
Now you know everything about meta-classes and the Real-World! | |
<unless-wizards-want-meta-classes-be-instances-of-mysterious-objects!> | |
-- | |
Vladimir MARANGOZOV | Vladimir.Marangozov@inrialpes.fr | |
http://sirac.inrialpes.fr/~marangoz | tel:(+33-4)76615277 fax:76615252 |