Comment vérifier si tous les éléments d'une liste sont présents dans une autre liste?

J'ai deux listes dire

List1 = ['a','c','c']
List2 = ['x','b','a','x','c','y','c']

Maintenant, je veux savoir si tous les éléments de la Liste 1 sont là dans la liste 2. Dans ce cas, tous y sont. Je ne peux pas utiliser la fonction de sous-ensemble, car je peux avoir des éléments répétés dans les listes. Je peux utiliser une boucle for pour compter le nombre d'occurrences de chaque élément dans la liste 1 et de voir si il est inférieur ou égal au nombre d'occurrences dans la liste 2. Est-il une meilleure façon de le faire?

Grâce.

source d'informationauteur pogo

python

Lorsque le nombre d'occurrences n'est pas grave, vous pouvez toujours utiliser le sous-ensemble de la fonctionnalité, en créant un jeu à la volée:

>>> list1 = ['a', 'c', 'c']
>>> list2 = ['x', 'b', 'a', 'x', 'c', 'y', 'c']
>>> set(list1) < set(list2)
True

Si vous avez besoin de vérifier si chaque élément se montre au moins autant de fois dans la deuxième liste, comme dans la première liste, vous pouvez utiliser le type de Compteur et de définir votre propre sous-ensemble de la relation:

>>> from collections import Counter
>>> def counterSubset(list1, list2):
        c1, c2 = Counter(list1), Counter(list2)
        for k, n in c1.items():
            if n > c2[k]:
                return False
        return True

>>> counterSubset(list1, list2)
True
>>> counterSubset(list1 + ['a'], list2)
False
>>> counterSubset(list1 + ['z'], list2)
False

Si vous avez déjà des compteurs (qui peut être une alternative utile pour stocker vos données, de toute façon), vous pouvez aussi écrire cela comme une seule ligne:

>>> all(n <= c2[k] for k, n in c1.items())
True

1

Être conscient de ce qui suit:
```
>>>listA = ['a', 'a', 'b','b','b','c']
>>>listB = ['b', 'a','a','b','c','d']
>>>all(item in listB for item in listA)
True
```
Si vous avez lu le "tout" de la ligne comme vous le feriez en anglais, Ce n'est pas mauvais, mais peut être trompeur, car listA a un troisième "b", mais listB ne le fait pas.

Cela a aussi le même problème:
```
def list1InList2(list1, list2):
    for item in list1:
        if item not in list2:
            return False
    return True
```
Juste une remarque. Le code suivant ne fonctionne pas:
```
>>>tupA = (1,2,3,4,5,6,7,8,9)
>>>tupB = (1,2,3,4,5,6,6,7,8,9)
>>>set(tupA) < set(TupB)
False
```
Si vous convertissez les tuples, listes, il ne fonctionne toujours pas. Je ne sais pas pourquoi les chaînes de caractères, mais ints ne le font pas.

Fonctionne mais même problème de ne pas tenir comte de l'élément événements:
```
>>>set(tupA).issubset(set(tupB))
True
```
À l'aide des ensembles n'est pas une solution complète pour le multi-occurence de l'élément correspondant.

Mais ici, c'est un one-liner/solution d'adaptation à l'shantanoo réponse sans try/except:
```
all(True if sequenceA.count(item) <= sequenceB.count(item) else False for item in sequenceA)
```
Un builtin fonction de la recouvrant d'une compréhension de liste à l'aide d'un opérateur conditionnel ternaire. Python est génial! Notez que le "<=" ne doit pas être "==".

Avec cette solution séquence A et B peuvent être de type tuple et la liste et d'autres des "séquences" avec "le comte". Les éléments dans les deux séquences peuvent être la plupart des types. Je ne voudrais pas utiliser ce avec dicts comme il est maintenant, d'où l'utilisation de "séquence" au lieu de "itératif".

Une solution à l'aide de Compteur et la builtin intersection de la méthode (à noter que - est bon multiset différence, non pas un élément-sage soustraction):

from collections import Counter

def is_subset(l1, l2):
    c1, c2 = Counter(l1), Counter(l2)
    return not c1 - c2

Test:

>>> List1 = ['a','c','c']
>>> List2 = ['x','b','a','x','c','y','c']
>>> is_subset(List1, List2)
True

0

Je ne peux pas utiliser la fonction de sous-ensemble, car je peux avoir des éléments répétés dans les listes.

Ce que cela signifie, c'est que vous souhaitez traiter vos listes multisets plutôt que jeux de. La façon habituelle de gérer multisets en Python est avec collections.Compteur:

Un Counter est un dict sous-classe pour le comptage des hashable objets. C'est une collection non ordonnée, où les éléments sont stockés en tant que clés de dictionnaire et leurs nombres sont stockés en tant que dictionnaire de valeurs. Les comptes sont autorisés à être n'importe quelle valeur entière, y compris zéro ou négatif compte. La Counter classe est similaire à des sacs ou des multisets dans d'autres langues.

Et, alors que vous peut mettre en œuvre un sous-ensemble de multisets (mis en œuvre avec Counter) en faisant une boucle et en comparant compte, comme dans poke la réponse dece n'est pas nécessaire—il suffit que vous peut mettre en œuvre un sous-ensemble de jeux (mis en œuvre avec set ou frozenset) par les boucles et les tests inmais il n'est pas nécessaire.

La Counter type déjà mis en œuvre toutes l'ensemble des opérateurs étendu dans le moyen le plus évident pour multisets.^<1 de Sorte que vous pouvez juste écrire de sous-ensemble en termes de ces opérateurs, et il va travailler pour les deux set et Counter hors de la boîte.

Avec (multi)différence:²
```
def is_subset(c1, c2):
    return not c1 - c2
```
Ou avec (multi)définir intersection:
```
def is_subset(c1, c2):
    def c1 & c2 == c1
```
_{1. Vous demandez peut-être pourquoi, si Counter met en œuvre l'ensemble des opérateurs, il ne se contente pas de mettre en œuvre < et <= pour le bon sous-ensemble et sous-ensemble. Bien que je ne peux pas trouver l'e-mail thread, je suis sûr que cela a été discuté, et la réponse a été que "l'ensemble des opérateurs" sont définies comme l'ensemble spécifique des opérateurs définis dans la version initiale de collections.abc.Set (qui a depuis été élargi, autant que je me souvienne...), tous les exploitants qui set arrive à inclure pour la commodité, exactement de la même manière que Counter n'a pas nommé de méthodes comme le intersection qui est favorable à d'autres types de & juste parce que set.}

_{2. Cela dépend du fait que les collections en Python devraient être falsey quand il est vide et truthy autrement. Ceci est documenté ici pour la builtin types, et le fait que bool tests de revenir à len est expliqué ici—mais au final c'est juste une convention, de sorte que "la quasi-collections" comme des tableaux numpy peut la violer si ils ont une bonne raison. Il détient pour les "vrais collections" comme CounterOrderedDictetc. Si vous êtes vraiment inquiet à ce sujet, vous pouvez écrire len(c1 - c2) == 0mais note que c'est contre l'esprit de PEP 8.}

-1

def check_subset(list1, list2):
    try:
        [list2.remove(x) for x in list1]
        return 'all elements in list1 are in list2'
    except:
        return 'some elements in list1 are not in list2'

-1

Ce sera le retour de vrai, c'est que tous les éléments dans la liste 1 sont dans la liste 2

def list1InList2(list1, list2):
    for item in list1:
        if item not in list2:
            return False
    return True

Vous devez vous connecter pour publier un commentaire.