1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
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
|
