Discussion :

[DaanNoa]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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à.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
listARemplire = "listbox" + "bla bla"

Et de plus elle ne retourne rien, alors ... ?

[VinsS]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[tyrtamos]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tyrtamos]

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

Il me semblait avoir répondu.

Pour reprendre ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 )
Merci pour ta réponse, je vais faire quelques essais pour voir si j'ai bien tout compris.

Encore merci à vous pour votre aide.

[wiztricks]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[tyrtamos]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[dahtah]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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.

[tyrtamos]

Bonjour,

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...

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!

[VinsS]

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

[tyrtamos]

Bonjour 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?