Comment vérifier si tous les éléments suivants sont dans une liste?

J'ai trouvé, qu'il y a une question connexe, sur la façon de trouver si au moins un élément existe dans une liste:
Comment vérifier si l'un des éléments suivants est dans une liste?

Mais quelle est la meilleure façon pythonique de savoir si tous les éléments existent dans une liste?

En recherchant dans les documents, j'ai trouvé cette solution:

>>> l = ['a', 'b', 'c']
>>> set(['a', 'b']) <= set(l)
True
>>> set(['a', 'x']) <= set(l)
False

Une autre solution serait la suivante:

>>> l = ['a', 'b', 'c']
>>> all(x in l for x in ['a', 'b'])
True
>>> all(x in l for x in ['a', 'x'])
False

Mais ici, vous devez faire plus de frappe.

Y a-t-il d'autres solutions?

Les opérateurs comme <=dans Python ne sont généralement pas surchargés pour signifier quelque chose de significativement différent de "inférieur ou égal à". C'est inhabituel que la bibliothèque standard fasse cela - cela sent comme l'ancienne API.

Utilisez l'équivalent et méthode plus clairement nommé, set.issubset. Notez que vous n'avez pas besoin de convertir l'argument en un ensemble; il le fera pour vous si nécessaire.

set(['a', 'b']).issubset(['a', 'b', 'c'])

J'utiliserais probablement setde la manière suivante:

set(l).issuperset(set(['a','b'])) 

ou l'inverse:

set(['a','b']).issubset(set(l)) 

Je le trouve un peu plus lisible, mais c'est peut-être excessif. Les ensembles sont particulièrement utiles pour calculer l'union / l'intersection / les différences entre les collections, mais ce n'est peut-être pas la meilleure option dans cette situation ...

J'aime ces deux-là car ils semblent les plus logiques, ce dernier étant plus court et probablement le plus rapide (illustré ici en utilisant setune syntaxe littérale qui a été rétroportée vers Python 2.7):

all(x in {'a', 'b', 'c'} for x in ['a', 'b'])
#   or
{'a', 'b'}.issubset({'a', 'b', 'c'})

Et si vos listes contiennent des doublons comme celui-ci:

v1 = ['s', 'h', 'e', 'e', 'p']
v2 = ['s', 's', 'h']

Les ensembles ne contiennent pas de doublons. Ainsi, la ligne suivante renvoie True.

set(v2).issubset(v1)

Pour compter les doublons, vous pouvez utiliser le code:

v1 = sorted(v1)
v2 = sorted(v2)


def is_subseq(v2, v1):
    """Check whether v2 is a subsequence of v1."""
    it = iter(v1)
    return all(c in it for c in v2) 

Ainsi, la ligne suivante renvoie False.

is_subseq(v2, v1)

C'est ce que je cherchais en ligne mais malheureusement pas en ligne, mais en expérimentant sur l'interpréteur python.

>>> case  = "caseCamel"
>>> label = "Case Camel"
>>> list  = ["apple", "banana"]
>>>
>>> (case or label) in list
False
>>> list = ["apple", "caseCamel"]
>>> (case or label) in list
True
>>> (case and label) in list
False
>>> list = ["case", "caseCamel", "Case Camel"]
>>> (case and label) in list
True
>>>

et si vous avez une longue liste de variables contenues dans un sublist variable

>>>
>>> list  = ["case", "caseCamel", "Case Camel"]
>>> label = "Case Camel"
>>> case  = "caseCamel"
>>>
>>> sublist = ["unique banana", "very unique banana"]
>>>
>>> # example for if any (at least one) item contained in superset (or statement)
...
>>> next((True for item in sublist if next((True for x in list if x == item), False)), False)
False
>>>
>>> sublist[0] = label
>>>
>>> next((True for item in sublist if next((True for x in list if x == item), False)), False)
True
>>>
>>> # example for whether a subset (all items) contained in superset (and statement)
...
>>> # a bit of demorgan's law
...
>>> next((False for item in sublist if item not in list), True)
False
>>>
>>> sublist[1] = case
>>>
>>> next((False for item in sublist if item not in list), True)
True
>>>
>>> next((True for item in sublist if next((True for x in list if x == item), False)), False)
True
>>>
>>>

Un exemple de la façon de procéder à l'aide d'une expression lambda serait:

issublist = lambda x, y: 0 in [_ in x for _ in y]

Pas le cas d'OP, mais - pour quiconque veut affirmer une intersection dans des dictionnaires et s'est retrouvé ici en raison d'une mauvaise recherche sur Google (par exemple moi) - vous devez travailler avec dict.items:

>>> a = {'key': 'value'}
>>> b = {'key': 'value', 'extra_key': 'extra_value'}
>>> all(item in a.items() for item in b.items())
True
>>> all(item in b.items() for item in a.items())
False

C'est parce que dict.itemsrenvoie des tuples de paires clé / valeur, et tout comme n'importe quel objet en Python, ils sont comparables de manière interchangeable