Classes have a local scope during definition, but functions inside the class do not use that scope when looking up names. Because lambdas are functions, and comprehensions are implemented using function scope, this can lead to some surprising behavior.
a = 'global' class Fred: a = 'class' # class scope b = (a for i in range(10)) # function scope c = [a for i in range(10)] # function scope d = a # class scope e = lambda: a # function scope f = lambda a=a: a # default argument uses class scope @staticmethod # or @classmethod, or regular instance method def g(): # function scope return a print(Fred.a) # class print(next(Fred.b)) # global print(Fred.c) # class in Python 2, global in Python 3 print(Fred.d) # class print(Fred.e()) # global print(Fred.f()) # class print(Fred.g()) # global
Users unfamiliar with how this scope works might expect
e to print
From PEP 227:
Names in class scope are not accessible. Names are resolved in the innermost enclosing function scope. If a class definition occurs in a chain of nested scopes, the resolution process skips class definitions.
From Python's documentation on naming and binding:
The scope of names defined in a class block is limited to the class block; it does not extend to the code blocks of methods – this includes comprehensions and generator expressions since they are implemented using a function scope. This means that the following will fail:
class A: a = 42 b = list(a + i for i in range(10))
This example uses references from this answer by Martijn Pieters, which contains more in depth analysis of this behavior.