What exactly is contained within a obj.__closure__?

by

Closure cells refer to values needed by the function but are taken from the surrounding scope.

When Python compiles a nested function, it notes any variables that it references but are only defined in a parent function (not globals) in the code objects for both the nested function and the parent scope. These are the co_freevars and co_cellvars attributes on the __code__ objects of these functions, respectively.

Then, when you actually create the nested function (which happens when the parent function is executed), those references are then used to attach a closure to the nested function.

A function closure holds a tuple of cells, one each for each free variable (named in co_freevars); cells are special references to local variables of a parent scope, that follow the values those local variables point to. This is best illustrated with an example:

def foo():
    def bar():
        print(spam)

    spam = 'ham'
    bar()
    spam = 'eggs'
    bar()
    return bar

b = foo()
b()

In the above example, the function bar has one closure cell, which points to spam in the function foo. The cell follows the value of spam. More importantly, once foo() completes and bar is returned, the cell continues to reference the value (the string eggs) even though the variable spam inside foo no longer exists.

Thus, the above code outputs:

>>> b=foo()
ham
eggs
>>> b()
eggs

and b.__closure__[0].cell_contents is 'eggs'.

Note that the closure is dereferenced when bar() is called; the closure doesn’t capture the value here. That makes a difference when you produce nested functions (with lambda expressions or def statements) that reference the loop variable:

def foo():
    bar = []
    for spam in ('ham', 'eggs', 'salad'):
        bar.append(lambda: spam)
    return bar

for bar in foo():
    print bar()

The above will print salad three times in a row, because all three lambda functions reference the spam variable, not the value it was bound to when the function object was created. By the time the for loop finishes, spam was bound to 'salad', so all three closures will resolve to that value.

More Related Contents:

  1. A better way to write python closures? [closed]
  2. “is” operator behaves unexpectedly with integers
  3. Local variables in nested functions
  4. Accessing class variables from a list comprehension in the class definition
  5. What is the global interpreter lock (GIL) in CPython?
  6. Finding the source code for built-in Python functions?
  7. Why does id({}) == id({}) and id([]) == id([]) in CPython?
  8. When is del useful in Python?
  9. Python lambda closure scoping
  10. Are tuples more efficient than lists in Python?
  11. Two variables in Python have same id, but not lists or tuples
  12. time.sleep — sleeps thread or process?
  13. list() uses slightly more memory than list comprehension
  14. Accessing the list while being sorted
  15. Are sets ordered like dicts in python3.6
  16. How is tuple implemented in CPython?
  17. How to inject variable into scope with a decorator?
  18. Why is one class variable not defined in list comprehension but another is?
  19. Can you patch *just* a nested function with closure, or must the whole outer function be repeated?
  20. Accessing dictionary items by position in Python 3.6+ efficiently
  21. How references to variables are resolved in Python [duplicate]
  22. Weird closure behavior in python
  23. Identifier normalization: Why is the micro sign converted into the Greek letter mu?
  24. python is operator behaviour with string [duplicate]
  25. Python nonlocal statement / keyword
  26. list comprehension filtering – “the set() trap”
  27. How exactly is Python Bytecode Run in CPython?
  28. How do nested functions work in Python?
  29. Why can’t Python increment variable in closure?
  30. How are python closures implemented?

Leave a Comment