web-dev-qa-db-fra.com

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

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

Mais quel est le meilleur moyen, selon Pythonic, de savoir si tous les éléments existent dans une liste?

En cherchant dans la documentation, 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?

listpythoninclusion
73
sirex

Les opérateurs tels que <= en Python ne sont généralement pas modifiés pour signifier quelque chose de significativement différent de "inférieur ou égal à". C’est inhabituel pour la bibliothèque standard de le faire - cela sent l’API héritée pour moi.

Utilisez la méthode équivalente et plus clairement nommée, set.issubset. Notez que vous n'avez pas besoin de convertir l'argument en jeu. ça le fera pour vous si nécessaire.

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

J'utiliserais probablement set de 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 une tuerie. Les ensembles sont particulièrement utiles pour calculer les unions/intersections/différences entre les collections, mais ce n'est peut-être pas la meilleure option dans cette situation ...

57
tsimbalar

J'aime ces deux types car ils semblent les plus logiques, le dernier étant plus court et probablement le plus rapide (montré ici avec la syntaxe littérale set qui a été backported en Python 2.7):

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

Et si vos listes contiennent des doublons comme ceci:

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)

La ligne suivante renvoie donc False.

is_subseq(v2, v1)
1
Brut

C’est ce que j’étais en train de chercher en ligne mais que j’ai malheureusement trouvé non pas en ligne mais en testant un 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 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
>>>
>>>
0
Emirhan Özlen

Voici un exemple de méthode utilisant une expression lambda:

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