Problème clé dans un dictionnaire

Version imprimable

Bonjour,
Je viens vous voir car j'ai un problème avec la réalisation d'une liste de dictionnaire
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 TEST= [ #--------------------------------------- dict( NOM_TEST='TEST.F1-RejectionOndulation', NO_TEST=1, RESET_DUT='cfg-default', CONFIG_DUT='Cfg_F1-720', D_RATE=['16.41', '21.875','262.6','350'], DUT_PARAM=D_RATE, ), #--------------------------------------- ]
Mon probleme vient de la ligne suivante DUT_PARAM=D_RATE, j'aimerais donner la valeur de la clé D_RATE comme valeur de la clé DUT_PARAM également afin de lire
Code:

1 2 >>> TEST[0]['DUT_PARAM'] ['16.41', '21.875', '262.6', '350']
C'est impossible avec cette syntaxe et je n'arrive pas à trouver quoi que ce soit sur internet. J'obtiens toujours l'erreur suivante

Code:

NameError: name 'D_RATE' is not defined

Il faut savoir que la ma liste contient ici un seul dictionnaire mais il peut y en avoir des dizaines donc j'aimerais éviter de passer par la méthode "sale" qui est d'ajouter a la suite de ma définition de dictionnaire la ligne suivante qui elle fonctionne mais impossible a automatisé car le DUT_PARAM peut être autre chose que le D_RATE et la liste peut aussi être très longue donc cela dépendra des tests :

Code:

TEST[0]['DUT_PARAM']=TEST[0]['D_RATE']

En vous remerciant d'avance de votre aide, cdlt

Salut,

Tu dis que DUT_PARAM peut être autre chose que le D_RATE mais je suppose que tu le sais avant de créer ton dictionnaire, donc où est le problème ?

d'autre part la liste est en dur dans ton exemple, rien n'empêche, alors, d'écrire
Code:

1 2 3 4 5 6 7 8 9 10 11 values = ['16.41', '21.875','262.6','350'] dict( NOM_TEST='TEST.F1-RejectionOndulation', NO_TEST=1, RESET_DUT='cfg-default', CONFIG_DUT='Cfg_F1-720', D_RATE=values, DUT_PARAM=values, ),

Salut,

on peut faire ce que tu veux en héritant de dict pour modifier le comportement de la méthode __getitem__():

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
32
TEST= [
#---------------------------------------
    dict(
        NOM_TEST='TEST.F1-RejectionOndulation',
        NO_TEST=1,
        RESET_DUT='cfg-default',
        CONFIG_DUT='Cfg_F1-720',
        D_RATE=['16.41', '21.875','262.6','350'],
        DUT_PARAM="D_RATE",
        ),
    dict(
        NOM_TEST='TEST.F2-Blablabla',
        NO_TEST=2,
        RESET_DUT='pouet',
        CONFIG_DUT='toto',
        D_RATE=['16.41', '21.875','262.6','350'],
        DUT_PARAM="NOM_TEST",
        ),
#---------------------------------------
    ]
 
class MyDict(dict):
    def __getitem__(self, key):
        if key == "DUT_PARAM":
            key = super(MyDict, self).__getitem__(key)
        return super(MyDict, self).__getitem__(key)
 
 
md1 = MyDict(TEST[0]);
md2 = MyDict(TEST[1]);
print md1["DUT_PARAM"]  # ['16.41', '21.875', '262.6', '350']
print md2["DUT_PARAM"]  # TEST.F2-Blablabla

15/04/2014, 09h18
nikaulas

VinsS cette solution ne me va pas et oui je sais a l'avance ce que ce sera mais je souhaite éviter d'écrire en dur le parametre DUT_PARAM

Merci tryph pour ta solution effectivement je n'avais pas penser a modifier la méthode permettant de recuperer une clé.
Seulement je n'ai pas tout compris à la méthode pourrais tu m'expliquer ce que tu as fait je souhaiterais comprendre davantage.
Merci :)

Salut,

voir les commentaires:
Code:

1 2 3 4 5 class MyDict(dict): def __getitem__(self, key): # cette méthode est celle qui est appelée quand on accède a un item par sa clé. key est donc la clé demandée if key == "DUT_PARAM": # si cette clé est "DUT_PARAM"... key = super(MyDict, self).__getitem__(key) # ... alors on récupère la valeur associée à DUT_PARAM et on l'utilise comme clé return super(MyDict, self).__getitem__(key) # on retourne enfin la valeur associée à la clé
super(MyDict, self).__getitem__(key) appelle la méthode de la classe parente.
on l'utilise à la place de self[key] pour éviter de rentrer récurivement dans la méthode, ce qui provoquerait une erreur.

après pour l'instanciation d'objets de type MyDict, tu as 2 solution:

soit tu utilises MyDict à la place de dict dés le départ dans ta liste de dictionnaires (ça s'utilise exactement comme un dictionnaire classique)
soit, puisqu'on peut instancier un dictionnaire depuis un autre dictionnaire, tu instancies un nouvel objet MyDict en lui passant un dict classique (c'est que j'ai fait dans le code fourni en exemple)

Bonjour,

Ce qu'il faut comprendre c'est que quand tu fais:
Code:

1 2 dict(A="un", B=[1, 2])
tu crées une instance de la classe 'dict'. Ce qui est entre parenthèses ce sont les arguments passé à la méthode d'initialisation. Les valeurs des arguments doivent être des objets connus par python. Ici, "un" est une instance de type 'string', [1, 2] est une instance de type 'list' dont les éléments sont des instances de type 'int'. On n'a pas l'impression que ce sont des instances parce qu'il s'agit de notations "raccourcies". Elles correspondent respectivement à str("un") et list([in(1), int(2)]), de la même manière que {A: "un", B: [1, 2]} est une notation "raccourcie" pour dict(A="un", B=[1, 2])

Ceci:
Code:

1 2 3 4 dict(A="un", B=[1, 2], C=B) list(B) str(B)
ne peut pas fonctionner parce que B n'est pas connu de python à ce moment là.

A mon humble avis, il ne faut pas chercher midi à 14h00. Le mieux est probablement d'organiser ton code de manière à faire quelque chose dans le goût de ce que propose VinsS.

Cela dit, tu peux aussi faire ça, dans le style de ce que propose Tryph, en plus "direct":
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class ParamsDict(dict): def __init__(self, *args, **kwargs): # **kwrags contient le dictionnaire des arguments nommés passés à l'initialisation # *args contient un tuple des arguments non nommés KEY = kwargs["DUT_PARAM"] # récupère la valeur de l'argument "DUT_PARAM" kwargs["DUT_PARAM"] = kwargs[KEY] # remplace la valeur de "DUT_PARAM" par le valeur de l'argument KEY super(ParamsDict, self).__init__(*args, **kwargs) # passe les arguments à la méthode d'initialisation de dict params = ParamsDict( NOM_TEST='TEST.F1-RejectionOndulation', NO_TEST=1, RESET_DUT='cfg-default', CONFIG_DUT='Cfg_F1-720', D_RATE=['16.41', '21.875','262.6','350'], DUT_PARAM="D_RATE", ) print params["DUT_PARAM"] # ['16.41', '21.875', '262.6', '350']

Un peu dans le sens de Tryph, je ferais une copie du paramètre D_RATE lors de la création du dictionnaire, c'est aussi du fait mesure

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MyDict(dict):
    def __init__(self, **kwargs):
        dict.__init__(self, **kwargs)
        if "D_RATE" in kwargs and "DUT_PARAM" not in kwargs:
            self["DUT_PARAM"] = self["D_RATE"]
 
TEST= [
#---------------------------------------
    MyDict(
        NOM_TEST='TEST.F1-RejectionOndulation',        
        NO_TEST=1,
 
    RESET_DUT='cfg-default',            
        CONFIG_DUT='Cfg_F1-720',
        D_RATE=['16.41', '21.875','262.6','350']
        )
#---------------------------------------
    ]
 
print(TEST[0])
print(TEST[0]["DUT_PARAM"])

Bonne continuation...

15/04/2014, 15h29
nikaulas

Merci a tous pour vos explications j'ai résolu mon problème :)