# How do I execute a string containing Python code in Python?

## The Question :

394 people think this question is useful

How do I execute a string containing Python code in Python?

The Question Comments :
• To be fair, unlike the other question, this one isn’t a duplicate. And others have posted much more basic questions than this.
• The correct answer, of course, is almost always “don’t!”.
• @S. Lott: Haven’t read the FAQ recently? “It’s also perfectly fine to ask and answer your own programming question, but pretend you’re on Jeopardy: phrase it in the form of a question”. This is not a bad question. +1
• @S.Lott: You don’t. You don’t need to. If the question isn’t on the site already, then it’s fair game (according to the FAQ, as already pointed out). Just answer every question as though the OP needs help. They might not, but the next guy who reads their question probably will. Just my 2 cents.
• To all you saying not to do it: I have a case where I absolutely need to. It involves distributed processing.

## The Answer 1

370 people think this answer is useful

For statements, use exec(string) (Python 2/3) or exec string (Python 2):

>>> mycode = 'print "hello world"'
>>> exec(mycode)
Hello world



When you need the value of an expression, use eval(string):

>>> x = eval("2+2")
>>> x
4



However, the first step should be to ask yourself if you really need to. Executing code should generally be the position of last resort: It’s slow, ugly and dangerous if it can contain user-entered code. You should always look at alternatives first, such as higher order functions, to see if these can better meet your needs.

## The Answer 2

77 people think this answer is useful

In the example a string is executed as code using the exec function.

import sys
import StringIO

# create file-like string to capture output
codeOut = StringIO.StringIO()
codeErr = StringIO.StringIO()

code = """
def f(x):
x = x + 1
return x

print 'This is my output.'
"""

# capture output and errors
sys.stdout = codeOut
sys.stderr = codeErr

exec code

# restore stdout and stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__

print f(4)

s = codeErr.getvalue()

print "error:\n%s\n" % s

s = codeOut.getvalue()

print "output:\n%s" % s

codeOut.close()
codeErr.close()



## The Answer 3

29 people think this answer is useful

eval and exec are the correct solution, and they can be used in a safer manner.

As discussed in Python’s reference manual and clearly explained in this tutorial, the eval and exec functions take two extra parameters that allow a user to specify what global and local functions and variables are available.

For example:

public_variable = 10

private_variable = 2

def public_function():
return "public information"

def private_function():
return "super sensitive information"

# make a list of safe functions
safe_list = ['public_variable', 'public_function']
safe_dict = dict([ (k, locals().get(k, None)) for k in safe_list ])
# add any needed builtins back in
safe_dict['len'] = len

>>> eval("public_variable+2", {"__builtins__" : None }, safe_dict)
12

>>> eval("private_variable+2", {"__builtins__" : None }, safe_dict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name 'private_variable' is not defined

>>> exec("print \"'%s' has %i characters\" % (public_function(), len(public_function()))", {"__builtins__" : None}, safe_dict)
'public information' has 18 characters

>>> exec("print \"'%s' has %i characters\" % (private_function(), len(private_function()))", {"__builtins__" : None}, safe_dict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name 'private_function' is not defined



In essence you are defining the namespace in which the code will be executed.

## The Answer 4

22 people think this answer is useful

Remember that from version 3 exec is a function!
so always use exec(mystring) instead of exec mystring.

## The Answer 5

15 people think this answer is useful

# Avoid exec and eval

## Using exec and eval in Python is highly frowned upon.

### There are better alternatives

From the top answer (emphasis mine):

For statements, use exec.

When you need the value of an expression, use eval.

However, the first step should be to ask yourself if you really need to. Executing code should generally be the position of last resort: It’s slow, ugly and dangerous if it can contain user-entered code. You should always look at alternatives first, such as higher order functions, to see if these can better meet your needs.

set and get values of variables with the names in strings

[while eval] would work, it is generally not advised to use variable names bearing a meaning to the program itself.

Instead, better use a dict.

### It is not idiomatic

From http://lucumr.pocoo.org/2011/2/1/exec-in-python/ (emphasis mine)

### Python is not PHP

Don’t try to circumvent Python idioms because some other language does it differently. Namespaces are in Python for a reason and just because it gives you the tool exec it does not mean you should use that tool.

### It is dangerous

From http://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html (emphasis mine)

So eval is not safe, even if you remove all the globals and the builtins!

The problem with all of these attempts to protect eval() is that they are blacklists. They explicitly remove things that could be dangerous. That is a losing battle because if there’s just one item left off the list, you can attack the system.

So, can eval be made safe? Hard to say. At this point, my best guess is that you can’t do any harm if you can’t use any double underscores, so maybe if you exclude any string with double underscores you are safe. Maybe…

### It is hard to read and understand

From http://stupidpythonideas.blogspot.it/2013/05/why-evalexec-is-bad.html (emphasis mine):

First, exec makes it harder to human beings to read your code. In order to figure out what’s happening, I don’t just have to read your code, I have to read your code, figure out what string it’s going to generate, then read that virtual code. So, if you’re working on a team, or publishing open source software, or asking for help somewhere like StackOverflow, you’re making it harder for other people to help you. And if there’s any chance that you’re going to be debugging or expanding on this code 6 months from now, you’re making it harder for yourself directly.

## The Answer 6

13 people think this answer is useful

eval() is just for expressions, while eval('x+1') works, eval('x=1') won’t work for example. In that case, it’s better to use exec, or even better: try to find a better solution 🙂

## The Answer 7

9 people think this answer is useful

You accomplish executing code using exec, as with the following IDLE session:

>>> kw = {}
>>> exec( "ret = 4" ) in kw
>>> kw['ret']

4



## The Answer 8

7 people think this answer is useful

It’s worth mentioning, that’ exec‘s brother exist as well called execfile if you want to call a python file. That is sometimes good if you are working in a third party package which have terrible IDE’s included and you want to code outside of their package.

Example:

execfile('/path/to/source.py)'

or:

exec(open("/path/to/source.py").read())

## The Answer 9

6 people think this answer is useful

Use eval.

## The Answer 10

6 people think this answer is useful

As the others mentioned, it’s “exec” ..

but, in case your code contains variables, you can use “global” to access it, also to prevent the compiler to raise the following error:

NameError: name ‘p_variable’ is not defined

exec('p_variable = [1,2,3,4]')
global p_variable
print(p_variable)



## The Answer 11

4 people think this answer is useful

Check out eval:

x = 1
print eval('x+1')
->2



## The Answer 12

3 people think this answer is useful

I tried quite a few things, but the only thing that work was the following:

temp_dict = {}
exec("temp_dict['val'] = 10")
print(temp_dict['val'])



output:

10

## The Answer 13

1 people think this answer is useful

The most logical solution would be to use the built-in eval() function .Another solution is to write that string to a temporary python file and execute it.

## The Answer 14

1 people think this answer is useful

Ok .. I know this isn’t exactly an answer, but possibly a note for people looking at this as I was. I wanted to execute specific code for different users/customers but also wanted to avoid the exec/eval. I initially looked to storing the code in a database for each user and doing the above.

I ended up creating the files on the file system within a ‘customer_filters’ folder and using the ‘imp’ module, if no filter applied for that customer, it just carried on

import imp

def get_customer_module(customerName='default', name='filter'):
lm = None
try:
module_name = customerName+"_"+name;
m = imp.find_module(module_name, ['customer_filters'])
lm = imp.load_module(module_name, m[0], m[1], m[2])
except:
''
#ignore, if no module is found,
return lm

m = get_customer_module(customerName, "filter")
if m is not None: