Attualmente sto facendo questo:prova se tutti i valori sono in un iterabile in modo divinatorio
if x in a and y in a and z in a and q in a and r in a and s in a:
print b
C'è un modo più divinatorio per esprimere questo if
affermazione?
Attualmente sto facendo questo:prova se tutti i valori sono in un iterabile in modo divinatorio
if x in a and y in a and z in a and q in a and r in a and s in a:
print b
C'è un modo più divinatorio per esprimere questo if
affermazione?
Utilizzando la funzione all permette di scrivere questo in un modo piacevole e compatto:
if all(i in a for i in (x, y, z, q, r, s)):
print b
Questo codice dovrebbe fare quasi esattamente lo stesso come il tuo esempio, anche se gli oggetti non sono hashable o se l'oggetto a
ha qualche divertente metodo __contains__
. La funzione all
ha anche un comportamento simile a short-circuit come la catena di and
nel problema originale. La raccolta di tutti gli oggetti da testare in una tupla (o una lista) garantirà lo stesso ordine di esecuzione dei test rispetto al problema originale. Se usi un set, l'ordine potrebbe essere casuale.
if all(v in a for v in {x, y, z, q, r, s}):
print(b)
questo non funzionerà se qualcuno di 'x',' y', ... sono nel calcolo dell'hash, anche se ... – xnx
Un altro modo per farlo è quello di utilizzare sottoinsiemi:
if {x, y, z, q, r, s}.issubset(a):
print(b)
REPL esempio:
>>> {0, 1, 2}.issubset([0, 1, 2, 3])
True
>>> {0, 1, 2}.issubset([1, 2, 3])
False
Un avvertimento con questo approccio è che tutti x
, y
, z
, ecc deve essere hashable.
Conversione per impostare, sia:
if len({x, y, z, q, r, s} - set(a)) == 0:
print b
o
t = {x, y, z, q, r, s}
if t & set(a) == t:
print b
Nitpicking: questo * non * completamente equivalente al codice OP, anche se 'all' è pigro. Il problema è che la tupla '(x, y, z, q, r, s)' è costruita completamente prima di eseguire qualsiasi iterazione e se 'x',' y' ecc. Sono espressioni, alcune di esse potrebbero sollevare un'eccezione. In questo caso il codice dell'OP * potrebbe * restituire 'False' ed evitare l'eccezione mentre questo codice genererà sempre l'eccezione. – Bakuriu
"qualche divertente metodo __contains__'" - e così raggiungiamo gli angoli più complicati della digitazione delle anatre. L'interrogante dice "in un iterabile", ma se 'a' implementa' __contains__', allora per il codice del questionario non importa nemmeno se 'a' è iterable o non ... –
@Bakuriu, ma non sono espressioni. Sono variabili - assumendo che l'OP stia scrivendo Python e non meta-Python. –