Création dynamique d'un dictionnaire

**dca_marshall** · 11/10/2018, 12h13

Bonjour,

Big picture
Je souhaite alimenter un dictionnaire, sur la base d'un Parser Lexx/Yacc.
Toutefois je vous fais grâce du contenu du Parser.
Et actuellement, il me renvoi bien ce que j'attendais.

Je souhaiterai donc créer ce dictionnaire, via des "pointeurs" (ou référence) pour alimenter chaque valeur de clé, dans les items des listes.
Toutefois, la profondeur de ce dictionnaire sera très variable (selon ce que découvre le Parser).

J'ai donc fait un petit code, qui permet de lire un dictionnaire, pour la simulation du Parser (dict1), afin d'en alimenter un autre.
Mais je suis "sec" sur ce que je dois mettre pour alimenter le second dictionnaire (dict2).
Pour info, je fais très bien cela en Perl, mais là j'avoue être perdu...

Si vous pouviez me mettre sur la bonne piste, je serai un homme heureux

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
63
64
65
66
67
68
 
#!/usr/bin/env python3
import json
 
dict2 = {}
current = { 'pad': 0 }
dict1 = {
   'level1': [
 
      {
         'prp1': 'foo1',
         'prp2': 'bar',
         'prp3': 'zzz',
         'level2': [
            {
               'prp1': 'foo12',
               'prp2': 'bar12',
            },
            {
               'prp1': 'foo13',
               'prp2': 'bar13',
            },
         ],
      },
 
      {
         'prp1': 'foo2',
         'prp2': 'bar',
         'prp3': 'zzz',
         'level2': [
            {
               'prp1': 'foo22',
               'prp2': 'bar22',
            },
            {
               'prp1': 'foo23',
               'prp2': 'bar23',
            },
         ],
      },
 
   ],
}
 
 
def _readList(myList):
   for myItem in myList:
      print("{}{}".format( '   ' * current['pad'], '---' ))
      if isinstance(myItem, dict):
         _readDict(myItem)
 
 
 
 
 
def _readDict(currentDict):
   for k,v in currentDict.items():
      if isinstance(v, list):
         print("{}{}".format( '   ' * current['pad'], k ))
         current['pad']+=1
         _readList(v)
         current['pad']-=1
      else:
         print("{}{}={}".format( '   ' * current['pad'], k, v ))
 
 
_readDict(dict1)
print(json.dumps(dict2))

Note:
Les pad dans les print, sont juste là pour l'indentation de sortie et les tirets pour montrer les ruptures.
Et comme je n'aime pas trop les "global", j'ai mis la valeur du pad, dans in dictionnaire.

Aparté:
Du reste, je trouve plutôt étrange, de permettre, à un dictionnaire ou une liste, d'être "global" et pas une variable?!
Je n'ai peut être pas compris un truc... ?

La sortie donne ceci :

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
 
level1
   ---
   prp1=foo1
   prp2=bar
   prp3=zzz
   level2
      ---
      prp1=foo12
      prp2=bar12
      ---
      prp1=foo13
      prp2=bar13
   ---
   prp1=foo2
   prp2=bar
   prp3=zzz
   level2
      ---
      prp1=foo22
      prp2=bar22
      ---
      prp1=foo23
      prp2=bar23
{}

Merci d'avance de votre aide

**wiztricks** · 11/10/2018, 12h38

Envoyé par dca_marshall

J'ai donc fait un petit code, qui permet de lire un dictionnaire, pour la simulation du Parser (dict1), afin d'en alimenter un autre.
Mais je suis "sec" sur ce que je dois mettre pour alimenter le second dictionnaire (dict2).

Vous voulez y mettre quoi dans dict2? Il n'y a rien dans votre code ni dans votre prose qui le mentionne: on ne va pas l'inventer!
note: vous avez le module pprint pour afficher les structures composites avec indentation (ou pas).

Envoyé par dca_marshall

Aparté:
Du reste, je trouve plutôt étrange, de permettre, à un dictionnaire ou une liste, d'être "global" et pas une variable?!
Je n'ai peut être pas compris un truc... ?

Une variable peut être locale ou globale.
Un objet tel qu'un dictionnaire ou une liste seront associés à une ou plusieurs variables (pour exister) mais ne sont ni globaux ni locaux (çà c'est une propriété des variables). Ils ont juste une durée de vie et un état.

- W

**dca_marshall** · 11/10/2018, 13h22

Bonjour wiztricks,

Merci pour ta réponse et les infos (pprint et le global).
Juste un dernier truc là dessus : Il faut préciser dans chaque fonction, que la variable que l'on souhaite adresser est global, avec :

Code :

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

1
2
3
4
5
 
machin = 'bidule'
def myFunction():
   global machin
   machin = 'truc'

alors qu'avec un dictionnaire, ce n'est pas nécessaire :

Code :

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

1
2
3
4
 
myDict = { 'machin': 'bidule' }
def myFunction():
   myDict['machin'] = 'truc'

C'est juste cela que je trouve étrange. Mais bon, je ne vais pas en faire un fromage...

Sinon, c'est vrai que j'ai pas été très clair (toutes mes confuses)

Sur la base de ce code, je veux juste alimenter le dict2, avec exactement le même contenu que dict1 (mais sans utiliser "copy").
Le but étant de savoir comment adresser un "pointeur" sur dict2, lorsqu'il est alimenté à différents niveaux.

Donc le code donne juste les "moment" où l'alimentation de dict2 devrait être faite.

Et du coup, comme je n'ai jamais réussi à le faire, je demande votre aide.

Merci encore.

**wiztricks** · 11/10/2018, 15h13

Salut,

Lorsque vous écrivez machin = 'truc', vous essayez d'associer un nouvel objet à "machin". Par défaut dans une fonction "machin" sera variable locale... sauf à le préciser via la déclaration "global".

Quand vous écrivez myDict['machin'] = 'truc', vous modifiez juste la clef du dictionnaire que vous récupérez via "myDict" (qui est variable globale... mais vous accédez à l'objet associé, vous ne modifiez pas l'association).

Un autre aspect important est qu'une chaine de caractère ('truc') n'est pas mutable. Une fois l'association faite avec "machin", impossible de la modifier sans la remplacer.
Les dictionnaires et les listes sont eux des objets mutables: vous pouvez les modifier sans avoir à remplacer l'ancien par le nouveau.

Sur la base de ce code, je veux juste alimenter le dict2, avec exactement le même contenu que dict1 (mais sans utiliser "copy").
Le but étant de savoir comment adresser un "pointeur" sur dict2, lorsqu'il est alimenté à différents niveaux.

dict2 = dict1!
Mais vous aurez alors deux variables associé au même objet.

- W

**dca_marshall** · 11/10/2018, 16h17

En fait, le but n'est pas de copier un dictionnaire dans un autre.
J'ai juste simulé le Parser avec les boucle récursives, pour créer les "moment" d'alimentation de dict2.
Je voudrai savoir quoi mettre au niveau syntaxe, pour alimenter dict2.

J'ai fait plusieurs essais, mais sans succès...

Il faut donc mettre les instructions d'alimentation de dict2, juste au dessous des print.

Je met des commentaires dans le code pour cette visualisation

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
#!/usr/bin/env python3
import json
 
dict2 = {}
current = { 'pad': 0 }
dict1 = {
   'level1': [
 
      {
         'prp1': 'foo1',
         'prp2': 'bar',
         'prp3': 'zzz',
         'level2': [
            {
               'prp1': 'foo12',
               'prp2': 'bar12',
            },
            {
               'prp1': 'foo13',
               'prp2': 'bar13',
            },
         ],
      },
 
      {
         'prp1': 'foo2',
         'prp2': 'bar',
         'prp3': 'zzz',
         'level2': [
            {
               'prp1': 'foo22',
               'prp2': 'bar22',
            },
            {
               'prp1': 'foo23',
               'prp2': 'bar23',
            },
         ],
      },
 
   ],
}
 
 
def _readList(myList):
   for myItem in myList:
      print("{}{}".format( '   ' * current['pad'], '---' ))
      #-------------------------------------------
      # Tien ! Voici un nouvel item de list...
      # Alors je dois surement faire un append sur
      # le pointeur courant
      #-------------------------------------------
      if isinstance(myItem, dict):
         _readDict(myItem)
 
 
 
 
 
def _readDict(currentDict):
   for k,v in currentDict.items():
      if isinstance(v, list):
         print("{}{}".format( '   ' * current['pad'], k ))
         #-------------------------------------------
         # Ha bah ici, c'est une nouvelle clé de liste
         # Il faut donc créer cette clé au format list
         # ci elle n'existe pas
         #-------------------------------------------
         current['pad']+=1
         _readList(v)
         current['pad']-=1
      else:
         print("{}{}={}".format( '   ' * current['pad'], k, v ))
         #-------------------------------------------
         # Et là c'est juste une clé valeur
         # Toujours sur le pointeur courant je dois faire
         # dict2reference[k] = v
         #-------------------------------------------
 
 
_readDict(dict1)
print(json.dumps(dict2))