Como executo uma string contendo código Python no Python?

Para instruções, use exec(string)(Python 2/3) ou exec string(Python 2):

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

Quando você precisar do valor de uma expressão, use eval(string):

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

No entanto, o primeiro passo deve ser se perguntar se você realmente precisa. A execução do código geralmente deve ser a posição de último recurso: é lento, feio e perigoso se puder conter código inserido pelo usuário. Você deve sempre procurar alternativas primeiro, como funções de ordem superior, para ver se elas podem atender melhor às suas necessidades.

No exemplo, uma sequência é executada como código usando a função exec.

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()

evale execsão a solução correta e podem ser usadas de maneira mais segura .

Conforme discutido no manual de referência do Python e explicado claramente neste tutorial, as funções evale execusam dois parâmetros extras que permitem ao usuário especificar quais funções e variáveis ​​globais e locais estão disponíveis.

Por exemplo:

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

Em essência, você está definindo o espaço para nome no qual o código será executado.

Lembre-se de que a versão 3 execé uma função!
então sempre use em exec(mystring)vez de exec mystring.

eval()é apenas para expressões, enquanto eval('x+1')funciona, eval('x=1')não funciona, por exemplo. Nesse caso, é melhor usar exec, ou até melhor: tente encontrar uma solução melhor :)

Evite execeeval

Usar exece evalem Python é altamente desaprovado.

Existem melhores alternativas

Da resposta superior (ênfase minha):

Para instruções, use exec.

Quando você precisar do valor de uma expressão, use eval.

No entanto, o primeiro passo deve ser se perguntar se você realmente precisa. A execução do código geralmente deve ser a posição de último recurso : é lento, feio e perigoso se puder conter código inserido pelo usuário. Você deve sempre procurar alternativas primeiro, como funções de ordem superior , para ver se elas podem atender melhor às suas necessidades.

Das alternativas ao exec / eval?

definir e obter valores de variáveis ​​com os nomes em strings

[enquanto eval] funcionaria, geralmente não é aconselhável usar nomes de variáveis ​​que tenham significado para o próprio programa.

Em vez disso, use melhor um ditado.

Não é idiomático

De http://lucumr.pocoo.org/2011/2/1/exec-in-python/ (ênfase minha)

Python não é PHP

Não tente burlar expressões idiomáticas do Python porque alguma outra linguagem o faz de maneira diferente. Os namespaces estão no Python por um motivo e apenas porque ele fornece a ferramenta exec, não significa que você deve usá-la.

É perigoso

De http://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html (ênfase minha)

Portanto, eval não é seguro, mesmo que você remova todos os globals e os builtins!

O problema com todas essas tentativas de proteger eval () é que elas são listas negras . Eles explicitamente removem coisas que podem ser perigosas. Essa é uma batalha perdida porque se houver apenas um item da lista, você poderá atacar o sistema .

Então, a avaliação pode ser feita em segurança? Difícil de dizer. Neste ponto, meu melhor palpite é que você não pode causar nenhum dano se não puder usar sublinhados duplos; talvez, se você excluir qualquer string com sublinhados duplos, esteja seguro. Talvez...

É difícil ler e entender

Em http://stupidpythonideas.blogspot.it/2013/05/why-evalexec-is-bad.html (ênfase minha):

Primeiro, exectorna mais difícil para os seres humanos ler seu código . Para descobrir o que está acontecendo, eu não preciso apenas ler seu código, preciso ler seu código, descobrir qual string ele irá gerar e ler esse código virtual. Portanto, se você estiver trabalhando em equipe, publicando software de código aberto ou pedindo ajuda em algum lugar como o StackOverflow, está dificultando a ajuda de outras pessoas. E se houver alguma chance de você depurar ou expandir esse código daqui a seis meses, você estará dificultando diretamente a si mesmo.

Você executa a execução de código usando exec, como na seguinte sessão IDLE:

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

4

Como os outros mencionaram, é "exec" ..

mas, se o seu código contiver variáveis, você poderá usar "global" para acessá-lo, também para impedir que o compilador gere o seguinte erro:

NameError: o nome 'p_variable' não está definido

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

Use eval .

Vale ressaltar, que esse execirmão existe também chamadoexecfile se você quiser chamar um arquivo python. Às vezes, isso é bom se você estiver trabalhando em um pacote de terceiros com IDEs terríveis incluídos e quiser codificar fora do pacote.

Exemplo:

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

ou:

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

Confira eval :

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

Eu tentei algumas coisas, mas a única coisa que funcionou foi a seguinte:

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

resultado:

10

A solução mais lógica seria usar a função eval () integrada. Outra solução é gravar essa sequência em um arquivo python temporário e executá-la.

Ok .. Eu sei que isso não é exatamente uma resposta, mas possivelmente uma nota para as pessoas que olham para isso como eu. Eu queria executar código específico para diferentes usuários / clientes, mas também queria evitar o exec / eval. Inicialmente, eu procurei armazenar o código em um banco de dados para cada usuário e fazer o acima.

Acabei criando os arquivos no sistema de arquivos em uma pasta 'customer_filters' e usando o módulo 'imp', se nenhum filtro foi aplicado a esse cliente, ele continuou

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:
    m.apply_address_filter(myobj)

para que customerName = "jj" execute o apply_address_filter a partir do arquivo customer_filters \ jj_filter.py