Problème de compréhension d'un morceau de code

**Wuzei** · 01/04/2020, 19h56

Bonsoir , je suis le cour apprenez à programmer en python, je suis au niveau de la correction d'un TP pour créer un dictionnaire ordonné.

Voici mon le programme que j'ai réalisé (je n'est pas réussi l'exercice en sa totalité) :

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
84
85
86
87
88
class DictionnaireOrdre:
    """classe qui se comporte comme un dictionnaire
    mais qui a un ordre précis"""
 
    def __init__(self,**dico):
        """quand l'objet se crée le dictionnaire
        qui est rentré en argument est divisé en 2 listes"""
 
        self.clef = [key for key in dico.keys()]
        self.valeur = [values for values in dico.values()]
 
    def __delitem__(self, clef):
        """méthode pour supprimer la clef 
        et la valeur"""
        index = self.clef.index(clef)
        del self.valeur[index]
        del self.clef[index]
 
    def __getitem__(self, clef):
        """méthode appelé quand on fait
        objet[index]"""
        try:
          index = self.clef.index(clef)
          return self.valeur[index]
        except ValueError:
            raise KeyError("Key {} is not in dict".format(clef))
 
    def __setitem__(self, cle, valeur):
        """méthode qui ajoute cle + valeur 
        au dictionnaire, si la cle existe 
        on écrase la valeur associé, sinon
        on ajoute le couple cle + valeur"""
 
        if cle in self.clef:
            index = self.clef.index(cle)
            self.valeur[index] = valeur
        else:
            self.clef.append(cle)
            self.valeur.append(valeur)
 
    def __contains__(self, cle):
        """renvoi true si la cle est dans 
        le dictionnaire ou false si elle 
        n'y est pas"""
 
        if cle in self.clef:
            return True
        else:
            return False
 
    def __len__(self):
        """renvoi le nombre d'items dans
        le dictionnaire"""
 
        return len(self.clef)
 
    def keys(self):
        """méthode qui renvoi les clefs du
        dictionnaire"""
 
        i = 0
        while i < len(self.clef):
            yield self.clef[i]
            i += 1
 
    def values(self):
        """méthode qui renvoi les valeurs du 
        dictionnaire"""
 
        i = 0
        while i < len(self.valeur):
            yield self.valeur[i]
            i += 1
 
    def items(self):
        """méthode qui renvoi valeurs + clef"""
 
        i = 0
        while i < len(self.clef):
           yield self.valeur[i], self.clef[i]
           i += 1
 
    def __add__(self, objet):
        """méthode pour ajouter deux
        objet DictionnaireOdre entre eux"""
 
        self.clef += objet.clef 
        self.valeur += objet.valeur

et voici le morceau de la correction que je ne comprend pas:

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
class DictionnaireOrdonne:
    """Notre dictionnaire ordonné. L'ordre des données est maintenu
    et il peut donc, contrairement aux dictionnaires usuels, être trié
    ou voir l'ordre de ses données inversées"""
 
    def __init__(self, base={}, **donnees):
        """Constructeur de notre objet. Il peut ne prendre aucun paramètre
        (dans ce cas, le dictionnaire sera vide) ou construire un
        dictionnaire remplis grâce :
        -   au dictionnaire 'base' passé en premier paramètre ;
        -   aux valeurs que l'on retrouve dans 'donnees'."""
 
        self._cles = [] # Liste contenant nos clés
        self._valeurs = [] # Liste contenant les valeurs correspondant à nos clés
 
        # On vérifie que 'base' est un dictionnaire exploitable
        if type(base) not in (dict, DictionnaireOrdonne):
            raise TypeError( \
                "le type attendu est un dictionnaire (usuel ou ordonne)")
 
        # On récupère les données de 'base'
        for cle in base:
            self[cle] = base[cle]
 
        # On récupère les données de 'donnees'
        for cle in donnees:
            self[cle] = donnees[cle]

Je ne le comprend pas car quand je le tape dans mon éditeur de code, il me renvoi un message d'erreur, "'self' does not support item assignmentpylint(unsupported-assignment-operation)"
pour les deux boucles for sur la variable self[cle], je comprend cette erreur car je ne trouve pas cela logique, on veut deux listes une avec les clefs du dictionnaire et l'autre
avec les valeurs associer aux clefs, donc si je comprend bien le programme on n'affecte pas les valeurs je veux dire aucunes listes définies dans _init__ ne contiendras
les valeurs du dictionnaire.
De plus self tout seul ne signifie rien ?
Je suis débutant en python et je commence à peine à comprendre comment marchent les classes.

Merci d'avance pour l'aide

**wiztricks** · 01/04/2020, 20h54

Salut,

Envoyé par Wuzei

Je ne le comprend pas car quand je le tape dans mon éditeur de code, il me renvoi un message d'erreur, "'self' does not support item assignmentpylint(unsupported-assignment-operation)"

Votre éditeur de code n'est pas l'interpréteur Python.

Côté Python, self[cle] = ... ne sera évalué que lorsque l'instruction sera exécutée.

A ce moment là, si l'objet a une méthode __setitem__, l'interpréteur saura quoi appeler.

- W

**Wuzei** · 01/04/2020, 21h26

D'accord , mais si j’exécute le code juste avec __init__ sans avoir crée de méthode __setitem__ cela ne va pas marcher pourquoi ?

Quand on crée un objet __setitem__ est appelé si il existe ?

Je viens de tester avec __init__ + __setitem__ et ça marche mais sans __setitem__ ça ne marche pas.

PS: Voici le code de __setitem__:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
def __setitem__(self, cle, valeur):
        """Méthode spéciale appelée quand on cherche à modifier une clé
        présente dans le dictionnaire. Si la clé n'est pas présente, on l'ajoute
        à la fin du dictionnaire"""
 
        if cle in self._cles:
            indice = self._cles.index(cle)
            self._valeurs[indice] = valeur
        else:
            self._cles.append(cle)
            self._valeurs.append(valeur)

**wiztricks** · 01/04/2020, 22h07

Salut,

Envoyé par Wuzei

D'accord , mais si j’exécute le code juste avec __init__ sans avoir crée de méthode __setitem__ cela ne va pas marcher pourquoi ?

Çà fonctionne parce que les concepteurs de Python ont décidé que l'écriture a[x] = c était équivalente à a.__setitem__(x, c).
Et vous avez plein de méthodes "spéciales" (les __machin__) qui se cachent derrière les opérations simples comme a * b, a + b, ...

Après "pourquoi", c'est certainement parce que c'est ce qu'on attend de l'accès à un tableau depuis qu'on a inventé cette notation.
Mais si vous voulez apprendre à programmer avec Python, il va falloir apprendre à faire avec.

- W