The scope of names defined in class block doesn’t extend to the methods’ blocks. Why is that?

by

A class block is syntactic sugar for building a dictionary, which is then passed to the metaclass (usually type) to construct the class object.

class A:
    i = 1
    def f(self):
        print(i)

Is roughly equivalent to:

def f(self):
    print(i)
attributes = {'f': f, 'i': 1)
A = type('A', (object,) attributes)

Seen that way, there is no outer scope the i name to come from. However there obviously is a temporary scope for you to execute the statements in the class block. It would be possible for that class block to desugar to something more like:

def attributes():
    i = 1
    def f(self):
        print(i)
    return locals()
A = type('A', (object,), attributes())

In this case the outer reference to i would work. However, this would be going “against the grain” of Python’s object system philosophy.

Python has objects, which contain attributes. There’s not really any concept of “variables” other than local variables in functions (which can be nested to create a scope chain). A bare name is looked up as a local variable, then in outer scopes (which come from functions). Attributes are looked up, using the dotted name syntax, on other objects, and you always specify which object to look in.

There is a protocol for resolving attribute references, which says that when attribute is not found on obj, obj.attribute can be resolved by looking in the class of obj (and its base classes, using the method resolution order). This is actually how methods are found; when in your example you executed a.f(), the a object contains no attribute f, so the class of a (which is A) is searched, and the method definition is found.

Having class attributes automatically available in an outer scope for all methods would be weird, because no other attribute works this way. It would also have the following drawbacks:

  1. Functions defined outside the class and assigned to it later would have to use different syntax to refer to the class attribute than functions defined as part of a class.
  2. Because it’s shorter, it would encourage reference to class attributes including staticmethods and classmethods as bare names: thing rather than using Class.thing or self.thing. This makes them look like module globals when they’re not (method definitions are usually short enough that you can easily see they’re not defined locally).
  3. Note that looking for the attributes on self allows them to play nicer with subclasses, as it allows subclasses to override the attribute. That probably isn’t as big a deal for “class constants”, but it’s very important for staticmethods and classmethods.

Those are the main reasons I see, but ultimately it’s just a choice the designers of Python made. You find it weird that you don’t have this implicit ability to reference class variables, but I find implicit class and instance variable access in languages like C++ and Java to be weird. Different people have different opinions.

More Related Contents:

  1. Explaining the ‘self’ variable to a beginner [duplicate]
  2. Understanding Python super() with __init__() methods [duplicate]
  3. What is the purpose of the word ‘self’?
  4. What is the difference between old style and new style classes in Python?
  5. Variable scopes in Python classes
  6. How do I call a parent class’s method from a child class in Python?
  7. Python function overloading
  8. difference between variables inside and outside of __init__()
  9. What is the difference between __init__ and __call__?
  10. Nested classes’ scope?
  11. What is the purpose of the `self` parameter for methods?
  12. What is the `self` parameter in class methods?
  13. Attaching a decorator to all functions within a class
  14. Private members in Python
  15. How do I access Class member variables in Python?
  16. Does Python have class prototypes (or forward declarations)?
  17. What is the purpose of python’s inner classes?
  18. Prevent creating new attributes outside __init__
  19. How to implement a binary search tree in Python?
  20. Python: how to “kill” a class instance/object?
  21. What is the purpose of the `self` parameter? Why is it needed?
  22. difference between variables inside and outside of __init__() (class and instance attributes)
  23. How do I access instance variables in Python?
  24. How do I access Class member variables?
  25. How do I set and access attributes of a class? [duplicate]
  26. How to assign a new class attribute via __dict__?
  27. How do you change the value of one attribute by changing the value of another? (dependent attributes)
  28. Correctly extend a tkinter widget using inheritance
  29. Should I use a class or dictionary?
  30. Type Hinting for objects of type that’s being defined [duplicate]

Leave a Comment