StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
12699607
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
5
CommunityOwnedDate
CreationDate
2012-10-02T22:55:53.863
FavoriteCount
0
LastActivityDate
2012-10-02T23:01:35.420
LastEditDate
2012-10-02T23:01:35.420
LastEditorUserId
450128
OwnerUserId
450128
ParentId
12664385
PostTypeId
2
Score
14
ViewCount
0
LastEditorDisplayName
text
Body
First things first. <code>__init__</code> is required to return <code>None</code>. The <a href="http://docs.python.org/reference/datamodel.html#object.__init__" rel="noreferrer">Python docs</a> say "no value may be returned", but in Python "dropping off the end" of a function without hitting a return statement is equivalent to <code>return None</code>. So explicitly returning <code>None</code> (either as a literal or by returning the value of an expression resulting in <code>None</code>) does no harm either. So the <code>__init__</code> method of <code>DeclarativeMeta</code> that you quote looks a little odd to me, but it doesn't do anything wrong. Here it is again with some comments added by me: <pre><code>def __init__(cls, classname, bases, dict_): if '_decl_class_registry' in cls.__dict__: # return whatever type's (our superclass) __init__ returns # __init__ must return None, so this returns None, which is okay return type.__init__(cls, classname, bases, dict_) else: # call _as_declarative without caring about the return value _as_declarative(cls, classname, cls.__dict__) # then return whatever type's __init__ returns return type.__init__(cls, classname, bases, dict_) </code></pre> This could more succinctly and cleanly be written as: <pre><code>def __init__(cls, classname, bases, dict_): if '_decl_class_registry' not in cls.__dict__: _as_declarative(cls, classname, cls.__dict__) type.__init__(cls, classname, bases, dict_) </code></pre> I have no idea why the SqlAlchemy developers felt the need to return whatever <code>type.__init__</code> returns (which is constrained to be <code>None</code>). Perhaps it's proofing against a future when <code>__init__</code> might return something. Perhaps it's just for consistency with other methods where the core implementation is by deferring to the superclass; usually you'd return whatever the superclass call returns unless you want to post-process it. However it certainly doesn't actually do anything. So your <code>print result</code> printing <code>None</code> is just showing that everything is working as intended. <hr> Next up, lets take a closer look at what metaclasses actually mean. A metaclass is just the class of a class. Like any class, you create instances of a metaclass (i.e. classes) by calling the metaclass. The class block syntax isn't really what creates classes, it's just very convenient syntactic sugar for defining a dictionary and then passing it to a metaclass invocation to create a class object. The <code>__metaclass__</code> attribute isn't what does the magic, it's really just a giant hack to communicate the information "I would like this class block to create an instance of this metaclass instead of an instance of <code>type</code>" through a back-channel, because there's no proper channel for communicating that information to the interpreter.1 This will probably be clearer with an example. Take the following class block: <pre><code>class MyClass(Look, Ma, Multiple, Inheritance): __metaclass__ = MyMeta CLASS_CONST = 'some value' def __init__(self, x): self.x = x def some_method(self): return self.x - 76 </code></pre> This is roughly syntactic sugar for doing the following2: <pre><code>dict_ = {} dict_['__metaclass__'] = MyMeta dict_['CLASS_CONST'] = 'some value' def __init__(self, x): self.x = x dict_['__init__'] = __init__ def some_method(self): return self.x - 76 dict_['some_method'] = some_method metaclass = dict_.get('__metaclass__', type) bases = (Look, Ma, Multiple, Inheritance) classname = 'MyClass' MyClass = metaclass(classname, bases, dict_) </code></pre> So a "class having an attribute <code>__metaclass__</code> having [the metaclass] as value" IS an instance of the metaclass! They are exactly the same thing. The only difference is that if you create the class directly (by calling the metaclass) rather than with a class block and the <code>__metaclass__</code> attribute, then it doesn't necessarily have <code>__metaclass__</code> as an attribute.3 That invocation of <code>metaclass</code> at the end is exactly like any other class invocation. It will call <code>metaclass.__new__(classname, bases, dict_)</code> to get create the class object, then call <code>__init__</code> on the resulting object to initialise it. The default metaclass, <code>type</code>, only does anything interesting in <code>__new__</code>. And most uses for metaclasses that I've seen in examples are really just a convoluted way of implementing class decorators; they want to do some processing when the class is created, and thereafter not care. So they use <code>__new__</code> because it allows them to execute both before and after <code>type.__new__</code>. The net result is that everyone thinks that <code>__new__</code> is what you implement in metaclasses. But you can in fact have an <code>__init__</code> method; it will be invoked on the new class object after it has been created. If you need to add some attributes the the class, or record the class object in a registry somewhere, this is actually a slightly more convenient place to do it (and the logically correct place) than <code>__new__</code>. <hr> 1 In Python3 this is addressed by adding <code>metaclass</code> as a "keyword argument" in the base-class list, rather than as a an attribute of the class. 2 In reality it's slightly more complicated due to the need for metaclass compatibility between the class being constructed and all the bases, but this is the core idea. 3 Not that even a class with a metaclass (other than <code>type</code>) created the usual way necessarily has to have <code>__metaclass__</code> as an attribute; the correct way to check the class of a class is the same way as checking the class of anything else; use <code>cls.__class__</code>, or apply <code>type(cls)</code>.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POSqlAlchemy metaclass confusion
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USBen
UserOwnerUserId
1. USBen
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POSqlAlchemy metaclass confusion
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.