I try to use eval() in a local scope of a function. However it always evaluate in the global scope.
Self contained examples:
1- This code works:
var1 = 1
var2 = 2
var3 = 3
myDict = dict((name, eval(name)) for name in ["var1",
"var2",
"var3"])
print(myDict["var1"])
2- Throws NameError
for lvar1
def test1():
lvar1 = 1
lvar2 = 2
lvar3 = 3
myDict = dict((name, eval(name)) for name in ["lvar1",
"lvar2",
"lvar3"])
print(myDict["lvar1"])
3- Same outcome as 2.
def test2():
lvar1 = 1
lvar2 = 2
lvar3 = 3
myDict = dict((name, eval(name), locals()) for name in ["lvar1",
"lvar2",
"lvar3"])
print(myDict["lvar1"])
Eval function is mostly used in situations or applications which need to evaluate mathematical expressions. Also if the user wants to evaluate the string into code then can use eval function, because eval function evaluates the string expression and returns the integer as a result.
literal_eval may be a safer alternative. literal_eval() would only evaluate literals, not algebraic expressions.
The Eval function evaluates the string expression and returns its value. For example, Eval("1 + 1") returns 2. If you pass to the Eval function a string that contains the name of a function, the Eval function returns the return value of the function.
Save the result of locals()
(or vars()
) call to return the function's local scope. Otherwise, locals()
inside the generator expression will return the gen-expr's local scope.
def test3():
lvar1 = 1
lvar2 = 2
lvar3 = 3
scope = locals()
myDict = dict((name, eval(name, scope)) for name in [
"lvar1", "lvar2", "lvar3"])
print(myDict["lvar1"])
BTW, you don't need an explicit comprehension to build that dict:
# copy() avoids quirky, unexpected updates if something else (like a debugger)
# accesses locals() or f_locals
myDict = locals().copy() # or vars().copy()
First of all it's important to read this:
The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is present and lacks
‘__builtins__’
, the current globals are copied into globals before expression is parsed. This means that expression normally has full access to the standard__builtin__
module and restricted environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment whereeval()
is called. The return value is the result of the evaluated expression`.
To start with it is important to note that a generator expression has its own scope(true for a dict-comprehension as well), hence it has its own locals()
dictionary.
This worked because in global scope both globals()
and locals()
dict points to the same dictionary hence the dict constructor can access those variables.
Here we are again calling eval()
with no globals()
and locals()
dict hence it ends up using the global scope and its own local scope(which is empty) and there are no such variable available in any of these scopes.
Remember generators have their own scope so calling locals()
here barely makes any difference, it's an empty dict.
Solution:
def test1():
lvar1 = 1
lvar2 = 2
lvar3 = 3
test1_locals = locals()
myDict = dict((name, eval(name, test1_locals)) for name in ["lvar1",
"lvar2",
"lvar3"])
print myDict
print(myDict["lvar1"])
This worked because we captured test1's locals()
in a variable and then used that dictionary inside of the dictionary comprehension, so it now has access to those variables.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With