Why does a class’ body get executed at definition time?

by

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.

More Related Contents:

  1. Why is a class __dict__ a mappingproxy?
  2. “is” operator behaves unexpectedly with integers
  3. What is the global interpreter lock (GIL) in CPython?
  4. Finding the source code for built-in Python functions?
  5. Why is the id of a Python class not unique when called quickly?
  6. What is the difference between class and instance variables?
  7. List attributes of an object [duplicate]
  8. How to return a value from __init__ in Python?
  9. How to create a read-only class property in Python? [duplicate]
  10. list() uses slightly more memory than list comprehension
  11. Defining “boolness” of a class in python
  12. Accessing the list while being sorted
  13. Are sets ordered like dicts in python3.6
  14. Monkey patching a class in another module in Python
  15. How is tuple implemented in CPython?
  16. Overloading Addition, Subtraction, and Multiplication Operators
  17. Why is one class variable not defined in list comprehension but another is?
  18. Accessing dictionary items by position in Python 3.6+ efficiently
  19. Python Class Members Initialization
  20. Class (Static) variables and methods in Python
  21. list comprehension filtering – “the set() trap”
  22. Passing variables, creating instances, self, The mechanics and usage of classes: need explanation [closed]
  23. How do you change the value of one attribute by changing the value of another? (dependent attributes)
  24. What’s an example use case for a Python classmethod?
  25. Are functions objects in Python?
  26. Why is a function/method call in python expensive?
  27. How does str(list) work?
  28. Type Hinting for objects of type that’s being defined [duplicate]
  29. How does the Python for loop actually work?
  30. ‘is’ operator behaves unexpectedly with floats

Leave a Comment