Combinaison de deux listes et suppression des doublons, sans supprimer les doublons de la liste d'origine
J'ai deux listes que je dois combiner, les doublons de la première liste étant ignorés. .. Un peu difficile à expliquer, alors laissez-moi vous montrer un exemple de ce que le code ressemble, et ce que je veux en conséquence.
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
# The result of combining the two lists should result in this list:
resulting_list = [1, 2, 2, 5, 7, 9]
Vous remarquerez que le résultat a la première liste, incluant ses deux valeurs "2", mais le fait que second_list a également une valeur supplémentaire de 2 et 5 n'est pas ajouté à la première liste.
Normalement, pour quelque chose comme ceci, j'utiliserais des ensembles, mais un ensemble sur first_list purgerait les valeurs en double qu'il possède déjà. Je me demande donc simplement quel est le meilleur moyen/le plus rapide de réaliser cette combinaison souhaitée.
Merci.
Vous devez ajouter à la première liste les éléments de la deuxième liste qui ne figurent pas dans la première - les ensembles sont le moyen le plus simple de déterminer quels éléments ils sont, comme ceci:
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
in_first = set(first_list)
in_second = set(second_list)
in_second_but_not_in_first = in_second - in_first
result = first_list + list(in_second_but_not_in_first)
print result # Prints [1, 2, 2, 5, 9, 7]
Ou si vous préférez les one-liners 8-)
print first_list + list(set(second_list) - set(first_list))
resulting_list = list(first_list)
resulting_list.extend(x for x in second_list if x not in resulting_list)
Vous pouvez utiliser des ensembles:
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
resultList= list(set(first_list) | set(second_list))
print(resultList)
# Results in : resultList = [1,2,5,7,9]
Vous pouvez réduire cela à une seule ligne de code si vous utilisez numpy:
a = [1,2,3,4,5,6,7]
b = [2,4,7,8,9,10,11,12]
sorted(np.unique(a+b))
>>> [1,2,3,4,5,6,7,8,9,10,11,12]
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
print( set( first_list + second_list ) )
Le plus simple pour moi est:
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
merged_list = list(set(first_list+second_list))
print(merged_list)
#prints [1, 2, 5, 7, 9]
resulting_list = first_list + [i for i in second_list if i not in first_list]
Cela pourrait aider
def union(a,b):
for e in b:
if e not in a:
a.append(e)
La fonction union fusionne la deuxième liste en première, sans dupliquer un élément d'un, s'il est déjà dans. Semblable à l'opérateur du groupe de postes. Cette fonction ne change pas b. Si a = [1,2,3] b = [2,3,4]. Après l'union (a, b) fait a = [1,2,3,4] et b = [2,3,4]
Vous pouvez également combiner les réponses de RichieHindle et de Ned Batchelder pour un algorithme casse moyenne O (m + n) préservant l'ordre:
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
fs = set(first_list)
resulting_list = first_list + [x for x in second_list if x not in fs]
assert(resulting_list == [1, 2, 2, 5, 7, 9])
Notez que x in s a une complexité dans le pire des cas de O(m) , de sorte que la complexité pire-cas de ce code est toujours O (m * n).
simplement comme ci-dessous:
resulting_list = list(set(resulting_list))
Basé sur la recette :
result_list = list (set (). union (first_list, second_list))
list1 = [1, 2, 1]
list2 = [2, 3, 4, 3]
def extendList(list1, list2):
return list(set(list1+list2))
list12 = extendList(list1, list2)
print(list12)
Sortie: [1, 2, 3, 4]
L1 = [1,2,3,3,4,4]
L2 = [3,4,5,6,6,6]
L1.extend(L2)
L3 =[]
[L3.append(num) for num in L1 if num not in L3]
print L3
[1, 2, 3, 4, 5, 6]
[Finished in 0.5s]
first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]
newList=[]
for i in first_list:
newList.append(i)
for z in second_list:
if z not in newList:
newList.append(z)
newList.sort()
print newList
[1, 2, 2, 5, 7, 9]