besoin d'une petite explication de la fonction "eval"

Version imprimable

Bonjour,

je rencontre actuellement un petit probleme avec la fonction "eval", afin de vous expliquer au mieux voila deux codes minimaliste representant mon probleme:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# -*- coding: cp1252 -*-
from Tkinter import *
 
   def fillTheListBox():
 
        listARemplire = "listbox"
        eval(listARemplire).insert(END, "bla bla")
        #listbox.insert(END, "bla bla")
 
 
    Fenetre_02 = Tk()
 
    listbox = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold")
    listbox.pack(side = LEFT, padx = 0, pady = 0)
 
 
    fillTheListBox()
    Fenetre_02.mainloop()

jusque là ca fonctionne (je pense faire une utiliation correcte de "eval")

oui mais voila , l'exemple suivant lui ne foncitonne pas et je ne parviens pas a comprendre pourquoi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding: cp1252 -*-
from Tkinter import *
 
 
def TestDansUneFonction():
 
    def fillTheListBox():
 
        listARemplire = "listbox"
        eval(listARemplire).insert(END, "bla bla")
 
 
    Fenetre_02 = Tk()
 
    listbox = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold")
    listbox.pack(side = LEFT, padx = 0, pady = 0)
 
 
    fillTheListBox()
    Fenetre_02.mainloop()
 
 
 
 
 
Fenetre_01 = Tk()
 
Button = Button(Fenetre_01, width=20, text ='Open Fenetre_02', command = TestDansUneFonction)
Button.pack(side = TOP, padx = 2, pady = 1)
 
Fenetre_01.mainloop()

j'obtiens:

Code:

1
2
3
4
5
6
7
8
9
10
Exception in Tkinter callback
Traceback (most recent call last):
  File "/usr/lib/python2.7/lib-tk/Tkinter.py", line 1437, in __call__
    return self.func(*args)
  File "/home/bibi/Downloads/test.py", line 20, in TestDansUneFonction
    fillTheListBox()
  File "/home/bibi/Downloads/test.py", line 10, in fillTheListBox
    eval(listARemplire).insert(END, "bla bla")
  File "<string>", line 1, in <module>
NameError: name 'listbox' is not defined

je me tourne donc vers vous dans l'espoir de trouver quelqu'un qui puisse m'expliquer où se trouve mon erreur.

d'avance merci pour votre aide,
Daan.

30/07/2015, 23h59
VinsS
Salut,

Ça me semble assez simple, dans le premier cas la fonction TestDansUneFonction n'est pas invoquée donc l'erreur n'apparait pas. Mais elle est quand même là.

Citation:

jusque là ca fonctionne (je pense faire une utiliation correcte de "eval")

Non seulement une utilisation incorrecte mais aussi inapropriée.

Quel est le but de cette fonction ?

Juste ça ?
Code:

1 2 listARemplire = "listbox" + "bla bla"
Et de plus elle ne retourne rien, alors ... ?

Après relecture, je pense comprendre que ton intention est ceci:

Code:

1
2
3
4
5
6
7
8
9
 
    def fillTheListBox(widget):
        widget.insert(END, "bla bla")
 
    Fenetre_02 = Tk()
    listbox = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold")
    listbox.pack(side = LEFT, padx = 0, pady = 0)
 
    fillTheListBox(listbox)

Bonjour,

Ce n'est qu'un problème de visibilité de variable.

D'abord, print(eval("toto")) n'affiche la valeur de la variable toto que si cette variable a été déclarée avant. A défaut, eval déclenche une erreur:
Code:

1 2 3 toto = 10 print(eval("toto")) 10
Prenons un code simplifié pour voir ce que ça donne dans les fonctions, puis dans les fonctions de fonction:

Cas d'une fonction:
Code:

1 2 3 4 5 6 7 8 9 def fonction(): print("toto" in globals()) print("toto" in locals()) print(eval("toto")) toto = 10 fonction()
Ce qui affiche:
Code:

1 2 3 True False 10
Ici, print(eval("toto")) affiche bien 10, parce que dans la fonction, la variable toto est reconnue comme faisant partie des variables globales (dictionnaire globals())

Cas d'une fonction de fonction:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def fonction(): def fonctiondefonction(): print("toto" in globals()) print("toto" in locals()) print(eval("toto")) toto = 10 fonctiondefonction() fonction()
Ce qui affiche:
Code:

1 2 3 4 5 6 7 8 9 False False fonction() File "E:\Pythondev\Pydev3_qt5\python3\test99\testC\test05.py", line 13, in fonction fonctiondefonction() File "E:\Pythondev\Pydev3_qt5\python3\test99\testC\test05.py", line 10, in fonctiondefonction print(eval("toto")) File "<string>", line 1, in <module> NameError: name 'toto' is not defined
On voit bien que la variable toto n'est ni dans les variables globales, ni dans les variables locales: il y a erreur dans eval.

Bizarrerie dans les fonctions de fonctions

Il se passe tout de même des choses bizarres dans les fonctions de fonctions:
Code:

1 2 3 4 5 6 7 8 9 10 11 def fonction(): def fonctiondefonction(): print("toto" in globals()) print("toto" in locals()) toto = 10 fonctiondefonction() fonction()
Ce qui affiche:
Code:

1 2 False False
Donc, comme on l'a vu avant, la variable toto n'est ni dans les variables globales, ni dans les variables locales.

Petite modification, maintenant: on ajoute seulement un print:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def fonction(): def fonctiondefonction(): print("toto" in globals()) print("toto" in locals()) print(toto) toto = 10 fonctiondefonction() fonction()
Logiquement, la variable toto n'ayant pas été déclarée, la tentative de l'affichage de sa valeur devrait déclencher une erreur? Et bien non! Cela affiche:
Code:

1 2 3 False True 10
C'est à dire que le seul fait de vouloir l'afficher entraine que la variable se trouve maintenant dans les variables locales à la fonction de fonction, et retrouve la valeur déclarée dans la fonction englobante!

Si quelqu'un peut m'expliquer ça...

En tout cas, cela explique pourquoi je n'utilise QUASIMENT JAMAIS les "fonctions de fonction" et surtout pas en laissant faire les "effets de bord": c'est pour moi de la mauvaise programmation.

A l'intérieur d'une fonction, soit la variable fait partie des arguments d'appel, soit elle est déclarée en local. Et j'évite autant que je peux les variables globales.

Ainsi, si on reprend le code qui déclenchait une erreur et qu'on transmet la variable toto comme argument, il n'y a plus de problème:
Code:

1 2 3 4 5 6 7 8 9 10 def fonction(): def fonctiondefonction(toto): print(eval("toto")) toto = 10 fonctiondefonction(toto) fonction()

31/07/2015, 07h55
DaanNoa

Bonjour et merci pour ton aide,

Mon objectif est bien d'ajouter "bla bla" a la listbox mais le nom de la variable est du type string (le nom de cette variable est généré automatiquement) , j'utilise donc "eval" pour interpréter le string puis j'insert "bla bla" avec " .insert(END, "blabla") "

Je constat que dans le premier code

Code:

eval(listARemplir).insert(END, "blabla")

Remplit bien la listbox mais quand je place ce premier code dans une fonction (FillTheListbox) "eval" ne semble plus capable d'interpréter " listARemplir" et je ne comprend pas pourquoi.

D'après ce que j'ai cru comprendre "eval" devrait me permettre de "convertir " le string en nom de variable.

J'apprends python par moi-même et je ne suis pas du milieu informatique,
Il est donc tout a fait possible que j'ai mal compris l'utilisation de " eval" ,
Dans ce cas pourrai tu m'expliquer ou réside mon erreur ?

Encore merci pour ton aide,
Daan

Citation:

Envoyé par DaanNoa

Dans ce cas pourrai tu m'expliquer ou réside mon erreur ?

Il me semblait avoir répondu.

Pour reprendre ton code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 from Tkinter import * def TestDansUneFonction(): def fillTheListBox(): listARemplire = "listbox" eval(listARemplire).insert(END, "bla bla") Fenetre_02 = Tk() listbox = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold") listbox.pack(side = LEFT, padx = 0, pady = 0) fillTheListBox() Fenetre_02.mainloop()
Il génère une erreur, parce qu'à l'intérieur de fillTheListBox, la variable listbox n'existe pas, et elle est nécessaire à eval("listbox") ou à eval(listARemplire) si listARemplire="listbox".

Solution: soit tu évites les "fonctions de fonction", soit tu transmets la variable listbox comme argument:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 from Tkinter import * def TestDansUneFonction(): def fillTheListBox(listbox): listARemplire = "listbox" eval(listARemplire).insert(END, "bla bla") Fenetre_02 = Tk() listbox = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold") listbox.pack(side = LEFT, padx = 0, pady = 0) fillTheListBox(listbox) Fenetre_02.mainloop()

31/07/2015, 09h01
DaanNoa

Re bonjour,

tyrtamos : tu as répondu pendant que je rédigeais mon message ( j'ai pris un certain temps pour le rédiger :D)
Merci pour ta réponse, je vais faire quelques essais pour voir si j'ai bien tout compris.

Encore merci à vous pour votre aide.

Salut,

Par défaut eval cherche à trouver le nom dans les "dictionnaires" globals() et locals() et non dans les variables libres (celles créées dans ce qu'on appelle "closure" lorsqu'on est dans le contexte d'une fonction de fonction, qui sont des objets assez particuliers).

Comme la résolution de noms dépend du contexte, il serait plus "sain" de construire son dictionnaire ad hoc pour avoir la correspondance "listbox" => objet voulu.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 from Tkinter import * def TestDansUneFonction(): def fillTheListBox(): listARemplire = "listbox" eval(listARemplire, ns).insert(END, "bla bla") Fenetre_02 = Tk() ns = {} ns['listbox'] = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold") ns['listbox'].pack(side = LEFT, padx = 0, pady = 0) fillTheListBox()
Ce "ns" là n'est ni locals(), ni globals() mais une variable libre du niveau englobant.
Et comme on dit à eval où retrouver ses petits... çà fonctionne.

Mieux, il permet aussi de se passer d'eval (qui n'est pas trop recommandable pour des tas de raisons), puisqu'on peut faire alors directement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 from Tkinter import * def TestDansUneFonction(): def fillTheListBox(): listARemplire = "listbox" ns[listARemplire].insert(END, "bla bla") Fenetre_02 = Tk() ns = {} ns['listbox'] = Listbox(Fenetre_02, height=15, width=20, font ="Arial 10 bold") ns['listbox'].pack(side = LEFT, padx = 0, pady = 0) fillTheListBox()
edit: pour revenir à l'intention de départ, on peut, avec tkinter, associer le nom au widget directement.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 from Tkinter import * def TestDansUneFonction(): def fillTheListBox(): listARemplire = ".listbox" root.nametowidget(listARemplire).insert(END, "bla bla") root = Tk() w = Listbox(root, height=15, width=20, font ="Arial 10 bold", name='listbox') w.pack(side = LEFT, padx = 0, pady = 0) fillTheListBox()
mais, c'est souvent plus facile de ré-inventer son propre nommage que d'essayer de voir comment une bibliothèque résout déjà pour vous ce genre de problème et en tirer profit.

- W

Bonjour wiztricks et merci pour cette explication complémentaire sur ce comportement curieux!

Et effectivement, il vaut mieux éviter eval quand on le peut, surtout quand la chaine à évaluer vient de l'utilisateur. En effet, bien que les chaines données à eval soient des expressions (et non des instructions), il existe des astuces pour importer quand même des modules et en exécuter à peu près n'importe quoi, et compris des effacements de données. Plutôt dangereux...

Exemple tout simple sous Windows:
Code:

1 2 print(eval("__import__('sys').platform")) win32
Une parade possible est de redéfinir la fonction eval pour y ajouter toutes les vérifications nécessaires:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 from builtins import eval as Eval def eval(expr, dicoglob=None, dicoloc=None): # ici toutes les vérifications: if "__import__" in expr: return None # appel au "vrai" eval et retour du résultat return Eval(expr, dicoglob, dicoloc) print(eval("2+3")) 5 print(eval("xxxx__imp" + "ort__yyyy")) None

31/07/2015, 20h36
dahtah
Citation:

Envoyé par tyrtamos

Une parade possible est de redéfinir la fonction eval pour y ajouter toutes les vérifications nécessaires:

C'est quasiment impossible en pratique, parce que tu peux accéder a sys/os a travers quasiment tous les autres modules, sans import. J'ai rajoute le premier import qui me venait a l'esprit dans ton code (re):
Code:

1 2 3 4 5 6 7 8 9 >>> from __builtin__ import eval as Eval >>> import re >>> eval <function eval at 0x110da2e60> >>> Eval <built-in function eval> >>> eval("re.sys.platform") 'darwin'
En pratique, je crois que personne n'a trouve le moyen d'avoir une version "sandboxee" de python en python.
01/08/2015, 00h32
DaanNoa

Bonjour, désolé pour cette réponse tardive.

Grâce à vos explications j'ai pu résoudre mon petit problème.

Un grand merci pour vos explications détaillées qui mon permissent d'apprendre / comprendre pas mal de choses.

Daan.
01/08/2015, 06h52
tyrtamos

Bonjour,

Citation:

Envoyé par dahtah

C'est quasiment impossible en pratique, parce que tu peux accéder a sys/os a travers quasiment tous les autres modules, sans import.

C'est vrai, mais:

-on peut n'importer dans le code que des objets et non des modules (from xxx import...).

- on peut ne diffuser qu'une version "standalone" avec des produits comme cx_freeze qui empêchent d'importer des modules en plus.

- il faut bien sûr compléter la liste des vérifications au début de la nouvelle fonction eval (empêcher eval, exec, tous les noms "système" de type __xxx__, etc...).

- grâce à inspect, on peut identifier les modules et les objets importés et non utilisés dans un code pour corriger les importations.

- etc...

Citation:

Envoyé par dahtah

En pratique, je crois que personne n'a trouve le moyen d'avoir une version "sandboxee" de python en python.

Merci pour le lien!

C'est bien dommage qu'il n'y ait pas plus de travail sur ce sujet de la part des développeurs de Python: la sécurité, c'est tout de même un domaine important!
01/08/2015, 08h46
VinsS

Normalement, c'est à cela que sert le module ast.literal_eval
01/08/2015, 10h46
tyrtamos

Bonjour VinsS

Citation:

Envoyé par VinsS

Normalement, c'est à cela que sert le module ast.literal_eval

Merci, je ne connaissais pas!

Je viens d'essayer quelques pièges connus ("__import__", "input()", "eval", "exec"...): effectivement, ça résiste!

[edit] Oui, ça résiste, mais ça ne fait pas grand chose: les opérations de base (+, -, *, / et quelques autres), et c'est tout. Pas de variable, ni de fonctions utilisateur, ni même de fonction du module math.

Bref: faire une calculette 4 opérations et c'est tout.

Peut-être en redéfinissant la fonction literal_eval pour lui ajouter (prudemment) ce qui manque?