Combiner deux listes et supprimer les doublons, sans supprimer les doublons dans la liste d'origine

J'ai deux listes que je dois combiner où la deuxième liste a tous les doublons de la première liste ignorés. .. Un peu difficile à expliquer, alors laissez-moi vous montrer un exemple de ce à quoi ressemble le code 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, y compris 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 ça, j'utiliserais des ensembles, mais un ensemble sur first_list purgerait les valeurs en double qu'il a déjà. Je me demande donc simplement quel est le moyen le meilleur / le plus rapide pour 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 de 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 ramener 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 ) )

resulting_list = first_list + [i for i in second_list if i not in first_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]

Vous pouvez également combiner les réponses de Ned et de RichieHindle Batchelder pour une moyenne cas O (m + n) algorithme qui préserve 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 la x in scomplexité dans le pire des cas est O (m) , donc la complexité dans le pire des cas de ce code est toujours O (m * n) .

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 dans la première, sans dupliquer un élément de a, s'il est déjà dans a. Similaire à l'opérateur set union. 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]

Basé sur la recette :

liste_résultante = liste (set (). union (première_liste, deuxième_liste))

    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]