python - Why does a class' body get executed at definition time?

Question

In contrast to functions, a class' body is executed at definition time:

class A(object):
    print 'hello'

Out:

hello

Why is it the case? Is it related to @classmethod / @staticmethod methods and class attributes?

@JohnZwinck I could understand their confusion. It would be intuitive that a class body would only get executed upon instantiation of the first instance of the class (although that is not the case). — Cory Kramer
a simple answer - because that is the way the language is defined.. — Tony Suffolk 66
Ask yourself: how could you use the class if it wasn't executed when the module is loaded? — Martijn Pieters♦
Unlike in some languages, a class is a first-class object (no pun intended) that exists in memory, rather than a static instruction to the compiler on how to create objects later. A class object is created by executing the class statement, which is simply a declarative wrapper around a call to the type function (or whatever callable is specified as the metaclass, but you don't need to worry about that technicality). — chepner

Martijn Pieters Martijn Pieters · Accepted Answer · 2014-10-04T16:24:26

Everything is executed at the module level when Python first imports a module. Function bodies (and generator expression bodies) are the exception here, not the rule. Python executes everything to create the objects contained in a module; like everything in Python, classes are objects, and so are functions.

The only reason a class body uses a separate code object is because a class body is executed in a separate namespace, with that namespace then forming the class attributes. Class bodies are not the only such namespaces; set and dict comprehensions, and in Python 3, list comprehensions are also executed with a separate namespace, scoping their locals.

So functions and generator expressions are the exception, expressly because their whole purpose is to be executed at a later time. Note that the function definition is executed:

>>> import dis
>>> dis.dis(compile('def foo(): pass', '<stdin>', 'exec'))
  1           0 LOAD_CONST               0 (<code object foo at 0x106aef2b0, file "<stdin>", line 1>)
              3 MAKE_FUNCTION            0
              6 STORE_NAME               0 (foo)
              9 LOAD_CONST               1 (None)
             12 RETURN_VALUE

The MAKE_FUNCTION bytecode there creates the function object, together with the stored bytecode for that function, and the result is bound to the global name foo.

Class objects are no different here; the class statement produces a class object, and as part of that object, we need to know the attributes from the class body.

If Python did not execute the class body, other code could not make any use of those class members. You couldn't access class attributes (including class methods and static methods), you couldn't set class attributes, etc.

Any functions that are part of the class body are of course not executed at that time. Just like top-level functions, only a MAKE_FUNCTION bytecode is executed and the resulting local name (set with STORE_FAST) is then turned into a class attribute, analogous to a global function object being bound to a global with STORE_NAME.

python - Why does a class' body get executed at definition time?

2 Answers