Bonsoir,
je suis de retour car les dictionnaires s'enregistrer à l'envers. Au lieu d'ajouter les nouvelles valeurs à la fin, celle-ci s'ajoute au début. Un exemple simple :
{'O': ['2', 0, 1], 'Cu': [1, 0, 1]}
Au lieu de :
{'Cu': [1, 0, 1], 'O': ['2', 0, 1]}
Pour ajouter une valeur, je fais : reactif[equation[i]+equation[i+1]]=list()
Merci d'avance, de plus... j'aimerais savoir si vous connaissez un site assez bien documenter sur python et en français, car le site principale semble très vide et les autres parles pas des problèmes qu'on pourrait rencontrer.
Un dictionnaire n'est pas ordonné, il n'y a pas de début ou de fin. Soit tu crées toi-même ton objet dictionnaire ordonné (cf un tuto ici), soit tu attends le type ordereddict de Python 3.2 (de mémoire).
edit : pour la documentation, le site officiel reste le meilleur choix, même s'il est en anglais. De toute façon tu vas bien être obligé de t'y coller.
sous Python 3.x tu as le module collection.OrdereDict
4.3 OrderedDict
Cette nouvelle classe concerne des dictionnaires qui se souviennent de l'ordre dans lequel on y a introduit les paires clé/valeur. Une redéfinition de clé laisse la paire concernée à sa place; un effacement suivi d'une réintroduction la place à la fin du dictionnaire. Il est possible d'introduire les éléments sous forme de dictionnaires ou de listes de paires.
>>> a=collections.OrderedDict({"c":123, "a":987}); a
OrderedDict([('a', 4), ('h', 6)])
>>> a.update({"j":456}); a
OrderedDict([('a', 4), ('h', 6), ('j', 456)])
>>> a.update([(5,9)]); a
OrderedDict([('a', 4), ('h', 6), ('j', 456), (5, 9)])
a.pop(cle) retourne la valeur et supprime la paire clé/valeur selon la clé précisée a.popitem(last=True) retourne et supprime la dernière paire clé/valeur a.popitem(last=False) retourne et supprime la première paire clé/valeu
J'ai trouvé une méthode simple pour résoudre le problème, vu que le dict s'inscrit à l'envers, je réinscrit alors celui-ci dans une autre variable pour que celle-ci soit dans le bon sens :
def reverseDict(dict) :
tmp = {}
for d in dict :
tmp[d] = dict[d]
return tmp
Merci à toute pour vos réponse, et je soutiens encore que les problèmes sont mal renseigner. Pour une variable non défini (Isset existant dans php), tout les codes que je trouvais ne fonctionnait pas, j'ai donc effectué une simple vérification par rapport à la longueur de la chaîne pour éviter de la dépasser.
Le code ci-dessus ne sert à rien puisque les dict python ne sont pas ordonnés.
Citation : jb1993
Merci à toute pour vos réponse, et je soutiens encore que les problèmes sont mal renseigner. Pour une variable non défini (Isset existant dans php), tout les codes que je trouvais ne fonctionnait pas, j'ai donc effectué une simple vérification par rapport à la longueur de la chaîne pour éviter de la dépasser.
Tant qu'a faire, pourquoi ne pas faire un copier/coller du tutoriel, et de placer ce code dans un fichier à part que tu importeras par la suite ?
Je te passes le code:
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 correspondantes à 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]
def __repr__(self):
"""Représentation de notre objet. C'est cette chaîne qui sera affichée
quand on entrera directement le dictionnaire dans l'interpréteur, ou en
utilisant la fonction 'repr'.
"""
chaine = "{"
premier_passage = True
for cle, valeur in self.items():
if not premier_passage:
chaine += ", " # on ajoute la virgule comme séparateur
else:
premier_passage = False
chaine += repr(cle) + ": " + repr(valeur)
chaine += "}"
return chaine
def __str__(self):
"""Fonction appelée quand on souhaite afficher le dictionnaire grâce
à la fonction 'print' ou le convertir en chaîne grâce au constructeur
'str'. On redirige sur __repr__.
"""
return repr(self)
def __len__(self):
"""Retourne la taille du dictionnaire"""
return len(self._cles)
def __contains__(self, cle):
"""Retourne True si la clé est dans la liste des clés, False sinon"""
return cle in self._cles
def __getitem__(self, cle):
"""Retourne la valeur correspondante à la clé si elle existe, lève
une exception KeyError sinon.
"""
if cle not in self._cles:
raise KeyError( \
"la clé {0} ne se trouve pas dans le dictionnaire".format( \
cle))
else:
indice = self._cles.index(cle)
return self._valeurs[indice]
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)
def __delitem__(self, cle):
"""Méthode appelée quand on souhaite supprimer une clé"""
if cle not in self._cles:
raise KeyError( \
"la clé {0} ne se trouve pas dans le dictionnaire".format( \
cle))
else:
indice = self._cles.index(cle)
del self._cles[indice]
del self._valeurs[indice]
def __iter__(self):
"""Méthode de parcours de l'objet. On retourne l'itérateur des clés"""
return iter(self._cles)
def __add__(self, autre_objet):
"""On retourne un nouveau dictionnaire contenant les deux
dictionnaires mis bout à bout (d'abord self puis autre_objet)
"""
if type(autre_objet) is not type(self):
raise TypeError( \
"impossible de concaténer {0} et {1}".format( \
type(self), type(autre_objet)))
else:
nouveau = DictionnaireOrdonne()
# on commence par copier self dans le dictionnaire
for cle, valeur in self.items():
nouveau[cle] = valeur
# on copie ensuite autre_objet
for cle, valeur in autre_objet.items():
nouveau[cle] = valeur
return nouveau
def items(self):
"""Retourne un générateur contenant les couples (cle, valeur)"""
for i, cle in enumerate(self._cles):
valeur = self._valeurs[i]
yield (cle, valeur)
def keys(self):
"""Cette méthode retourne la liste des clés"""
return list(self._cles)
def values(self):
"""Cette méthode retourne la liste des valeurs"""
return list(self._valeurs)
def reverse(self):
"""Inversion du dictionnaire"""
# On créée deux listes vides qui contiendront le nouvel ordre des clés
# et valeurs
cles = []
valeurs = []
for cle, valeur in self.items():
# On ajoute les clés et valeurs au début de la liste
cles.insert(0, cle)
valeurs.insert(0, valeur)
# On met ensuite à jour nos listes
self._cles = cles
self._valeurs = valeurs
def sort(self):
"""Méthode permettant de trier le dictionnaire en fonction de ses clés"""
# On tri les clés
cles_triees = sorted(self._cles)
# On créée une liste de valeurs, encore vide
valeurs = []
# On parcourt ensuite la liste des clés triées
for cle in cles_triees:
valeur = self[cle]
valeurs.append(valeur)
# enfin, on met à jour notre liste de clés et de valeurs
self._cles = cles_triees
self._valeurs = valeurs
@Lord : Je voulais simplement inverser le sens et non pas ordonner le dict vu que j'avais l'habitude qu'un ajout se rajoute à la fin.
Et l'autre problème que j'avais rencontrer, c'était pour vérifier si une variable existait, j'ai utilisé tout les codes trouvé sur google avant de finalement renoncé et de crée une simple condition qui vérifie que je vais pas dépasser la taille du tableau, avant.
Si tu crois que les valeurs s'ajoutent au début dans un dictionnaire classique, tu te trompes. C'est juste un "hasard", et tu ne peux pas garantir d'ordre particulier dessus.
Et isset, c'est une erreur de la nature.
Et l'autre problème que j'avais rencontrer, c'était pour vérifier si une variable existait, j'ai utilisé tout les codes trouvé sur google avant de finalement renoncé et de crée une simple condition qui vérifie que je vais pas dépasser la taille du tableau, avant.
Sérieusement je voudrais bien voir ce code.
Citation
Et isset, c'est une erreur de la nature.
Purée, oui...
Citation
je suis de retour car les dictionnaires s'enregistrer à l'envers. Au lieu d'ajouter les nouvelles valeurs à la fin, celle-ci s'ajoute au début
As-tu un intérêt à faire cela sur un dico ? Franchement je ne vois pas.
Sachant que pour appeler une valeur, tu l'appelles par sa key.
Si tu avais donné l'intérêt peut-être une autre solution aurait pu être proposée.
ifi+1<(len(string))andstring[i+tmpNameLen].isdigit()
Sinon, c'est vrai, dict organise bien le tableau par ordre alphabétique, j'avais pas tester avec d'autre valeur.
Je souhaitais utiliser dict pour accéder facilement à une valeur par rapport à son nom, mais au vu de ceci, je vais retourner au list et utiliser l'index.
i contient l'index d'un caractère d'une équation qui est sous la forme d'un string. tmpNameLen est la variable qui me permet de voir ce qu'il y a après ce caractère, c'est celle-ci qui cause le dépassement de tampon.
De plus, j'ai commencé à utiliser index et j'ai déjà une erreur (Normal) :
File "/home/jb/Bureau/Equation-bilan/fonction.py", line 27, in cutEquation
tmpNameIndex = atome.index(tmpName)
ValueError: list.index(x): x not in list
Bon je dois partir là, mais si tu veux qu'on t'aide, tu mets ce que tu as en entrée, ce que tu veux en sortie, car un bout de code où tu démarres par une condition, c'est un peu short.
D'accord, merci pour ton aide ! J'ai réussis à résoudre ce petit problème et je vais continuer d'avancer en espérant que j'arrêterais de vous embêtez sur le forum.
D'accord, merci pour ton aide ! J'ai réussis à résoudre ce petit problème et je vais continuer d'avancer en espérant que j'arrêterais de vous embêtez sur le forum.
Mais de rien, t'as fais comment pour résoudre ton problème finalement?
Tu nous embêtes pas, un forum est fait pour ça, de ton côté il faut accepter les critiques
Le problème c'est que tu ne dis pas ce que tu as en entrée et ce que tu veux en sortie, et du coup peut-être que tu manques une astuce ou un code plus optimisé. N'est surtout pas peur de présenter ton code, des gens compétents en python sont là.
Voilà ! Comme ça, vous avez mon avancez dans le projet que je commence très mal à ma vue, le code est similaire à celui que j'avais fais en C++, mais plus dure à lire.
Alors, je rentre un string : equation='Cu + O2->Cu2 + O'
et le programme doit résoudre l'équation en expliquant la mise en œuvre, mon ancien code arrivait à gérer tout les cas sauf les doubles molécules et les ions positifs ou négatifs.
Voici une image en gros de l'entrer et la sortie avec mon vieux programme :
Merci de vais utiliser votre astuce pour la fonction.
Concernant l'algorithme, il a été créer par mes petites mains, le plus dure étant juste de trouver tout les cas possibles. J'ai donc déjà la base de l'algorithme de base du programme que je peux vous fournir en c++ (La partie la plus simple que je suis entrain de refaire tien en 5 cas différent).
J'ai néanmoins un léger problème avec mon code, j'écris généralement les longues lignes en premier afin de savoir ce que je devrais faire, néanmoins, celui-ci me cause une erreur que je ne réussis à trouver.
if alias['reactifJointure'] == True and alias['produitJointure'] == True :
print 'a'
""" Le réactif à une jointure droite """
elif alias['reactifJointure'] == True :
print 'a'
""" Le produit à une jointure droite """
elif alias['produitJointure'] == True :
print 'a'
Des problèmes au niveau de l'indentation je suppose.
if alias['reactifJointure'] == True and alias['produitJointure'] == True :
print 'a' # indentation avec 4 espaces comme prédit par la norme voir FAQ sur les erreurs courantes.
""" Le réactif à une jointure droite """
elif alias['reactifJointure'] == True :
print 'a'
""" Le produit à une jointure droite """
elif alias['produitJointure'] == True :
print 'a'
Tes indentations tu les fais avec la touche tab ou avec les espaces?
Pour ton edit
for i in string:
#traitement sur chaque caractère de la chaine string
J'utilise la touche tab pour l'indentation pour que les développeurs puissent utiliser leur propre espacement.
Tu feras attention j'ai fais un edit sur le post précédent.
Sinon tu feras aussi attention à mon code qui est utilisé avec les espaces. Tu ne peux pas mélanger tabulation et espacement, c'est très important. Et tes erreurs viennent de là je pense.
J'ai vérifié rapidement les tabulations et espacement avec world (Vu que je suis au lycée), et celle-ci semble avoir aucun problème.
Sinon, mon edit, c'était pour savoir s'il est possible de voir le caractère suivant sans passer par la boucle (D'où le i + 1 qui signifie que je veux voir le caractère suivant sans quitter la boucle car je vérifie ensuite si je peux récupérer d'autre donnée).
Sinon, mon edit, c'était pour savoir s'il est possible de voir le caractère suivant sans passer par la boucle (D'où le i + 1 qui signifie que je veux voir le caractère suivant sans quitter la boucle car je vérifie ensuite si je peux récupérer d'autre donnée).
J'avoue que j'ai pas très bien compris ce que tu disais, mais si tu veux travailler par index pour comparer 2 lettres (lettre + lettre suivante), tu peux avec une boucle for.
for i in range(len(string)-1):
if string[i]==string[i+1]:
#traitement
Citation
J'ai vérifié rapidement les tabulations et espacement avec world (Vu que je suis au lycée), et celle-ci semble avoir aucun problème.
Vérifie plutôt chez toi quand tu auras les outils adéquates
Je vais utiliser votre technique avec la boucle for.
Sinon, j'ai rapidement vérifier le fichier avec nano depuis mon pc et d'après ce que je vois, il n'y a aucun problème d'indentation.
Dois-je donner les lignes au dessus des conditions ? Car juste au dessus, j'ai la liste d'alias.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Blond, bouclé, toujours le sourire aux lèvres...