Por que usar 'eval' é uma má prática?

Estou usando a classe a seguir para armazenar facilmente dados das minhas músicas.

class Song:
    """The class to store the details of each song"""
    attsToStore=('Name', 'Artist', 'Album', 'Genre', 'Location')
    def __init__(self):
        for att in self.attsToStore:
            exec 'self.%s=None'%(att.lower()) in locals()
    def setDetail(self, key, val):
        if key in self.attsToStore:
            exec 'self.%s=val'%(key.lower()) in locals()

Eu sinto que isso é muito mais extensível do que escrever um if/elsebloco. No entanto, evalparece ser considerado uma prática ruim e insegura de usar. Nesse caso, alguém pode me explicar o porquê e me mostrar uma maneira melhor de definir a classe acima?

Sim, usar eval é uma prática ruim. Apenas para citar alguns motivos:

1. Quase sempre há uma maneira melhor de fazer isso
2. Muito perigoso e inseguro
3. Torna a depuração difícil
4. Lento

No seu caso, você pode usar o setattr :

class Song:
    """The class to store the details of each song"""
    attsToStore=('Name', 'Artist', 'Album', 'Genre', 'Location')
    def __init__(self):
        for att in self.attsToStore:
            setattr(self, att.lower(), None)
    def setDetail(self, key, val):
        if key in self.attsToStore:
            setattr(self, key.lower(), val)

EDITAR:

Existem alguns casos em que você precisa usar eval ou exec. Mas eles são raros. Usar eval no seu caso é uma prática ruim, com certeza. Estou enfatizando as más práticas, porque eval e exec são frequentemente usados ​​no lugar errado.

EDIT 2:

Parece que alguns discordam de que avaliação é 'muito perigosa e insegura' no caso do OP. Isso pode ser verdade para este caso específico, mas não em geral. A pergunta era geral e as razões que listei também são verdadeiras para o caso geral.

EDIT 3: Reordenados pontos 1 e 4

O uso evalé fraco, não é uma prática claramente ruim .

1. Ele viola o "Princípio Fundamental do Software". Sua fonte não é a soma total do que é executável. Além da sua fonte, existem argumentos para eval, que devem ser claramente entendidos. Por esse motivo, é a ferramenta de último recurso.

2. Geralmente é um sinal de design impensado. Raramente existe uma boa razão para o código-fonte dinâmico, criado on-the-fly. Quase tudo pode ser feito com delegação e outras técnicas de design de OO.

3. Isso leva a uma compilação on-the-fly relativamente lenta de pequenos pedaços de código. Uma sobrecarga que pode ser evitada usando melhores padrões de design.

Como nota de rodapé, nas mãos de sociopatas enlouquecidos, pode não funcionar bem. No entanto, quando confrontados com usuários ou administradores sociopatas enlouquecidos, é melhor não dar a eles o Python interpretado em primeiro lugar. Nas mãos do verdadeiro mal, Python pode ser um passivo; evalnão aumenta o risco.

Nesse caso sim. Ao invés de

exec 'self.Foo=val'

você deve usar o builtin função setattr:

setattr(self, 'Foo', val)

Sim, ele é:

Corte usando Python:

>>> eval(input())
"__import__('os').listdir('.')"
...........
...........   #dir listing
...........

O código abaixo listará todas as tarefas em execução em uma máquina Windows.

>>> eval(input())
"__import__('subprocess').Popen(['tasklist'],stdout=__import__('subprocess').PIPE).communicate()[0]"

No Linux:

>>> eval(input())
"__import__('subprocess').Popen(['ps', 'aux'],stdout=__import__('subprocess').PIPE).communicate()[0]"

Vale ressaltar que, para o problema específico em questão, existem várias alternativas ao uso eval :

O mais simples, como observado, está usando setattr:

def __init__(self):
    for name in attsToStore:
        setattr(self, name, None)

Uma abordagem menos óbvia é atualizar o objeto do __dict__objeto diretamente. Se tudo o que você deseja fazer é inicializar os atributos None, isso é menos direto do que o descrito acima. Mas considere isso:

def __init__(self, **kwargs):
    for name in self.attsToStore:
       self.__dict__[name] = kwargs.get(name, None)

Isso permite que você passe argumentos de palavras-chave para o construtor, por exemplo:

s = Song(name='History', artist='The Verve')

Também permite que você use locals()mais explícito, por exemplo:

s = Song(**locals())

... e, se você realmente deseja atribuir Noneaos atributos cujos nomes são encontrados em locals():

s = Song(**dict([(k, None) for k in locals().keys()]))

Outra abordagem para fornecer um objeto com valores padrão para uma lista de atributos é definir o __getattr__método da classe :

def __getattr__(self, name):
    if name in self.attsToStore:
        return None
    raise NameError, name

Este método é chamado quando o atributo nomeado não é encontrado da maneira normal. Essa abordagem é um pouco menos direta do que simplesmente definir os atributos no construtor ou atualizar o__dict__ , mas tem o mérito de não criar o atributo, a menos que ele exista, o que pode reduzir substancialmente o uso de memória da classe.

O ponto de tudo isso: em geral, existem muitas razões para evitar eval- o problema de segurança da execução de código que você não controla, o problema prático de código que você não pode depurar etc. etc. Mas uma razão ainda mais importante é que geralmente você não precisa usá-lo. O Python expõe tanto de seus mecanismos internos ao programador que você raramente precisa escrever um código que escreva código.

Outros usuários apontaram como seu código pode ser alterado para não depender eval; Vou oferecer um caso de uso legítimo para uso eval, encontrado mesmo no CPython: testing .

Aqui está um exemplo que encontrei em test_unary.pyque um teste para determinar se (+|-|~)b'a'gera um TypeError:

def test_bad_types(self):
    for op in '+', '-', '~':
        self.assertRaises(TypeError, eval, op + "b'a'")
        self.assertRaises(TypeError, eval, op + "'a'")

O uso claramente não é uma má prática aqui; você define a entrada e apenas observa o comportamento. evalé útil para teste.

Dê uma olhada esta pesquisa para eval, realizada no repositório git CPython; o teste com eval é muito usado.

Quando eval()é usado para processar a entrada fornecida pelo usuário, você habilita o usuário a soltar para o REPL fornecendo algo como isto:

"__import__('code').InteractiveConsole(locals=globals()).interact()"

Você pode se safar, mas normalmente não deseja vetores para execução arbitrária de código em seus aplicativos.

Além da resposta da @Nadia Alramli, como eu sou novo no Python e estava ansioso para verificar como o uso evalafetaria os horários , tentei um pequeno programa e abaixo as observações:

#Difference while using print() with eval() and w/o eval() to print an int = 0.528969s per 100000 evals()

from datetime import datetime
def strOfNos():
    s = []
    for x in range(100000):
        s.append(str(x))
    return s

strOfNos()
print(datetime.now())
for x in strOfNos():
    print(x) #print(eval(x))
print(datetime.now())

#when using eval(int)
#2018-10-29 12:36:08.206022
#2018-10-29 12:36:10.407911
#diff = 2.201889 s

#when using int only
#2018-10-29 12:37:50.022753
#2018-10-29 12:37:51.090045
#diff = 1.67292