Hoe voorwaardelijke vertakkingen schrijven met if statements in Python

Bedrijf

Leg voorwaardelijke vertakking uit met if statements in Python.

  • Grondbeginselen van if-statements (if, elif, else)
  • Specificeer voorwaarden met vergelijkingsoperatoren, enz.
  • Specificeer voorwaarden per nummer, lijst, enz.
  • Specificeer meerdere voorwaarden of ontkenningen met logische operatoren (en, of, niet)
  • Voorwaardelijke uitdrukkingen op nieuwe regels en op meerdere regels

Er is ook een ternaire operator die een voorwaardelijke vertakking in één regel beschrijft. Zie het volgende artikel.

Grondbeginselen van if-statements (if, elif, else)

De basisvorm van de if-statement is als volgt

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.`

De “elif” komt overeen met de “else if” in C en andere talen, en er kan een willekeurig aantal “elifs” zijn.

Indien er slechts één voorwaardelijke uitdrukking is of verwerking wanneer false niet nodig is, kunnen de “elif” en “else” blokken weggelaten worden.

Specificeer voorwaarden met vergelijkingsoperatoren, enz.

Specificeer de voorwaarde met een bewerking die een bool type (waar, onwaar) teruggeeft, zoals een vergelijkingsoperator.

Python vergelijkingsoperatoren zijn als volgt

operatorresultaat
x < ywaar als x kleiner is dan y
x <= ytrue als x kleiner is dan of gelijk aan y
x > ywaar als x groter is dan y
x >= ytrue als x groter is dan of gelijk aan y
x == ytrue als x en y waarden gelijk zijn
x != ytrue als x en y waarden niet gelijk zijnx is ywaar als x en y hetzelfde object zijnx is not ywaar als x en y niet hetzelfde object zijnx in ywaar als x in y zitx not in ywaar als x niet in y zit

Voorbeeld. Voor het gemak wordt het gedefinieerd als een functie met de def verklaring.

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

Het volgende kan worden geschreven op een manier die uniek is voor Python. Zie het volgende artikel voor details.
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
  • ==
  • !=

Het bovenstaande is een vergelijking van waarden; om objectidentiteiten te vergelijken, gebruik je het volgende

  • is
  • is not

Bijvoorbeeld, bij het vergelijken van een geheel getal en een drijvend-kommagetal, “==” is waar als de waarden equivalent zijn, maar “is” is vals omdat het verschillende objecten zijn.

i = 10
print(type(i))
# <class 'int'>

f = 10.0
print(type(f))
# <class 'float'>

print(i == f)
# True

print(i is f)
# False

Het is ook mogelijk de voorwaarde te stellen of een lijst of een string een specifiek element (karakter) bevat.

  • in:inclusief
  • not in:niet inbegrepen
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

Specificeer voorwaarden per nummer, lijst, enz.

De voorwaardelijke uitdrukking van een if-instructie kan een getal, lijst, of ander object zijn dat niet van het type bool (waar, onwaar) is.

if 10:
    print('True')
# True

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

In de voorwaardelijke uitdrukking van een Python if statement worden de volgende objecten als onwaar beschouwd.

Getallen die nul voorstellen, lege reeksen, lijsten, enz. worden als onwaar beschouwd; alle andere worden als waar beschouwd.

Hoe het object wordt beoordeeld kan worden gecontroleerd met bool().

print(bool(10))
# True

print(bool(0.0))
# False

print(bool([]))
# False

print(bool('False'))
# True

Dit kan gebruikt worden om het proces te schrijven als de lijst leeg is, bijvoorbeeld.

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

Merk op dat de string 'False' ook true zal zijn, omdat zoals in het voorbeeld hierboven, elke string die niet leeg is in de string true zal zijn. Om een specifieke string zoals 'True' of 'False' om te zetten naar 1,0, gebruik je strtobool() in de distutils.util module.

Specificeer meerdere voorwaarden of ontkenningen met logische operatoren (en, of, niet)

De logische operatoren (en, of, niet) kunnen worden gebruikt om logische conjunctie, logische splitsing en negatie van meervoudige voorwaarden te behandelen.

operator（Resultaat (in de voorwaardelijke uitdrukking van een if-statement)
x and ywaar als zowel x als y waar zijn
x or ywaar als x of y waar is
not xonwaar als x waar is, waar als x onwaar is
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

In feite geven “x en y” en “x of y” niet True of False terug, maar ofwel x of y. Zolang ze gebruikt worden in voorwaardelijke uitdrukkingen in if statements, is er geen reden om je er zorgen over te maken, aangezien ze evalueren naar ofwel True of False. Zie het volgende artikel voor details.

Het is mogelijk om en en of meer dan eens te gebruiken.

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

Voorwaardelijke uitdrukkingen op nieuwe regels en op meerdere regels

Wanneer meerdere voorwaardelijke uitdrukkingen worden gebruikt door ze te verbinden met “en” of “of” en elke regel lang wordt, is het soms nodig om de voorwaardelijke uitdrukking af te breken en op meerdere regels te schrijven.

Een regeleinde kan worden gemaakt door een backslash te gebruiken of door de hele regel tussen haakjes te zetten.

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

U kunt een backslash gebruiken om een regel zo vaak te breken als u wilt. Evenzo kunt u een regel binnen haakjes een willekeurig aantal keren afbreken. Er is geen limiet voor inspringing.

Merk op dat dit een techniek is die overal in Python code kan worden gebruikt, niet alleen in if statements.

Copied title and URL