Salut à tous,

Je suis débutant en Python (et pas très avançé en programmation) et j'ai des soucis avec le TP3 (création d'une classe DictionnaireOrdonné du tuto d'apprentissage de Python. Je n'arrive pas à afficher correctement mon dictionnaire avec les accolades et l'interpréteur de veux pas me trouver mon objet de classe (ma liste contenant les clés) lorsque j'execute le code :

Python 3.2 (r32:88445, Jul 16 2011, 07:13:11) 
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from classe_dico import *
>>> fruits = DictionnaireOrdonne()
>>> fruits
<classe_dico.DictionnaireOrdonne object at 0xb733848c>
>>> fruits["pomme"] = 52
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "classe_dico.py", line 48, in __setitem__
    if cle in self._cles :
AttributeError: 'DictionnaireOrdonne' object has no attribute '_cles'
>>> fruits.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "classe_dico.py", line 108, in sort
    cles_tri = sorted(self._cles)
AttributeError: 'DictionnaireOrdonne' object has no attribute '_cles'
>>>

Voici mon code, qui est assez clair, je l'espère :

#!/usr/local/bin/python3.2
#-*-coding:Latin-1-*

class DictionnaireOrdonne:
	""" Ceci est une classe permettant de construire des dictionnaires ordonnes
	en fonctions des cles.
	La creation d'un dictionnaire est la meme au'un dictionnaire de Python
	
	"""
	def _init_(self, dic={}, **val_rentree):
		"""On definit ici notre constructeur de 3 manieres:
		- dictionnaire vide si on appelle la fonction sans parametre
		- dictionnaire construit a partir d'un autre en parametre
		- avec des couples cles-valeurs en parametres

		"""
 		# On cree les listes vides, parametres accessibles seulement depuis la classe
		self._cles = []
		self._valeurs = []
		if type(dic) not in (dict, DictionnaireOrdonnee):
			raise TypeError( \
				"le type attendu est un dictionnaire usuel ou ordonné")
		# Si jamais des parametres nommes sont rentres, on les ajoute dans les deux listes
		for cle,valeur in val_rentree :
			self[cle] = valeur
		# Si jamais un dictionnaire doit etre copie, on ajoute ses cles et valeurs dans les deux listes
		for cle,valeur in dic :
			self[cle] = valeur
	
	def __getitem__(self, cle):
		"""Cette méthode spéciale est appelée quand on fait objet[cle]
        	Elle redirige vers self._valeurs[index].
		
		"""
		#Si la cle est effectivement dans le dico alors on retourne la valeur correspondante
		if cle in self._cles:
			index = self._cles.index(cle)
			return self._valeurs[index]
		else :
			raise KeyError ("La cle {0} n'est pas presente dans le dictionnaire!!!".format(cle))
		
	def __setitem__(self, cle, valeur):
		"""Cette méthode est appelée quand on entre objet[cle] = valeur
        	On redirige vers self._valeurs[index] = valeur
        	
		"""
		# Si la cle rentree existe deja, alors on remplace l'ancienne valeur par la nouvelle
		if cle in self._cles :
			index = self._cles.index(cle)
			self._valeurs[index] = valeur
		# Sinon, on ajoute le couple a la fin du dictionnaire
		else :
			self._cles.append(cle)
			self._valeurs.append(valeur)
	
	def _delitem_(self, cle):
		"""Cette méthode est appelée quand on entre del objet[cle]
       		 On redirige vers del self._cles[index] et del self._valeurs[index]
        
       		 """
		# Si la cle est bien presente alors on efface le couple cle-valeur
		if cle in self._cles :
		    index = self._cles.index(cle)
		    del self._cles[index]
		    del self._valeurs[index]
		else :
			raise KeyError ("La cle {0} n'est pas presente dans le dictionnaire!!!".format(cle))
	
	def _contains_(self, par):
		""" Cette methode permet de savoir si une valeur ou une cle est dans le dictionnaire.
		Retourne un booleen.
			
		"""
		if par in self._cles :
			return True
		elif par in self._valeurs :
			return True
		else :
			return False
	
	def _len_():
		""" Retourne la longueur du dictionnaire sous forme d'un entier
		
		"""
		return len(self._cles)

	def _str_(self):
		""" Methode permettant d'afficher le dictionnaire ordonnée
		sous la forme d'un dictionnaire habituel

		"""
		chaine = "{"
		for cle, valeur in self.items():
			#On verifie qu'on est pas au dernier élément des listes
			if self._cles.index(cle)<(len(self._cles) - 1) :
				chaine += cle + ":" + valeur + ", "
			else :
				chaine += cle + ":" + valeur + "}"
		
		return "{0}".format(chaine)

	def sort(self):
		"""Methode permettant de trier le dictionnaire en fonction des cles.
		Affiche le dictionnaire trie

		"""
		# On trie la liste des cles
		cles_tri = sorted(self._cles)
		val_tri = []
		for i,elt in enumerate(cles_tri):
			valeur = self[elt]
			val_tri[i]=valeur
		# On met à jour nos listes
		self._cles = cles_tri
		self._valeurs = val_tri
		return _str_(self)

	def reverse(self):
		"""Methode permettant d'inverser le dictionnaire en fonction des cles.
		Affiche le dictionnaire renverse

		"""
		#On crée une copie de la liste des cles
		cles_rev = list(self._cles)
		# On renverse la liste des cles
		cles_rev.renverse()
		val_rev = []
		for i,elt in enumerate(cles_rev):
			valeur = self[elt]
			val_rev[i]=valeur
		self._cles = cles_rev
		self._valeurs = val_rev
		return _str_(self)

	def _iter_(self):
		"""Cette méthode retourne un itérateur parcourant la liste des cles.
		
		"""
		return iter(self._cles)
	
	def keys(self):
		"""Methode retournant et affichant la liste des cles du dictionnaire
		
		"""
		print(self._cles)
		return list(self._cles)

	def values(self):
		"""Methode retournant et affichant la liste des cles du dictionnaire
		
		"""
		print(self._valeurs)
		return list(self._valeurs)
		
	def items(self):
		"""Methode retournant la liste de tuples (cles,valeurs)

		"""
		for i,cle in enumerate(self_cles):
			valeur = self._valeurs[i]
			yield (cles,valeur)
	
	def _add_ (self, dict_ajouter):
		"""Methode permettant d'ajouter un dictionnaire à notre objet
		
		"""
		if type(dict_ajouter) is not type(self):
			raise TypeError(\
				"Impossible de concaténer {0} et {1}".format( \
				type(self), type(dict_ajouter)))
		else :
			# On récupère les clés et valeurs du dico ajouter
			cles_plus = keys(dict_ajouter)
			valeurs_plus = values(dict_ajouter)
			for cle,valeur in zip(cles_plus,valeur_plus):
				self[cle] = valeur
		return self

Citation

Je suis débutant en Python (et pas très avançé en programmation)

>>> fruits.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "classe_dico.py", line 108, in sort
    cles_tri = sorted(self._cles)
AttributeError: 'DictionnaireOrdonne' object has no attribute '_cles'

ça ne sert à rien de lui demander de trier si il n'y a rien dans le dico

Bon ton code est mal recopié, revoir le tuto sur les méthodes spéciales, _init_ s'écrit en fait __init__ et pour les autres du même cas, faire la même chose.

if type(dic) not in (dict, DictionnaireOrdonne)

ça fait un moment qu'on utilise plus ce type de ligne, on utilise isinstance pour vérifier un type et avec la version 3.x je ne pense même pas que ça fonctionne.

if not isinstance(dic, dict):

Il manque un self à def __len__(self)