Hur man använder Python Ternary Operator

av

Den här guiden kommer att lära dig hur du använder den ternära operatorn i Python. Du kommer att lära dig syntaxen och koda flera exempel för att förstå hur det fungerar.

Vi börjar med att granska hur den villkorliga satsen if-else fungerar och sedan lära oss hur man skriver ett ekvivalent uttryck med den ternära operatorn.

Därefter kommer vi att koda några exempel och sedan lära oss hur man emulerar beteendet hos Pythons ternära operator med hjälp av en Python-tuppel och ordbok. Slutligen kommer vi att granska några användningsfall när du föredrar att använda den ternära operatorn.

Låt oss börja!

If-Else Statement i Python: En recension

Du kan koda med genom att starta en Python REPL eller i adminvista.com online Python-redigerare.

Den generiska syntaxen för if-else-satsen i Python är följande:

if condition:
    # do this
else:
    # do this

I ovanstående utdrag anger villkor det villkor som ska kontrolleras. Om villkoret utvärderas till True, utlöses if-blocket. Om villkoret utvärderas till False, så exekveras satserna i else-blocket.

Här är ett exempel där game_over-variabeln tilldelas ett booleskt värde beroende på om energivärdet är mindre än eller lika med noll.

  • Om energi <= 0, är ​​game_over Sant.
  • Annars är game_over falskt.

Följande kodavsnitt visar hur du gör detta med de villkorliga satserna if-else:

energy = -1

if energy <= 0:
    game_over = True
else:
    game_over = False

print(game_over)
# True

I det här exemplet är energin -1 vilket är mindre än 0. Så game_over är sant.

Python Ternary Operator: Syntax och exempel

Python har en ternär operator som fungerar mycket som den ternära villkorsoperatorn i språk som C och C++. Den allmänna syntaxen för att använda den är som följer:

expression1 if condition else expression2

Låt oss analysera syntaxen ovan:

  • skick: Villkoret att kontrollera efter.
  • expression1: Uttrycket som ska utvärderas om villkoret är sant.
  • expression2: Uttrycket som ska utvärderas om villkoret är False.

Nu ska vi identifiera vad expression1, expression2 och condition ska vara från if-else-versionen av koden.

Om vi ​​sätter ihop allt har vi följande med Pythons ternära operator.

game_over = True if energy <= 0 else False
print(game_over)
# True

Låt oss koda ett annat exempel. Anta att du driver en bokhandel och du ger läsarna rabatt på köpet beroende på hur ofta de har besökt din butik under det senaste året.

Låt numVisits beteckna antalet besök.

  • Om numVisits > 7 är rabattprocenten, rabatt_perc 20.
  • Annars är rabatt_perc 5.

Vi använder den ternära operatorn för att tilldela värde till variabeln rabatt_perc.

numVisits = 10

discount_perc = 20 if numVisits > 7 else 5

print(discount_perc)
# 20 (as numVisits = 10 which is > 7)

Därefter kommer vi att lära oss hur man emulerar den ternära operatorn med en Python-tupel och en ordbok.

Emulering av den ternära operatören med Python Tuple

Som alla iterables i Python följer tupler noll indexering. Så om du har två element i en tupel, tuple_name[0] anger det första elementet i tupeln och tupelnamn[1] ger det andra elementet i tupeln.

De grundläggande datatyperna i Python är heltal, float, sträng och Boolean. Python stöder typcasting som låter dig representera en viss datatyp genom dess motsvarande representation i en annan datatyp.

Starta en Python REPL och kör följande exempel. Om du försöker konvertera heltal till booleaner kommer du att märka följande:

  • bool(0) är falskt.
  • bool() returnerar True.
>>> bool(0)
False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(10)
True

På liknande sätt, när vi castar booleska till heltal, har vi följande:

>>> int(True)
1
>>> int(False)
0

Genom att sätta ihop typgjutning och indexering kan vi göra enligt följande:

  • Element vid index 0 i tupeln: Värdet som ska användas när villkoret är Falskt.
  • Element vid index 1 i tupeln: Värdet som ska användas när villkoret är True.

Med hjälp av ovanstående har vi följande:

>>> numVisits = 10
>>> discount_perc = (5,20)[numVisits > 7]
>>> discount_perc
# 20

Här är villkoret numVisits > 7 True eftersom numVisits är 10. Eftersom int(True) är 1 är värdet på rabatt_perc 20, elementet vid index 1.

Emulera den ternära operatören med Python Dictionary

Du kan ställa in Sant och Falskt som nycklar i ordboken. Och du kan ställa in expression1 och expression2 som värden som motsvarar nycklarna True respektive False.

some_dict = {True: expression1,
             False: expression2
            }

Vad gör du härnäst? Om du nu använder some_dict[condition], expression1 som motsvarar nyckeln True utvärderas om villkoret är True. Och expression2 utvärderas när villkoret är False.

Låt oss koda discount_perc-exemplet (igen) men den här gången med en Python-ordbok.

>>> numVisits = 10
>>> discount_dict = {True: 20, False:5}
>>> discount_perc = discount_dict[numVisits > 7]
>>> discount_perc
# 20

Här är numVisits = 10 vilket är större än 7. Därför är villkoret numVisits > 7 Sant. Så rabatt_dikt[numVisits > 7] utvärderar till rabatt_dikt[True] vilket är värdet 20.

Bör du alltid använda Python Ternary Operator?

Hittills har vi lärt oss hur man använder den ternära operatorn. Men ska vi alltid använda den ternära operatorn? Tja, den ternära operatören kanske inte är det bästa valet för alla användningsfall. Det här avsnittet bryter ner när du skulle föredra att använda den ternära operatorn framför if-else-satser. Vi kommer också att ta upp när vi bör överväga att använda if-else-satsen istället för den ternära operatorn.

Mer koncisa än om annat block

Som nämnts, i Python, är det ternära operatoruttrycket mer kortfattat än if-else-satsen. Därför kan du använda den för att leta efter villkor och utvärdera uttryck villkorligt i farten.

I följande exempel är nums en lista med 100 slumpmässigt genererade heltal. För vart och ett av de 100 talen kontrollerar vi om det är udda eller jämnt. Och denna utvärdering sker inline inuti f-strängen.

import random

nums = [random.choice(range(100)) for i in range(10)]

for num in nums:
    print(f"{num} is {'even' if num%2==0 else 'odd'}")
# sample output

0 is even
56 is even
6 is even
53 is odd
62 is even
7 is odd
8 is even
77 is odd
41 is odd
94 is even

Den ternära operatören kräver Else-klausulen

När du använder if-else villkorliga uttalanden är else-satsen valfri. Låt oss ta ett exempel. Game_over-variabeln är satt till True om energin sjunker till ett värde som är mindre än eller lika med noll.

Men om energin är större än noll, initieras game_over-variabeln aldrig. Så du kommer att stöta på fel om du försöker komma åt game_over-variabeln.

energy = 5
if energy <= 0:
    game_over = True

print(f"Is the game over? {game_over}")
Traceback (most recent call last):
  File "ternary_op.py", line 39, in <module>
    print(f"Is the game over? {game_over}")
NameError: name 'game_over' is not defined

Ett sätt att fixa detta är att ställa game_over till False initialt och uppdatera den till True om energinivån är mindre än eller lika med noll.

energy = 5
game_over = False
if energy <= 0:
    game_over1 = True

print(f"Is the game over? {game_over}")

Men när du använder Python-ternära operatormotsvarigheten till ovanstående, är else-satsen inte valfri. Den ternära operatorn kräver att uttrycket utvärderas när villkoret är Falskt.

game_over = True if energy <= 0 else False

Om du ändrar ovanstående till game_over = True om energi <= 0 genom att ta bort den andra delen, kommer du att stöta på syntaxfel, som visas:

File "ternary_op.py", line 42
    game_over = True if energy <= 0
                                  ^
SyntaxError: invalid syntax

För att kontrollera om det finns flera tillstånd, använd If-Else-uttalanden

Tänk på exemplet: Varje fråga i en uppsättning av kodande intervjufrågor har en tillhörande svårighetspoäng. Beroende på denna poäng tilldelar vi en av de tre svårighetsnivåerna: lätt, medel eller svår, till en viss fråga. Anta att vi har följande:

Poäng Svårighetsnivå Mindre än 10lättMellan 10 och 20 medelhögare än 20hårt

Med tanke på svårighetspoängen kan du få dess svårighetsnivå med den ternära Python-operatorn som visas:

score = 12

difficulty_level = "easy" if score < 10 else "hard" if score > 20 else "medium"

print(difficulty_level)
# medium

Det ternära operatoruttrycket i ovanstående kodblock har följande form:

expression1 if condition1 else expression2 if condition2 else expression3

Även om den är kortfattad är den lite svår att läsa och tolka. Följande bild visar hur kontrollflödet uppstår i detta fall.

Följande kodavsnitt visar en likvärdig implementering med if-else-satser. Som sett är kontrollflödet mycket lättare att förstå och koden är mer läsbar.

if score < 10:
    difficulty_level="easy"
elif score > 20:
    difficulty_level="hard"
else:
    difficulty_level="medium"

print(difficulty_level)

Därför, när du har flera villkor, bör du använda if-else-blocken istället för den ternära operatorn. Detta säkerställer att koden är lätt att läsa och förstå.

Dessutom, när du behöver köra flera satser – beroende på om villkoret är sant eller falskt – bör du överväga att använda if-else-satsen.

Slutsats

Här är en sammanfattning av vad du har lärt dig i den här handledningen.

  • I Python kan den ternära operatorn användas med följande syntax: expression1 if condition else expression2.
  • Du kan emulera beteendet hos den ternära operatorn med Python-tupler och ordböcker.
  • Även om den ternära operatorn kan vara ett mer kortfattat alternativ till if-else-blocken, bör du se till att koden är läsbar. För att förbättra läsbarheten för koden kan du använda if-else-satserna istället för den ternära operatorn, speciellt när du behöver kedja flera villkor.

Lär dig sedan att kolla in handledningen om lika och inte lika operatorer i Python.