lenguaje - python tutorial

Compruebe si dos listas desordenadas son iguales

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo comparar eficientemente dos listas desordenadas (no conjuntos) en Python? 9 respuestas

Estoy buscando una manera fácil (y rápida) de determinar si dos listas desordenadas contienen los mismos elementos:

Por ejemplo:

[''one'', ''two'', ''three''] == [''one'', ''two'', ''three''] : true
[''one'', ''two'', ''three''] == [''one'', ''three'', ''two''] : true
[''one'', ''two'', ''three''] == [''one'', ''two'', ''three'', ''three''] : false
[''one'', ''two'', ''three''] == [''one'', ''two'', ''three'', ''four''] : false
[''one'', ''two'', ''three''] == [''one'', ''two'', ''four''] : false
[''one'', ''two'', ''three''] == [''one''] : false

Espero hacer esto sin usar un mapa.

Answer 1

¿Qué hay de obtener la representación en cadena de las listas y compararlas?

>>> l1 = [''one'', ''two'', ''three'']
>>> l2 = [''one'', ''two'', ''three'']
>>> l3 = [''one'', ''three'', ''two'']
>>> print str(l1) == str(l2)
True
>>> print str(l1) == str(l3)
False

Answer 2

Desea ver si contienen los mismos elementos, pero no le importa el pedido.

Puedes usar un set:

>>> set([''one'', ''two'', ''three'']) == set([''two'', ''one'', ''three''])
True

Pero el objeto conjunto en sí solo contendrá una instancia de cada valor único y no conservará el orden.

>>> set([''one'', ''one'', ''one'']) == set([''one''])
True

Por lo tanto, si el seguimiento de duplicados / longitud es importante, probablemente también desee verificar la longitud:

def are_eq(a, b):
return set(a) == set(b) and len(a) == len(b)

Answer 3

Python tiene un tipo de datos incorporado para una colección desordenada de cosas (hashable), llamada set . Si convierte ambas listas a conjuntos, la comparación no estará ordenada.

set(x) == set(y)

Documentación en set

EDITAR: @mdwhatcott señala que desea verificar si hay duplicados. set ignora, por lo que necesita una estructura de datos similar que también haga un seguimiento del número de elementos en cada lista. Esto se llama un multiset ; La mejor aproximación en la biblioteca estándar es una collections.Counter .

>>> import collections
>>> compare = lambda x, y: collections.Counter(x) == collections.Counter(y)
>>>
>>> compare([1,2,3], [1,2,3,3])
False
>>> compare([1,2,3], [1,2,3])
True
>>> compare([1,2,3,3], [1,2,2,3])
False
>>> 

Answer 4

Si los elementos siempre están casi ordenados como en su ejemplo, entonces .sort() ( timsort ) timsort debe ser rápido:

>>> a = [1,1,2]
>>> b = [1,2,2]
>>> a.sort()
>>> b.sort()
>>> a == b
False

Si no desea ordenar in situ, puede usar sorted() .

En la práctica, siempre puede ser más rápido que las collections.Counter() (a pesar de que asintóticamente el tiempo O(n) es mejor que O(n*log(n)) para .sort() ). Mídelo; Si es importante.

Answer 5

Si no desea utilizar la biblioteca de colecciones, siempre puede hacer algo como esto: dado que a y b son sus listas, lo siguiente devuelve el número de elementos coincidentes (considera el orden).

sum([1 for i,j in zip(a,b) if i==j])

Por lo tanto,

len(a)==len(b) and len(a)==sum([1 for i,j in zip(a,b) if i==j])

será True si ambas listas son iguales, contienen los mismos elementos y en el mismo orden. False contrario.

Por lo tanto, puede definir la función de comparación como la primera respuesta anterior, pero sin la biblioteca de colecciones.

compare = lambda a,b: len(a)==len(b) and len(a)==sum([1 for i,j in zip(a,b) if i==j])

y

>>> compare([1,2,3], [1,2,3,3])
False
>>> compare([1,2,3], [1,2,3])
True
>>> compare([1,2,3], [1,2,4])
False

Answer 6

Suponiendo que ya sabe que las listas son de igual tamaño, lo siguiente garantizará Verdadero si y solo si dos vectores son exactamente iguales (incluido el orden)

functools.reduce(lambda b1,b2: b1 and b2, map(lambda e1,e2: e1==e2, listA, ListB), True)

Ejemplo:
>>> desde functools import reduce
>>> def compvecs (a, b):
... devuelva reducir (lambda b1, b2: b1 y b2, mapa (lambda e1, e2: e1 == e2, a, b), Verdadero)
...
>>> compvecs (a = [1,2,3,4], b = [1,2,4,3])
Falso
>>> compvecs (a = [1,2,3,4], b = [1,2,3,4])
Cierto
>>> compvecs (a = [1,2,3,4], b = [1,2,4,3])
Falso
>>> compare_vectors (a = [1,2,3,4], b = [1,2,2,4])
Falso
>>>

Answer 7

Una respuesta de línea a la pregunta anterior es:

deje que las dos listas sean list1 y list2, y su requisito es asegurarse de que dos listas tengan los mismos elementos, entonces según mi criterio, el siguiente enfoque será el mejor:

if ((len(list1) == len(list2)) and
(all(i in list2 for i in list1))):
print ''True''
else:
print ''False''

El fragmento de código anterior funcionará según su necesidad, es decir, si todos los elementos de list1 están en list2 y vice-verse.

Pero si solo quiere comprobar si todos los elementos de la lista1 están presentes en la lista2 o no, debe usar el siguiente código:

if all(i in list2 for i in list1):
print ''True''
else:
print ''False''

La diferencia es que, más adelante se imprimirá True, si list2 contiene algunos elementos adicionales junto con todos los elementos de list1. En palabras simples, asegurará que todos los elementos de list1 estén presentes en list2, independientemente de si list2 tiene algunos elementos adicionales o no.

Answer 8

sorted(x) == sorted(y)

Copiando desde aquí: compruebe si dos listas desordenadas son iguales

Creo que esta es la mejor respuesta para esta pregunta porque

1. Es mejor que usar el contador como se indica en esta respuesta.
2. x.sort () ordena x, que es un efecto secundario. ordenado (x) devuelve una nueva lista.