Come verificare se tutti i seguenti elementi sono in un elenco?

Ho scoperto che c'è una domanda correlata, su come trovare se almeno un elemento esiste in un elenco:
Come verificare se uno dei seguenti elementi è in un elenco?

Ma qual è il modo migliore e pitonico per scoprire se tutti gli elementi esistono in un elenco?

Cercando tra i documenti ho trovato questa soluzione:

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

Un'altra soluzione sarebbe questa:

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

Ma qui devi scrivere di più.

Esistono altre soluzioni?

Gli operatori come <=in Python generalmente non vengono sovrascritti per indicare qualcosa di significativamente diverso da "minore o uguale a". È insolito che la libreria standard lo faccia: per me sa di API legacy.

Utilizzare l'equivalente e il metodo più chiaramente dal nome, set.issubset. Nota che non è necessario convertire l'argomento in un set; lo farà per te se necessario.

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

Probabilmente lo userei setnel modo seguente:

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

O viceversa :

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

Lo trovo un po 'più leggibile, ma potrebbe essere eccessivo. Gli insiemi sono particolarmente utili per calcolare l'unione / intersezione / differenze tra le raccolte, ma potrebbe non essere l'opzione migliore in questa situazione ...

Mi piacciono questi due perché sembrano i più logici, quest'ultimo è più breve e probabilmente più veloce (mostrato qui usando la setsintassi letterale che è stata backportata in Python 2.7):

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

E se i tuoi elenchi contengono duplicati come questo:

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

I set non contengono duplicati. Quindi, la riga seguente restituisce True.

set(v2).issubset(v1)

Per contare i duplicati, puoi utilizzare il codice:

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) 

Quindi, la riga seguente restituisce False.

is_subseq(v2, v1)

Questo era quello che stavo cercando online ma sfortunatamente non l'ho trovato online ma durante la sperimentazione sull'interprete 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
>>>

e se hai un lungo elenco di variabili contenute in un file 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 esempio di come eseguire questa operazione utilizzando un'espressione lambda potrebbe essere:

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

Non è il caso di OP, ma - per chiunque voglia affermare l'intersezione nei dict e sia finito qui a causa di una scarsa ricerca su Google (ad es. Me) - devi lavorare con 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

Questo perché dict.itemsrestituisce tuple di coppie chiave / valore e, proprio come qualsiasi oggetto in Python, sono intercambiabili comparabili