How can I pass my locals and access the variables directly from another function?

Question

Let's say I have this :

def a(dict):
  locals().update(dict)
  print size

def b():
  size = 20
  f(locals())

What do I have to do to access the size variable directly from the a function? I know of :

size = dict["size"]

but I think there should be a more direct way. I tried using locals().update(dict) but it didn't work. Is there a betteer way ?

Answer 1

print size

cannot work, because "size" is not known when the code is compiled. Your code will work if you change it like this:

def a(dict):
    locals().update(dict)
    print locals()["size"]

def b():
    size = 20
    a(locals())

But as the comment to your question already suggests: This is very strange code. I'm very sure that there are better solutions, if you explain what you really want to do.

Answer 2

Is this helping you somehow?

def print_size(size=None):
    print(size)

dict = {'size': 'XXL'}
print_size(**dict)

Answer 3

You can use closures to access the scope of another function:

def b():

  def a():
    print size

  size = 20
  a()

The trick is to stack functions which belongs together in each other. This way the inner funtion a can access the local variables of the outer function b.

But I don't know what you're really up to so I'm not sure if this helps.

Answer 4

The Python compiler optimizes access to local variables by recognizing at compile time whether the barenames a function is accessing are local (i.e., barenames assigned or otherwise bound within the function). So if you code:

def lv1(d):
  locals().update(d)
  print zap

the compiler "knows" that barename zap is NOT local (not assigned in function lv1) and so it compiles code to access it as a global instead -- whatever d contains won't matter.

If you prefer slow and bloated code, you can defeat the optimization by using an exec inside the function -- when the compiler sees the keyword exec, it KNOWS you're trying to make your code as slow, bloated and buggy as possible, and so it cooperates by not optimizing in any way, just about.

So, the following code works as you desire:

def lv1(d):
  exec ""
  locals().update(d)
  print zap

lv1({'zap': 23})

it emits 23 as you want.

I hope it's clear from the above "deadpan humor" that the technique is not recommended, but I'd better spell it out very explicitly: for the dubious syntactic pleasure of writing print zap in lieu of print locals()['zap'], you ARE paying a hefty price in terms of performance. Still, like all sorts of dangerous tools that can be useful in rare use cases for really experienced guru-level programmers who really truly know what they're doing and why, exec is there, available for you to use (or mis-use) at your whim: Python does NOT stand in your way!-)