In Python, possono essere concatenati. Puoi scrivere a < xex < b come a < x < b come in matematica.
In questo articolo vengono descritti i seguenti contenuti.
- Catena di confrontarsi
- Esempio 1: Intervallo numerico
- Esempio 2: verificare se più valori sono tutti uguali
- Fai attenzione a non abusarne
Catena di confrontarsi
Ad esempio, a < x < b è equivalente a < xex < b.
I confronti possono essere concatenati arbitrariamente, ad es. x < y <= z equivale ax < yey <= z, tranne per il fatto che y viene valutato solo una volta (ma in entrambi i casi z non viene valutato affatto quando x < y viene trovato essere falso).
Formalmente, se a, b, c, …, y, z sono espressioni e op1, op2, …, opN sono operatori di confronto, allora a op1 b op2 c … y opN z è equivalente aa op1 beb op2 ce .. .y opN z, tranne per il fatto che ogni espressione viene valutata al massimo una volta.
6. Espressioni – Confronti — Documentazione Python 3.9.1
Se a,b, c, …, y, z sono espressioni e op1, op2, …, opN sono operatori di confronto (come < o >), i due seguenti sono equivalenti.
a op1 b op2 c ... y opN z
a op1 b and b op2 c and ... y opN z
Esempi specifici:
x = 15
print(10 < x < 20)
# True
print(10 < x and x < 20)
# True
x = 0
print(10 < x < 20)
# False
print(10 < x and x < 20)
# False
Esempi più complessi:
x = 15
y = 25
print(10 < x < 20 < y < 30)
# True
print(10 < x and x < 20 and 20 < y and y < 30)
# True
x = 15
y = 40
print(10 < x < 20 < y < 30)
# False
print(10 < x and x < 20 and 20 < y and y < 30)
# False
Come indicato nella documentazione ufficiale, ogni espressione viene valutata al massimo una volta quando concatenata.
Ad esempio, definisci una funzione semplice che restituisca i suoi argomenti così come sono. print() viene eseguito per confermare che la funzione è stata chiamata.
def test(x):
print('function is called')
return(x)
print(test(15))
# function is called
# 15
Se i confronti sono concatenati, la funzione viene chiamata una sola volta.
print(10 < test(15) < 20)
# function is called
# True
Nel caso di e, la funzione viene chiamata due volte.
print(10 < test(15) and test(15) < 20)
# function is called
# function is called
# True
In X e Y, se X è Falso, Y non viene valutato. Pertanto, nel caso seguente, la funzione viene chiamata una sola volta in esso dal fatto che sia concatenata o meno.
print(10 < test(0) < 20)
# function is called
# False
print(10 < test(0) and test(0) < 20)
# function is called
# False
Questa è chiamata valutazione di cortocircuito. Vedere il seguente articolo per i dettagli.
In ogni caso, durante il concatenamento, ogni espressione viene valutata una sola volta al massimo, quindi il concatenamento è più funzioni quando si confrontano i risultati di efficienti complesse.
Esempio 1: Intervallo numerico
Quando un intervallo di numeri viene utilizzato come condizione, i confronti concatenati sono utili.
x = 15
if 10 < x < 20:
print('result: 10 < x < 20')
else:
print('result: x <= 10 or 20 <= x')
# result: 10 < x < 20
x = 30
if 10 < x < 20:
print('result: 10 < x < 20')
else:
print('result: x <= 10 or 20 <= x')
# result: x <= 10 or 20 <= x
Esempio 2: verificare se più valori sono tutti uguali
Un altro comodo utilizzo è controllare se più variabili ed espressioni sono tutte uguali.
Il concatenamento con l’operatore di confronto == produce True solo se tutti i valori sono uguali.
a = 10
b = 10
c = 10
if a == b == c:
print('all equal')
else:
print('not all equal')
# all equal
Se è presente anche un valore diverso, viene restituito False.
a = 10
b = 1
c = 10
if a == b == c:
print('all equal')
else:
print('not all equal')
# not all equal
Fare attenzione quando si utilizza l’operatore di confronto != che risponde True quando i valori non sono equivalenti. Non tutte le combinazioni di valori vengono valutate, quindi anche se sono presenti valori equivalenti, True viene restituito a seconda dell’ordine.
a = 10
b = 1
c = 100
print(a != b != c)
# True
a = 10
b = 10
c = 1
print(a != b != c)
# False
a = 10
b = 1
c = 10
print(a != b != c)
# True
Un modo per verificare che siano più valori tutti univoci è archiviarli in un elenco e quindi controllare i duplicati. Vedi il seguente articolo.
Nota che == e != confrontano i valori. L’uso è, non è ottenuto l’identità degli oggetti.
Ad esempio, quando si un intero int con un numero in virgola mobile float, == restituisce True se confronta i valori sono equivalenti, ma richiede False perché sono oggetti diversi.
i = 10
print(type(i))
# <class 'int'>
f = 10.0
print(type(f))
# <class 'float'>
print(i == f)
# True
print(i is f)
# False
Fai attenzione a non abusarne
Il confronto concatenato può essere scritto in vari modi, ma fai attenzione che il codice può essere difficile da leggere in alcuni casi.
Ad esempio, l’operatore in, che verifica se un elenco contiene un elemento particolare, può anche essere concatenato, ma probabilmente crea confusione per la maggior parte delle persone. A meno che tu non abbia un forte vantaggio in quanto “ogni viene valutata solo una volta”, usare e.
a = 100
l = [0, 10, 100, 1000]
print(50 < a in l)
# True
print(50 < a and a in l)
# True