What limitations have closures in Python compared to language X closures?

by

The most important limitation, currently, is that you cannot assign to an outer-scope variable. In other words, closures are read-only:

>>> def outer(x): 
...     def inner_reads():
...         # Will return outer's 'x'.
...         return x
...     def inner_writes(y):
...         # Will assign to a local 'x', not the outer 'x'
...         x = y
...     def inner_error(y):
...         # Will produce an error: 'x' is local because of the assignment,
...         # but we use it before it is assigned to.
...         tmp = x
...         x = y
...         return tmp
...     return inner_reads, inner_writes, inner_error
... 
>>> inner_reads, inner_writes, inner_error = outer(5)
>>> inner_reads()
5
>>> inner_writes(10)
>>> inner_reads()
5
>>> inner_error(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in inner_error
UnboundLocalError: local variable 'x' referenced before assignment

A name that gets assigned to in a local scope (a function) is always local, unless declared otherwise. While there is the ‘global’ declaration to declare a variable global even when it is assigned to, there is no such declaration for enclosed variables — yet. In Python 3.0, there is (will be) the ‘nonlocal’ declaration that does just that.

You can work around this limitation in the mean time by using a mutable container type:

>>> def outer(x):
...     x = [x]
...     def inner_reads():
...         # Will return outer's x's first (and only) element.
...         return x[0]
...     def inner_writes(y):
...         # Will look up outer's x, then mutate it.      
...         x[0] = y
...     def inner_error(y):
...         # Will now work, because 'x' is not assigned to, just referenced.
...         tmp = x[0]
...         x[0] = y
...         return tmp
...     return inner_reads, inner_writes, inner_error
... 
>>> inner_reads, inner_writes, inner_error = outer(5)
>>> inner_reads()
5
>>> inner_writes(10)
>>> inner_reads()
10
>>> inner_error(15)
10
>>> inner_reads()
15

More Related Contents:

  1. A better way to write python closures? [closed]
  2. What do lambda function closures capture?
  3. Don’t understand why UnboundLocalError occurs (closure) [duplicate]
  4. Local variables in nested functions
  5. How are lambdas useful? [closed]
  6. How do lexical closures work?
  7. Python nonlocal statement
  8. How to understand closure in a lambda?
  9. Why aren’t python nested functions called closures?
  10. Python lambda’s binding to local values
  11. Python lambda closure scoping
  12. How do I create a list of lambdas (in a list comprehension/for loop)?
  13. Can you explain closures (as they relate to Python)?
  14. Why does this UnboundLocalError occur (closure)? [duplicate]
  15. nonlocal keyword in Python 2.x
  16. Read/Write Python Closures
  17. What exactly is contained within a obj.__closure__?
  18. Why results of map() and list comprehension are different? [duplicate]
  19. How to inject variable into scope with a decorator?
  20. How can a function access its own attributes?
  21. Python dynamic function creation with custom names
  22. Can you patch *just* a nested function with closure, or must the whole outer function be repeated?
  23. Weird closure behavior in python
  24. Python nonlocal statement / keyword
  25. Schrödinger’s variable: the __class__ cell magically appears if you’re checking for its presence?
  26. What does nonlocal do in Python 3?
  27. How do nested functions work in Python?
  28. Modify bound variables of a closure in Python
  29. Why can’t Python increment variable in closure?
  30. How are python closures implemented?

Leave a Comment