maliste=["Paul","Joe","Paul","Martine", "Joe", "Paul"]
dic_occurences = {}
for i in range(0, len(maliste)) :
element = maliste[i]
if element not in dic_occurences :
dic_occurences[element] = 1
else :
maliste[i] = maliste[i] + str(dic_occurences[element])
dic_occurences[element] += 1
print maliste
Ceci ne fonctionne pas puisque le premier «Paul» n'est pas renommé en «Paul1», de plus, un Counter serait plus judicieux qu'un dictionnaire, et ce n'est pas comme ça qu'on itère sur une liste en Python.
Voici la solution que je propose :
from collections import Counter
maliste=["Paul","Joe","Paul","Martine", "Joe", "Paul"]
# On compte le nombre d'occurrences de chaque nom
occurrences = Counter(maliste)
# On crée un dictionnaire répertoriant les suffixes à ajouter (pas de suffixe quand une seule occurrence)
suffixes = {name: list(range(1, count + 1)) for name, count in occurrences.items() if count > 1}
# On remplace les noms en ajoutant leur suffixe si besoin
maliste = ['{}{}'.format(name, suffixes[name].pop(0)) if name in suffixes else name for name in maliste]
EDIT: remplacement des 3 lignes du compteur (création d'un compteur vide puis ajout des éléments) par la création d'un compteur depuis la liste
Ta solution est sympa Olygrim par contre je me demande si c'est pas un peu bourrin si on a une liste très très (très) longue, étant donné qu'au final tu dois avoir une complexité un peu de foufou avec ton count à chaque itération. Sinon oui, le changement avec le else m'a déjà emmerdé plus d'une fois (et la première fois rend un peu fou si tu ne sais pas)
Edit pour entwanne : Ca va, on a juste à bouger une ligne pour avoir le comportement voulu ...
maliste=["Paul","Joe","Paul","Martine", "Joe", "Paul"]
dic_occurences = {}
for i in range(0, len(maliste)) :
element = maliste[i]
if element not in dic_occurences :
dic_occurences[element] = 1
else :
dic_occurences[element] += 1
maliste[i] = maliste[i] + str(dic_occurences[element])
print maliste
Parfois il vaut mieux un exemple simple plutôt qu'un truc bourrin, même si c'est pas forcément bien codé, surtout quand il s'agit d'un problème "simple" comme ça. Donc sérieux osef de la boucle avec le range ...
"je me demande si c'est pas un peu bourrin si on a une liste très très (très) longue"
C'est exactement ce que je me suis dit, et au final une boucle classique me paraît plus pertinent (rien que pour éviter de calculer 2 fois maliste.count(elt))
Ta solution est sympa Olygrim par contre je me demande si c'est pas un peu bourrin si on a une liste très très (très) longue
Il ne faut pas sous estimé la méthode count, c'est un binding C très efficace... et avant d'arriver à la surpasser, il va falloir faire des tests avec d'autres solutions que celles proposées. Elle n'est certes pas la plus propre, mais je pense que c'est la plus efficace !
Cependant j'aime bien la solution pythonique d'entwanne, qui pour ce genre d'exercice est la solution qui me semble la plus lisible et maintenable à long terme.
Edit pour entwanne : Ca va, on a juste à bouger une ligne pour avoir le comportement voulu ...
Non, dans ta nouvelle monture, tu ajoutes un «1» même aux noms qui n'ont pas de doublons. Tu testes tes bouts de code avant de les poster ?
Olygrim a écrit:
Tu peux directement utiliser ta liste en argument de Counter() pour avoir le compte. Merci à Sam&Max
Oui, merci, j'avais oublié cette possibilité.
Olygrim a écrit:
PS: Avez-vous remarqué que l'ordre des étapes dans une intention (une compréhension) est différent si on a ou non la condition else.
Que veux-tu dire par là ? Le mot-clef else est obligatoire dans l'opérateur ternaire. Tu peux avoir un if sans else dans les listes en intention, mais ça n'est pas un ternaire et ça ne se place pas au même endroit.
C'est marrant parce que la boucle range() m'a aussi fait tiquer . Après c'est juste parce qu'on m'a souvent répété que c'était pas propre. Je n'ai pas le niveau pour débattre mais j'aurai plutôt utiliser enumerate() à la place:
for ind, elt in enumerate(maliste) :
if elt not in dic_occurences :
dic_occurences[elt] = 1
else :
dic_occurences[elt] += 1
maliste[ind] = maliste[ind] + str(dic_occurences[elt])
Par contre Jevanni ton résultat renvoie Martine1 au lieu de Martine
"Il ne faut pas sous estimé la méthode count"
Thx pour l'info oldP. Même si j'en abuse quand même pas mal (3 fois dans mon code). C'est d'ailleurs pour ça que j'étais pas trop satisfait de la qualité de ce code
Même si j'en abuse quand même pas mal (3 fois dans mon code:lol:).
Si on souhaite quelque chose d'efficace, même si le nombre de boucles peut paraître aberrant, ce qu'on regardera c'est l'efficacité avant tout, mais si ce n'est pas ce qu'on recherche, je préfère la solution d'entwanne...
En fait, il se trouve que le iffait partie intégrante de la syntaxe des listes en intention (ainsi que des générateurs, ensembles ou dictionnaires), permettant de filtrer les éléments.
Par contre, l'expression à placer au début peut-être n'importe quelle expression python, ternaires inclus (... if ... else ...).
Ainsi, il est possible d'écrire [elem + 1 if elem > 0 else elem for elem in elements if elem < 10].
J'avais mal compris ta question car je croyais que tu parlais d'ordre d'évaluation et non d'ordre dans l'écriture.
Celle d'Etwanne est la plus pythonique. Si je lis le code d'Etwanne, je vois tout de suite ce qu'il veut faire. Si je lis le code de Jevanni, je me dis: il ré-invente la roue.
Lequel est le plus performant? Tu peux faire quelques timeit, mais à mon avis c'est la solution d'Etwanne qui sera devant.
Mon code n'a pas exactement le résultat voulu, contrairement aux deux autres solutions fournis si l'on recherche strictement ce que tu as présenté. Dans le 1er code que j'ai donné la 1ère occurrence n'a pas de "1" à la fin. Dans le second (qui est encore plus faux en fait), tous les noms, mêmes ceux présents une fois, ont un 1 lors de la 1ère occurrence.
Le second point du "débat" vient du fait que mon code n'est pas propre. Tout d'abord etwanne a présenté l'utilisation d'un module spécifique, ce qui rend le plus "agréable" (il n'y a pas besoin d'utiliser de dic). Dans un second temps j'utilise une boucle for avec un range, ce qui est d'habitude à éviter.
En terme de performance je pense que la solution d'etwanne est plus rapide avec un très grand nombre de noms. A vérifier.
Après tout dépend ce que tu veux, en terme de performance pure, à moins que tu es vraiment beaucoup de noms à gérer, la différence ne devrait pas trop se faire sentir.
"C'est quoi la différence entre la solution de Jevanni et celle de Olygrim/entwanne concrètement ? est elle plus performante ?"
La différence principale est la qualité de lecture (point super important en python). Après en terme de performance, j'aurai tendance à dire qu'on s'en fout un peu. A moins que tu es beaucoup d'éléments dans ta liste, le temps de traitement ne doit pas vraiment être perceptible (j'ai pas testé, mais pour moi c'est secondaire pour ce cas précis).
Précepte: Le mieux est l'ennemi du bien
renommer doublons dans liste
× 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.
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique