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