Combinar dos listas y eliminar duplicados, sin eliminar duplicados en la lista original

Tengo dos listas que necesito combinar donde la segunda lista tiene cualquier duplicado de la primera lista ignorado. .. Un poco difícil de explicar, así que déjame mostrarte un ejemplo de cómo se ve el código y lo que quiero como resultado.

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]

Notará que el resultado tiene la primera lista, incluidos sus dos valores "2", pero el hecho de que second_list también tiene un valor adicional de 2 y 5 no se agrega a la primera lista.

Normalmente, para algo como esto, usaría conjuntos, pero un conjunto en first_list eliminaría los valores duplicados que ya tiene. Así que simplemente me pregunto cuál es la mejor / más rápida forma de lograr esta combinación deseada.

Gracias.

Debe agregar a la primera lista los elementos de la segunda lista que no están en la primera; los conjuntos son la forma más fácil de determinar qué elementos son, así:

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]

O si lo prefiere de una sola línea 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)

Puedes usar conjuntos:

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]

Puede reducir esto a una sola línea de código si usa 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]

Lo más simple para mí es:

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]

También puede combinar las respuestas de RichieHindle y Ned Batchelder para un algoritmo O (m + n) de caso promedio que preserva el orden:

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])

Tenga en cuenta que x in stiene una complejidad en el peor de los casos de O (m) , por lo que la complejidad del peor de los casos de este código sigue siendo O (m * n) .

Esto puede ayudar

def union(a,b):
    for e in b:
        if e not in a:
            a.append(e)

La función de unión fusiona la segunda lista con la primera, sin duplicar un elemento de a, si ya está en a. Similar a establecer un operador de unión. Esta función no cambia b. Si a = [1,2,3] b = [2,3,4]. Después de la unión (a, b) hace a = [1,2,3,4] yb = [2,3,4]

Basado en la receta :

lista_resultantes = lista (conjunto (). unión (primera_lista, segunda_lista))

    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]