Renommer les doublons dans une liste peut être un problème difficile à résoudre car cela vous oblige à identifier les doublons, puis à décider comment les renommer. Cela peut être particulièrement difficile si la liste contient de nombreux éléments ou si les éléments sont des objets complexes. De plus, renommer les doublons peut vous obliger à modifier d'autres parties de votre code qui reposent sur les noms d'origine des éléments afin qu'ils continuent à fonctionner correctement.
def rename_duplicates(lst):
seen = set()
new_lst = []
for item in lst:
if item not in seen:
seen.add(item)
new_lst.append(item)
else:
new_item = item + '_1' # append a suffix to make it unique
while new_item in seen: # increment the suffix until it's unique
suffix = int(new_item.split('_')[-1]) + 1 # get the last number and add one to it
new_item = '{}_{}'.format('_'.join(new_item.split('_')[:-1]), suffix)
seen.add(new_item) # add the newly created item to the set of seen items
new_lst.append(new_item) # append the newly created item to the list
return new
_lst
# Ce code définit une fonction appelée rename_duplicates qui prend une liste comme argument.
def rename_duplicates(lst):
# Il crée ensuite un ensemble vide appelé vu et une liste vide appelée new_lst.
vu = set ()
nouveau_lst = []
# Il parcourt ensuite les éléments de la liste et vérifie s'ils sont déjà dans l'ensemble des éléments vus.
pour l'élément dans la liste :
si l'élément n'est pas vu : # Si ce n'est pas le cas, il l'ajoute à l'ensemble des éléments vus et l'ajoute à la nouvelle liste.
vu.add(item)
new_lst.append(item) # Si c'est le cas, il crée une version unique de cet élément en ajoutant un suffixe (par exemple, '_1') à son nom et vérifie si cet élément nouvellement créé est déjà dans l'ensemble des éléments vus.
else : # Si c'est le cas, il incrémente le suffixe jusqu'à ce qu'il trouve une version inutilisée de ce nom d'élément et ajoute cet élément nouvellement créé à la fois à l'ensemble des éléments vus et à la nouvelle liste avant de renvoyer cette nouvelle liste à la fin de son exécution.
nouvel_article = article + '_1'
tandis que new_item est vu : # incrémente le suffixe jusqu'à ce qu'il soit unique
suffixe = int(new_item.split('_')[-1]) + 1 # obtenir le dernier numéro et en ajouter un
nouvel_élément = '{}_{}'.format('_'.join(nouvel_élément.split('_')[:-1]), suffixe)
vu.add(nouveau
Listes en Python
Les listes en Python sont l'une des structures de données les plus couramment utilisées. Ils sont utilisés pour stocker une collection d'éléments, qui peuvent être de n'importe quel type, y compris d'autres listes. Les listes sont modifiables, ce qui signifie qu'elles peuvent être modifiées après leur création. Ils prennent également en charge des opérations telles que l'indexation, le découpage et la concaténation.
Pour créer une liste en Python, vous utilisez des crochets et séparez chaque élément par une virgule :
ma_liste = [1, 2, 3]
Vous pouvez accéder aux éléments individuels de la liste en utilisant leur index :
ma_liste[0] # renvoie 1
ma_liste[1] # renvoie 2
ma_liste[2] # renvoie 3
Vous pouvez également utiliser des indices négatifs pour accéder aux éléments à partir de la fin de la liste :
ma_liste[-1] # renvoie 3 (le dernier élément)
Vous pouvez ajouter des éléments à une liste en utilisant la méthode append() :
my_list.append(4) # ajoute 4 à la fin de la liste
Vous pouvez supprimer des éléments d'une liste à l'aide des méthodes remove() ou pop() :
my_list.remove(3) # supprime 3 de la liste
my_list.pop(2) # supprime et renvoie 2 (le troisième élément) de la liste
Renommer les doublons dans la liste en Python
Renommer les doublons dans la liste en Python est une tâche courante lorsqu'il s'agit de listes. Cela implique de remplacer les éléments en double dans une liste par des valeurs uniques. Cela peut être fait en utilisant la fonction set(), qui supprime tous les éléments en double d'une liste et renvoie une nouvelle liste avec uniquement des éléments uniques. La fonction set() peut également être utilisée pour renommer les doublons en lui fournissant un mappage des anciennes valeurs aux nouvelles valeurs. Par exemple, si vous avez une liste de nombres et que vous souhaitez remplacer tous les doublons par leurs carrés respectifs, vous pouvez utiliser le code suivant :
# Créer un dictionnaire vide
mappage = {}
# Itérer sur la liste d'origine
pour l'élément dans my_list :
# Vérifier si l'élément existe déjà dans le dictionnaire
si l'élément n'est pas dans le mappage :
# Sinon, ajoutez-le au dictionnaire et attribuez-lui son carré comme valeur
mappage[élément] = élément * élément
# Créer une liste de résultats vide
liste_résultat = []
# Itérer à nouveau sur la liste d'origine et remplacer chaque élément par son carré du dictionnaire pour i dans my_list : result_list.append(mapping[i])
# Imprimer le résultat print(result_list)
