Why is one class variable not defined in list comprehension but another is?

by

data is the source of the list comprehension; it is the one parameter that is passed to the nested scope created.

Everything in the list comprehension is run in a separate scope (as a function, basically), except for the iterable used for the left-most for loop. You can see this in the byte code:

>>> def foo():
...     return [i for i in data]
... 
>>> dis.dis(foo)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x105390390, file "<stdin>", line 2>)
              3 LOAD_CONST               2 ('foo.<locals>.<listcomp>')
              6 MAKE_FUNCTION            0
              9 LOAD_GLOBAL              0 (data)
             12 GET_ITER
             13 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             16 RETURN_VALUE

The <listcomp> code object is called like a function, and iter(data) is passed in as the argument (CALL_FUNCTION is executed with 1 positional argument, the GET_ITER result).

The <listcomp> code object looks for that one argument:

>>> dis.dis(foo.__code__.co_consts[1])
  2           0 BUILD_LIST               0
              3 LOAD_FAST                0 (.0)
        >>    6 FOR_ITER                12 (to 21)
              9 STORE_FAST               1 (i)
             12 LOAD_FAST                1 (i)
             15 LIST_APPEND              2
             18 JUMP_ABSOLUTE            6
        >>   21 RETURN_VALUE

The LOAD_FAST call refers to the first and only positional argument passed in; it is unnamed here because there never was a function definition to give it a name.

Any additional names used in the list comprehension (or set or dict comprehension, or generator expression, for that matter) are either locals, closures or globals, not parameters.

If you go back to my answer to that question, look for the section titled The (small) exception; or, why one part may still work; I tried to cover this specific point there:

There’s one part of a comprehension or generator expression that executes in the surrounding scope, regardless of Python version. That would be the expression for the outermost iterable.

More Related Contents:

  1. Accessing class variables from a list comprehension in the class definition
  2. How do I create a list of lambdas (in a list comprehension/for loop)?
  3. list() uses slightly more memory than list comprehension
  4. Advanced Nested List Comprehension Syntax
  5. How references to variables are resolved in Python [duplicate]
  6. Are list comprehensions syntactic sugar for `list(generator expression)` in Python 3?
  7. What are __signature__ and __text_signature__ used for in Python 3.4
  8. Why is “1000000000000000 in range(1000000000000001)” so fast in Python 3?
  9. UnboundLocalError on local variable when reassigned after first use
  10. Scope of python variable in for loop
  11. Explaining the ‘self’ variable to a beginner [duplicate]
  12. Why can tuples contain mutable items?
  13. How to access outer class from an inner class?
  14. How can I change a global variable from within a function?
  15. Why does assigning to my global variables not work in Python?
  16. Why does a class’ body get executed at definition time?
  17. Python scope: “UnboundLocalError: local variable ‘c’ referenced before assignment” [duplicate]
  18. How do I pass variables across functions?
  19. String with ‘f’ prefix in python-3.6
  20. globals and locals in python exec()
  21. Python Compilation/Interpretation Process
  22. python import multiple times
  23. When are .pyc files refreshed?
  24. remove None value from a list without removing the 0 value
  25. Nested list comprehension scope
  26. How to remove duplicate items from a list using list comprehension? [duplicate]
  27. Changing one dict changes all dicts in a list of dicts [duplicate]
  28. How do the scoping rules work with classes?
  29. sum each value in a list of tuples
  30. Optimal method to find the max of sublist items within list

Leave a Comment