Discussion :

[nabix]

Bonjour,

J'essaye sans succes pour l'instant de transformer une string formatée exactement comme un dictionnaire python en une structure dict. Ex.

Code :

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

s = "{'a':{'b':'c', 'd':'e'}}"

j'aimerai avoir à partir de s l'équivalent de

Code :

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

d = {'a':{'b':'c', 'd':'e'}}

il y a bien la fonction exec mais je la trouve un peu radicale et très problématique dans mon cas (la string vient du web).

Je me demande donc si il existe pas une fonction ou une expression régulière permettant de parser une telle string en un dict.

Merci d'avance pour votre aide

Nicolas

[GrandFather]

Bonjour,

les expressions régulières ne vont pas être le plus indiqué pour ce type d'expression récursive. Et si tu ne veux ou peux utiliser exec(), il ne te reste plus qu'à écrire un analyseur. Selon l'expression que tu as donnée en exemple, on peut déduire la grammaire suivante (grossièrement) :

Code :

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

1
2
3
4
5
dictionnaire ::= "{" paire (,paire)* "}"
paire ::= cle ":" valeur
cle ::= caractère
caractère ::= "'" alpha "'"
valeur ::= caractère | dictionnaire

Il n'y a plus qu'à traduire cette grammaire en Python :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
# -*- coding: iso-8859-1 -*-
 
 
def nextToken(expr):
    for c in expr:
        yield c
 
def dictionnaire():
    global token
    if token != '{':
        raise "{ attendu !"
    d = {}
    token = it_token.next()
    cle, valeur = paire()
    d[cle] = valeur
    while token == ',':
        token = it_token.next()
        cle, valeur = paire()
        d[cle] = valeur        
    if token != '}':
        raise "} attendu !"
    return d
 
def paire():
    global token
    nouv_cle = cle()
    token = it_token.next()    
    if token != ':':
        raise ': attendu !'
    token = it_token.next()    
    nouv_valeur = valeur()
    token = it_token.next()
    return nouv_cle, nouv_valeur
 
def cle():
    return caractere()
 
def caractere():
    global token
    if token != '\'':
        raise '\' attendu !'
    token = it_token.next()
    cle = token
    token = it_token.next()
    if token != '\'':
        raise '\' attendu !'
    return cle
 
def valeur():
    global token
    if token == '\'':
        return caractere()
    elif token == '{':
        return dictionnaire()
    else:
        raise 'erreur de syntaxe'
 
expr = "{'a':{'b':'c','d':'e'}}"
it_token = nextToken(expr)
token = it_token.next()
d = dictionnaire()
print d

Si tu dois avoir des chaînes à plusieurs caractères plutot qu'un seul, autoriser les espaces entre les tokens ou les dictionnaires vides, il suffit d'adapter l'algorithme mais le principe reste le même.

[DelphiManiac]

Une solution qui me parait simple et a priori qui ne pose pas de problème de sécurité serait peut etre celle là :

Code :

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

1
2
3
4
5
6
7
8
9
 
import UserDict
 
value = "{'a':{'b':'c', 'd':'e'}}"
 
try:
  a = UserDict.UserDict(eval(value))
except:
  print "Ce n'est pas un dictionnaire"

[nabix]

Merci à vous deux pour ces responses rapides.

GrandFather : Effectivement il existe toujours cette solution mais je voulais justement éviter de devoir écrire cette sorte de code, mais qui est effectivement toujours possible et je te remercie pour l'exemple d'algorithme .

DelphiManiac :
effectivement j'utilise actuellement eval().
J'ai cependant 2 interogations.
Premierement y a-t'il une différence entre

Code :

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

1
2
3
UserDict.UserDict(eval(value))
et
dict(eval(value))

j'ai lu que UserDict ne devais être utiliser que pour backward compatibilté.

Deuxièment :
quel type de code peut être executé avec eval, car dans :

Code :

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

1
2
3
UserDict.UserDict(eval(value))
ou
dict(eval(value))

le eval va être interpreter avant la création du dictionnaire. Si un code dangereux est envoyé à eval il sera quand même interpreter. D'où l'importance du type de code pouvant être passé à eval.
Merci encore

[DelphiManiac]

Après vérification, l'eval est toujours effectué, donc il y a un risque d'exécuter une code non prévu.

Par contre, ne serait-il pas suffisant et assez simple de juste vérifier que la chaine reçu commence bien par un { et fini par un } avant de la passer en eval ?

Il ne me semble pas possible d'exécuter un quelconque code à partir du moment ou celui ci est encadrer par des { }.

[nabix]

Effectivement je peux faire une petite vérification avant, c'est une bonne solution. Je pense que dans mon cas le eval est encore la solution la plus simple.

Merci pour ces réponses.