¿Existe alguna forma rápida de verificar si un juego contiene completamente otro?Python: ver si un conjunto contiene otro por completo
Algo así como:
>>>[1, 2, 3].containsAll([2, 1])
True
>>>[1, 2, 3].containsAll([3, 5, 9])
False
¿Existe alguna forma rápida de verificar si un juego contiene completamente otro?Python: ver si un conjunto contiene otro por completo
Algo así como:
>>>[1, 2, 3].containsAll([2, 1])
True
>>>[1, 2, 3].containsAll([3, 5, 9])
False
Esos son listas, pero si realmente quieren decir juegos que puede utilizar el método issubset.
>>> s = set([1,2,3])
>>> t = set([1,2])
>>> t.issubset(s)
True
>>> s.issuperset(t)
True
Para una lista, no podrá hacer nada mejor que comprobar cada elemento.
Para completar: esto es equivalente a issubset
(aunque posiblemente un poco menos explícito/legible):
>>> set([1,2,3]) >= set([2,1])
True
>>> set([1,2,3]) >= set([3,5,9])
False
Una opción se deja intacto - resta:
>>> {1, 2} - {1, 2, 3}
set([])
>>> {1, 2, 3} - {1, 2}
set([3])
Básicamente se compruebe lo los elementos en la primera lista no están en la segunda lista.
Me pareció muy práctico, ya que se podía mostrar lo que faltan valores:
>>> def check_contains(a, b):
... diff = a - b
... if not diff:
... # All elements from a are present in b
... return True
... print('Some elements are missing: {}'.format(diff))
... return False
...
>>> check_contains({1, 2}, {1, 2, 3})
True
>>> check_contains({1, 2, 3}, {1, 2})
Some elements are missing: set([3])
False
Posiblemente una exageración, pero otra variación: Si se cruzan dos conjuntos, y el conjunto resultante contiene todas las entradas únicas de su candidato subconjunto, entonces el conjunto candidato es de hecho un subconjunto.
En otras palabras: Si la cardinalidad de un conjunto en cuestión es igual a la cardinalidad resultante de su conjunto intersectado por otro conjunto, entonces es un subconjunto de ese conjunto.
a = [2,1,3,3]
b = [5,4,3,2,1]
set(a).intersection(set(b)) == set(a)
>>True
Let 'A = conjunto (a)' y 'B = conjunto (b)' a la cordura. Entonces esta comparación es eficientemente reductible a 'len (A.intersection (B)) == len (A)'. Es decir, los conjuntos mismos no necesitan * ser * comparados con elementos; solo se debe comparar la cardinalidad de estos conjuntos. Incluso esta optimización es probablemente insuficiente para hacer que este enfoque sea preferible, sin embargo. Los enfoques '' issubset() 'y' <= 'dramáticamente más legibles * y * eficientes son casi seguramente lo que todos quieren. –
Debajo de la función return 0 si la lista principal no contiene la sublista completamente y 1 si contiene completamente.
def islistsubset(sublist,mainlist):
for item in sublist:
if item in mainlist:
contains = 1
else:
contains = 0
break;
return contains
Esto es O (n^2) mientras se usan las operaciones de conjunto, ya que en algunas de las respuestas existentes es mucho más rápido. Esto también se puede escribir simplemente 'cualquier (elemento en la lista principal para el elemento en la sublista)'. De acuerdo – Iguananaut
de hecho yo también podría escribir def islistsubset (sublista, mainlist): contiene = 1 para elemento de lista secundaria: si el artículo en mainlist: continuar otra cosa: contiene = 0 ruptura; return contiene Tan solo 2 asignaciones por llamada –
@BobinMottiThomas Puede simplemente devolver True o False directamente sin crear ninguna variable temporal. para el elemento en la lista_a: si el elemento no está en la lista_b: return False return True –
>>> set([1,2,3]).issuperset(set([2,1]))
True
>>>
>>> set([1,2,3]).issuperset(set([3,5,9]))
False
Considere formatear su respuesta correctamente y agregue alguna explicación. – Sam
me sale una extraña sensación de dejavu cuando veo esta respuesta –