Come scrivere rami condizionali con istruzioni if in Python

Attività commerciale

Spiegare la ramificazione condizionale con le istruzioni if in Python.

  • Fondamenti di dichiarazioni if (if, elif, else)
  • Specificare le condizioni con operatori di confronto, ecc.
  • Specificare le condizioni per numero, elenco, ecc.
  • Specificare condizioni multiple o negazioni con operatori logici (and, or, not)
  • Espressioni condizionali su nuove linee e linee multiple

C'è anche un operatore ternario che descrive un ramo condizionale in una linea. Vedere il seguente articolo.

Fondamenti di dichiarazioni if (if, elif, else)

La forma base dell'istruzione if è la seguente

if Conditional expression 1:
    `Processing to be performed if Expression 1 is True.`
elif Conditional expression 2:
    `Processing to be performed when expression 1 is false and expression 2 is true.`
elif Expression 3:
    `Process when expression 1 and 2 are false and expression 3 is true.`
...
else:
    `Processing when all conditionals are false.`

L'”elif” corrisponde all'”else if” in C e in altri linguaggi, e ci può essere qualsiasi numero di “elif”.

Se c'è solo un'espressione condizionale o l'elaborazione quando falso non è necessaria, i blocchi “elif” e “else” possono essere omessi.

Specificare le condizioni con operatori di confronto, ecc.

Specificare la condizione con un'operazione che restituisce un tipo bool (vero, falso), come un operatore di confronto.

Gli operatori di confronto Python sono i seguenti

operatorerisultato
x < yvero se x è minore di y
x <= yvero se x è minore o uguale a y
x > yvero se x è maggiore di y
x >= yvero se x è maggiore o uguale a y
x == yvero se i valori x e y sono uguali
x != yvero se i valori x e y non sono ugualix is yvero se x e y sono lo stesso oggettox is not yvero se x e y non sono lo stesso oggettox in yvero se x è contenuto in yx not in yvero se x non è contenuto in y

Esempio. Per comodità, è definito come una funzione con l'istruzione def.

def if_test(num):
    if num > 100:
        print('100 < num')
    elif num > 50:
        print('50 < num <= 100')
    elif num > 0:
        print('0 < num <= 50')
    elif num == 0:
        print('num == 0')
    else:
        print('num < 0')

if_test(1000)
# 100 < num

if_test(70)
# 50 < num <= 100

if_test(0)
# num == 0

if_test(-100)
# num < 0

Quanto segue può essere scritto in un modo che è unico per Python. Vedere il seguente articolo per i dettagli.
a < x < b

def if_test2(num):
    if 50 < num < 100:
        print('50 < num < 100')
    else:
        print('num <= 50 or num >= 100')

if_test2(70)
# 50 < num < 100

if_test2(0)
# num <= 50 or num >= 100
  • ==
  • !=

Quanto sopra è un confronto di valori; per confrontare le identità degli oggetti, usate il seguente

  • is
  • is not

Per esempio, quando si confrontano un intero e un numero in virgola mobile, “==” restituisce vero se i valori sono equivalenti, ma “è” restituisce falso 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

È anche possibile fare la condizione se una lista o una stringa contiene un elemento specifico (carattere).

  • in:includere
  • not in:non incluso
def if_test_in(s):
    if 'a' in s:
        print('a is in string')
    else:
        print('a is NOT in string')

if_test_in('apple')
# a is in string

if_test_in('melon')
# a is NOT in string

Specificare le condizioni per numero, elenco, ecc.

L'espressione condizionale di un'istruzione if può essere un numero, una lista o un altro oggetto che non sia di tipo bool (true, false).

if 10:
    print('True')
# True

if [0, 1, 2]:
    print('True')
# True

Nell'espressione condizionale di un'istruzione if di Python, i seguenti oggetti sono considerati falsi.

I numeri che rappresentano lo zero, le stringhe vuote, le liste, ecc. sono considerati falsi; tutti gli altri sono considerati veri.

Come viene giudicato l'oggetto può essere controllato con bool().

print(bool(10))
# True

print(bool(0.0))
# False

print(bool([]))
# False

print(bool('False'))
# True

Questo può essere usato per scrivere semplicemente il processo quando la lista è vuota, per esempio.

def if_test_list(l):
    if l:
        print('list is NOT empty')
    else:
        print('list is empty')

if_test_list([0, 1, 2])
# list is NOT empty

if_test_list([])
# list is empty

Notate che anche la stringa 'False' sarà vera, perché come mostrato nell'esempio sopra, qualsiasi stringa che non è vuota nella stringa sarà vera. Per convertire una specifica stringa come 'True' o 'False' in 1,0, usate strtobool() nel modulo distutils.util.

Specificare condizioni multiple o negazioni con operatori logici (and, or, not)

Gli operatori logici (and, or, not) possono essere usati per gestire la congiunzione logica, la disgiunzione logica e la negazione di condizioni multiple.

operatore（Risultato (nell'espressione condizionale di un'istruzione if)
x and yvero se sia x che y sono veri
x or yvero se o x o y è vero
not xfalso se x è vero, vero se x è falso
def if_test_and_not(num):
    if num >= 0 and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_not(5)
# num is positive odd

if_test_and_not(10)
# num is NOT positive odd

if_test_and_not(-10)
# num is NOT positive odd

Infatti, “x e y” e “x o y” non restituiscono True o False, ma o x o y. Finché sono usati in espressioni condizionali in dichiarazioni if, non c'è bisogno di preoccuparsene, poiché valutano True o False. Vedere il seguente articolo per i dettagli.

È possibile usare e e o più di una volta.

def if_test_and_not_or(num):
    if num >= 0 and not num % 2 == 0 or num == -10:
        print('num is positive odd or -10')
    else:
        print('num is NOT positive odd or -10')

if_test_and_not_or(5)
# num is positive odd or -10

if_test_and_not_or(10)
# num is NOT positive odd or -10

if_test_and_not_or(-10)
# num is positive odd or -10

Espressioni condizionali su nuove linee e linee multiple

Quando si usano più espressioni condizionali collegandole con “e” o “o” e ogni riga diventa lunga, a volte è necessario spezzare l'espressione condizionale e scriverla su più righe.

Un'interruzione di riga può essere fatta usando un backslash o racchiudendo l'intera riga tra parentesi.

def if_test_and_backslash(num):
    if num >= 0 \
       and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_backslash(5)
# num is positive odd

def if_test_and_brackets(num):
    if (num >= 0
        and not num % 2 == 0):
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_brackets(5)
# num is positive odd

Puoi usare un backslash per interrompere una linea quante volte vuoi. Allo stesso modo, si può interrompere una linea qualsiasi numero di volte all'interno delle parentesi. Non c'è limite di indentazione.

Notate che questa è una tecnica che può essere usata ovunque nel codice Python, non solo nelle istruzioni if.