Mengapa menggunakan 'eval' adalah praktik yang buruk?

Saya menggunakan kelas berikut untuk menyimpan data lagu saya dengan mudah.

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

Saya merasa ini jauh lebih bisa diperluas daripada menulis satu if/elseblok. Namun, evaltampaknya dianggap praktik yang buruk dan tidak aman untuk digunakan. Jika demikian, adakah yang bisa menjelaskan kepada saya mengapa dan menunjukkan kepada saya cara yang lebih baik untuk mendefinisikan kelas di atas?

Ya, menggunakan eval adalah praktik yang buruk. Hanya untuk menyebutkan beberapa alasan:

1. Hampir selalu ada cara yang lebih baik untuk melakukannya
2. Sangat berbahaya dan tidak aman
3. Membuat proses debug sulit
4. Lambat

Dalam kasus Anda, Anda dapat menggunakan setattr sebagai gantinya:

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)

EDIT:

Ada beberapa kasus di mana Anda harus menggunakan eval atau exec. Tetapi mereka jarang. Menggunakan eval dalam kasus Anda tentu merupakan praktik yang buruk. Saya menekankan pada praktik buruk karena eval dan eksekutif sering digunakan di tempat yang salah.

EDIT 2:

Sepertinya beberapa orang tidak setuju bahwa eval 'sangat berbahaya dan tidak aman' dalam kasus OP. Itu mungkin benar untuk kasus khusus ini tetapi tidak secara umum. Pertanyaannya adalah umum dan alasan yang saya cantumkan juga benar untuk kasus umum.

EDIT 3: Menyusun ulang poin 1 dan 4

Menggunakan evalitu lemah, bukan praktik yang jelas buruk .

1. Itu melanggar "Prinsip Dasar Perangkat Lunak". Sumber Anda bukan jumlah total dari apa yang dapat dieksekusi. Selain sumber Anda, ada argumen untuk eval, yang harus dipahami dengan jelas. Untuk alasan ini, ini adalah alat pilihan terakhir.

2. Ini biasanya merupakan tanda desain yang tidak dipikirkan. Jarang ada alasan bagus untuk kode sumber dinamis, dibuat dengan cepat. Hampir semua hal dapat dilakukan dengan pendelegasian dan teknik desain OO lainnya.

3. Ini menyebabkan kompilasi on-the-fly yang relatif lambat dari potongan-potongan kecil kode. Overhead yang dapat dihindari dengan menggunakan pola desain yang lebih baik.

Sebagai catatan kaki, di tangan para sosiopat gila, itu mungkin tidak berhasil dengan baik. Namun, ketika berhadapan dengan pengguna atau administrator sosiopat yang kacau, yang terbaik adalah tidak memberi mereka Python yang ditafsirkan. Di tangan orang yang benar-benar jahat, Python dapat menjadi tanggung jawab; evalsama sekali tidak meningkatkan risiko.

Dalam hal ini, ya. Dari pada

exec 'self.Foo=val'

Anda harus menggunakan fungsi builtinsetattr :

setattr(self, 'Foo', val)

Ya itu:

Retas menggunakan Python:

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

Kode di bawah ini akan mencantumkan semua tugas yang berjalan pada mesin Windows.

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

Di Linux:

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

Perlu dicatat bahwa untuk masalah spesifik yang dimaksud, ada beberapa alternatif untuk menggunakan eval:

Yang paling sederhana, seperti disebutkan, menggunakan setattr:

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

Pendekatan yang kurang jelas adalah memperbarui objek __dict__objek secara langsung. Jika semua yang ingin Anda lakukan adalah menginisialisasi atribut None, maka ini kurang mudah daripada di atas. Tetapi pertimbangkan ini:

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

Ini memungkinkan Anda meneruskan argumen kata kunci ke konstruktor, misalnya:

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

Ini juga memungkinkan Anda untuk membuat penggunaan Anda locals()lebih eksplisit, misalnya:

s = Song(**locals())

... dan, jika Anda benar-benar ingin menetapkan Noneatribut yang namanya ditemukan di locals():

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

Pendekatan lain untuk menyediakan objek dengan nilai default untuk daftar atribut adalah dengan mendefinisikan metode kelas __getattr__:

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

Metode ini dipanggil ketika atribut bernama tidak ditemukan dengan cara normal. Pendekatan ini agak kurang langsung daripada hanya mengatur atribut dalam konstruktor atau memperbarui __dict__, tetapi memiliki manfaat tidak benar-benar membuat atribut kecuali jika ada, yang dapat secara substansial mengurangi penggunaan memori kelas.

Inti dari semua ini: Ada banyak alasan, secara umum, untuk dihindari eval- masalah keamanan mengeksekusi kode yang tidak Anda kontrol, masalah praktis kode yang tidak dapat Anda debug, dll. Tapi alasan yang lebih penting adalah bahwa secara umum, Anda tidak perlu menggunakannya. Python memaparkan begitu banyak mekanisme internalnya kepada programmer sehingga Anda jarang benar-benar perlu menulis kode yang menulis kode.

Pengguna lain menunjukkan bagaimana kode Anda dapat diubah agar tidak bergantung eval; Saya akan menawarkan use-case yang sah untuk digunakan eval, yang bahkan ditemukan di CPython: testing .

Inilah satu contoh yang saya temukan di test_unary.pymana tes tentang apakah (+|-|~)b'a'menimbulkan TypeError:

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

Penggunaannya jelas bukan praktik yang buruk di sini; Anda mendefinisikan input dan hanya mengamati perilaku. evalberguna untuk pengujian.

Lihatlah pencarian ini untuk eval, dilakukan pada CPython git repositori; pengujian dengan eval banyak digunakan.

Saat eval()digunakan untuk memproses input yang disediakan pengguna, Anda memungkinkan pengguna untuk Drop-to-REPL memberikan sesuatu seperti ini:

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

Anda mungkin lolos begitu saja, tetapi biasanya Anda tidak ingin vektor untuk eksekusi kode arbitrer dalam aplikasi Anda.

Selain jawaban @Nadia Alramli, karena saya baru mengenal Python dan sangat ingin memeriksa bagaimana penggunaan evalakan memengaruhi timing , saya mencoba sebuah program kecil dan di bawah ini adalah pengamatannya:

#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