'Eval' kullanmak neden kötü bir uygulamadır?

Şarkılarımın verilerini kolayca saklamak için aşağıdaki sınıfı kullanıyorum.

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

Bunun bir if/elseblok yazmaktan çok daha genişletilebilir olduğunu hissediyorum . Ancak, evalkötü bir uygulama ve kullanımı güvensiz olarak kabul edilmektedir. Eğer öyleyse, birisi bana nedenini açıklayabilir ve yukarıdaki sınıfı tanımlamanın daha iyi bir yolunu gösterebilir mi?

Evet, eval kullanmak kötü bir uygulamadır. Sadece birkaç nedeni belirtmek için:

1. Bunu yapmanın neredeyse her zaman daha iyi bir yolu var
2. Çok tehlikeli ve güvensiz
3. Hata ayıklamayı zorlaştırır
4. Yavaş

Sizin durumunuzda bunun yerine setattr kullanabilirsiniz :

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)

DÜZENLE:

Eval veya exec kullanmak zorunda olduğunuz bazı durumlar vardır. Ancak nadirdirler. Sizin durumunuzda eval kullanmak kötü bir uygulamadır. Kötü uygulama üzerinde duruyorum çünkü eval ve exec sıklıkla yanlış yerde kullanılıyor.

DÜZENLEME 2:

OP davasında eval'ün 'çok tehlikeli ve güvensiz' olduğu konusunda bazı anlaşmazlıklar var gibi görünüyor. Bu, bu özel durum için doğru olabilir, ancak genel olarak geçerli değildir. Soru geneldi ve listelediğim nedenler genel durum için de geçerli.

DÜZENLEME 3: Yeniden sıralanan nokta 1 ve 4

Kullanımı evalzayıftır, açıkça kötü bir uygulama değildir.

1. "Yazılımın Temel Prensibi" ni ihlal eder. Kaynağınız, yürütülebilir dosyanın toplamı değil. Kaynağınıza ek olarak, evalaçıkça anlaşılması gereken argümanlar var . Bu nedenle, son çare aracıdır.

2. Genellikle düşüncesiz tasarımın bir işaretidir. Anında oluşturulmuş dinamik kaynak kodu için nadiren iyi bir neden vardır. Yetkilendirme ve diğer OO tasarım teknikleri ile hemen hemen her şey yapılabilir.

3. Küçük kod parçalarının anında yavaşça derlenmesine yol açar. Daha iyi tasarım desenleri kullanılarak önlenebilecek bir ek yük.

Dipnot olarak, dengesiz sosyopatların elinde iyi sonuç vermeyebilir. Bununla birlikte, dengesiz sosyopatik kullanıcılarla veya yöneticilerle karşılaştığında, en başta onlara yorumlanmış Python vermemek en iyisidir. Gerçekten kötülüğün elinde Python bir sorumluluk alabilir; evalriski hiç arttırmaz.

Bu durumda, evet. Onun yerine

exec 'self.Foo=val'

yerleşik işlevi kullanmalısınız setattr:

setattr(self, 'Foo', val)

Evet öyle:

Python kullanarak kesmek:

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

Aşağıdaki kod, bir Windows makinesinde çalışan tüm görevleri listeler.

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

Linux'ta:

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

Söz konusu sorun için, kullanmanın birkaç alternatifi olduğunu belirtmek gerekir eval:

En basit, belirtildiği gibi kullanıyor setattr:

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

Daha az belirgin bir yaklaşım, nesnenin __dict__nesnesini doğrudan güncellemektir . Tüm yapmak istediğiniz nitelikleri başlatmaksa, Nonebu yukarıdakilerden daha az basittir. Ancak şunu düşünün:

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

Bu, yapıcıya anahtar kelime bağımsız değişkenleri iletmenize olanak tanır, örneğin:

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

Ayrıca locals()daha açık bir şekilde kullanmanıza izin verir , örneğin:

s = Song(**locals())

... ve Noneadları gerçekten bulunan özelliklere gerçekten atamak istiyorsanız locals():

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

Bir nesneye nitelikler listesi için varsayılan değerler sağlamanın başka bir yaklaşımı da sınıfın __getattr__yöntemini tanımlamaktır :

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

Bu yöntem, adlandırılan öznitelik normal şekilde bulunmadığında çağrılır. Bu yaklaşım, yalnızca yapıcıdaki öznitelikleri ayarlamaktan veya güncellemekten daha az basittir __dict__, ancak sınıfın bellek kullanımını oldukça önemli ölçüde azaltabilen özniteliği olmadıkça aslında özniteliği oluşturmamaktan yararlanır.

Tüm bunların amacı: Genel olarak, kaçınmak için birçok neden vardır eval- kontrol etmediğiniz kod yürütmenin güvenlik sorunu, hata ayıklayamadığınız pratik kod sorunu, vb. Ama daha da önemli bir neden genel olarak, onu kullanmanıza gerek yoktur. Python, iç mekanizmalarının çoğunu programcıya maruz bırakır ve nadiren gerçekten kod yazan bir kod yazmanız gerekir.

Diğer kullanıcılar, kodunuzun bağımlı olmayacak şekilde nasıl değiştirilebileceğine dikkat çekti eval; evalCPython: testte bile bulunan meşru bir kullanım örneği sunacağım .

İşte bir örnek test_unary.pynerede (+|-|~)b'a'yükseltir olup olmadığını bir test TypeError:

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

Burada kullanımı açıkça kötü bir uygulama değildir; girdiyi tanımlar ve yalnızca davranışı gözlemlersiniz. evaltest için kullanışlıdır.

Bu arama bir göz atın için evalCPython git depo üzerinde gerçekleştirilen; eval ile test çok kullanılır.

Ne zaman eval()işlem kullanıcı tarafından sağlanan girişi için kullanılır, sen kullanıcı etkinleştirmek Bırak-to-Repl böyle bir şey sağlayarak:

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

Bundan kurtulabilirsiniz, ancak normalde uygulamalarınızda rastgele kod yürütmek için vektör istemezsiniz .

@Nadia Alramli cevabına ek olarak, Python'da yeni olduğum evalve kullanımın zamanlamaları nasıl etkileyeceğini kontrol etmeye istekli olduğum için, küçük bir program denedim ve aşağıdaki gözlemler vardı:

#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