Each Answer to this Q is separated by one/two green lines.
Given following code:
def A() : b = 1 def B() : # I can access 'b' from here. print( b ) # But can i modify 'b' here? 'global' and assignment will not work. B() A()
For the code in
B() function variable
b is in outer scope, but not in global scope. Is it possible to modify
b variable from within
B() function? Surely I can read it from here and
print(), but how to modify it?
On Python 3, use the
nonlocalstatement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope excluding globals. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope.
def foo(): a = 1 def bar(): nonlocal a a = 2 bar() print(a) # Output: 2
On Python 2, use a mutable object (like a list, or dict) and mutate the value instead of reassigning a variable:
def foo(): a =  def bar(): a.append(1) bar() bar() print a foo()
You can use an empty class to hold a temporary scope. It’s like the mutable but a bit prettier.
def outer_fn(): class FnScope: b = 5 c = 6 def inner_fn(): FnScope.b += 1 FnScope.c += FnScope.b inner_fn() inner_fn() inner_fn()
This yields the following interactive output:
>>> outer_fn() 8 27 >>> fs = FnScope() NameError: name 'FnScope' is not defined
I’m a little new to Python, but I’ve read a bit about this. I believe the best you’re going to get is similar to the Java work-around, which is to wrap your outer variable in a list.
def A(): b =  def B(): b = 2 B() print(b) # The output is '2'
Edit: I guess this was probably true before Python 3. Looks like
nonlocal is your answer.
No you cannot, at least in this way.
Because the “set operation” will create a new name in the current scope, which covers the outer one.
I don’t know if there is an attribute of a function that gives the
__dict__ of the outer space of the function when this outer space isn’t the global space == the module, which is the case when the function is a nested function, in Python 3.
But in Python 2, as far as I know, there isn’t such an attribute.
So the only possibilities to do what you want is:
1) using a mutable object, as said by others
def A() : b = 1 print 'b before B() ==', b def B() : b = 10 print 'b ==', b return b b = B() print 'b after B() ==', b A()
b before B() == 1 b == 10 b after B() == 10
The solution of Cédric Julien has a drawback:
def A() : global b # N1 b = 1 print ' b in function B before executing C() :', b def B() : global b # N2 print ' b in function B before assigning b = 2 :', b b = 2 print ' b in function B after assigning b = 2 :', b B() print ' b in function A , after execution of B()', b b = 450 print 'global b , before execution of A() :', b A() print 'global b , after execution of A() :', b
global b , before execution of A() : 450 b in function B before executing B() : 1 b in function B before assigning b = 2 : 1 b in function B after assigning b = 2 : 2 b in function A , after execution of B() 2 global b , after execution of A() : 2
The global b after execution of
A() has been modified and it may be not whished so
That’s the case only if there is an object with identifier b in the global namespace
The short answer that will just work automagically
I created a python library for solving this specific problem. It is released under the unlisence so use it however you wish. You can install it with
pip install seapie or check out the home page here https://github.com/hirsimaki-markus/SEAPIE
[email protected]:home$ pip install seapie
from seapie import Seapie as seapie def A(): b = 1 def B(): seapie(1, "b=2") print(b) B() A()
the arguments have following meaning:
- The first argument is execution scope. 0 would mean local
B(), 1 means parent
A()and 2 would mean grandparent
- The second argument is a string or code object you want to execute in the given scope
- You can also call it without arguments for interactive shell inside your program
The long answer
This is more complicated. Seapie works by editing the frames in call stack using CPython api. CPython is the de facto standard so most people don’t have to worry about it.
The magic words you are probably most likely interesed in if you are reading this are the following:
frame = sys._getframe(1) # 1 stands for previous frame parent_locals = frame.f_locals # true dictionary of parent locals parent_globals = frame.f_globals # true dictionary of parent globals exec(codeblock, parent_globals, parent_locals) ctypes.pythonapi.PyFrame_LocalsToFast(ctypes.py_object(frame),ctypes.c_int(1)) # the magic value 1 stands for ability to introduce new variables. 0 for update-only
The latter will force updates to pass into local scope. local scopes are however optimized differently than global scope so intoducing new objects has some problems when you try to call them directly if they are not initialized in any way. I will copy few ways to circumvent these problems from the github page
- Assingn, import and define your objects beforehand
- Assingn placeholder to your objects beforehand
- Reassign object to itself in main program to update symbol table: x = locals()[“x”]
- Use exec() in main program instead of directly calling to avoid optimization. Instead of calling x do: exec(“x”)
If you are feeling that using
exec() is not something you want to go with you can
emulate the behaviour by updating the the true local dictionary (not the one returned by locals()). I will copy an example from https://faster-cpython.readthedocs.io/mutable.html
import sys import ctypes def hack(): # Get the frame object of the caller frame = sys._getframe(1) frame.f_locals['x'] = "hack!" # Force an update of locals array from locals dict ctypes.pythonapi.PyFrame_LocalsToFast(ctypes.py_object(frame), ctypes.c_int(0)) def func(): x = 1 hack() print(x) func()
I don’t think you should want to do this. Functions that can alter things in their enclosing context are dangerous, as that context may be written without the knowledge of the function.
You could make it explicit, either by making B a public method and C a private method in a class (the best way probably); or by using a mutable type such as a list and passing it explicitly to C:
def A(): x =  def B(var): var = 1 B(x) print x A()
For anyone looking at this much later on a safer but heavier workaround is. Without a need to pass variables as parameters.
def outer(): a =  def inner(a=a): a += 1 inner() return a
You can, but you’ll have to use the global statment (not a really good solution as always when using global variables, but it works):
def A(): global b b = 1 def B(): global b print( b ) b = 2 B() A()