Denna guide kommer att introducera dig till hur man använder den ternära operatorn i Python. Du kommer att utforska syntaxen och undersöka flera kodexempel för att förstå dess funktion.
Vi börjar med att repetera hur if-else-villkorssatser fungerar, och därefter lära oss hur man konstruerar ett ekvivalent uttryck med hjälp av den ternära operatorn.
Efter det kommer vi att gå igenom ett par exempel och sedan undersöka hur man kan efterlikna beteendet hos Pythons ternära operator genom att använda en Python-tuppel och ordbok. Slutligen granskar vi olika situationer där användning av den ternära operatorn är att föredra.
Låt oss börja utforska detta!
If-Else-satser i Python: En Översikt
Du kan öva genom att starta en Python REPL eller använda en online Python-redigerare som adminvista.com.
Den grundläggande syntaxen för en if-else-sats i Python ser ut så här:
if villkor:
# Utför detta
else:
# Utför detta
I det ovanstående kodavsnittet representerar *villkor* det uttryck som ska kontrolleras. Om *villkor* utvärderas till *True* kommer koden inuti *if*-blocket att exekveras. Om *villkor* utvärderas till *False* kommer satserna i *else*-blocket att utföras.
Här är ett exempel där variabeln *game_over* tilldelas ett booleskt värde beroende på om variabeln *energi* är mindre än eller lika med noll:
- Om *energi* är <= 0, då är *game_over* *Sant*.
- Annars är *game_over* *Falskt*.
Följande kodexempel visar hur du åstadkommer detta med hjälp av if-else-villkorssatser:
energy = -1 if energy <= 0: game_over = True else: game_over = False print(game_over) # True
I detta exempel är *energi* satt till -1, vilket är mindre än 0. Därför tilldelas *game_over* värdet *True*.
Python Ternära Operator: Syntax och Exempel
Python har en ternär operator som liknar den ternära villkorsoperatorn i språk som C och C++. Den allmänna syntaxen för att använda den ser ut så här:
uttryck1 if villkor else uttryck2
Låt oss bryta ner syntaxen ovan:
- *villkor*: Det villkor som ska kontrolleras.
- *uttryck1*: Uttrycket som ska utvärderas om villkoret är sant.
- *uttryck2*: Uttrycket som ska utvärderas om villkoret är falskt.
Nu identifierar vi vad *uttryck1*, *uttryck2* och *villkor* ska vara från if-else-versionen av koden.
Sätter vi ihop allt så ser det ut så här 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 kunder rabatt beroende på hur ofta de har besökt din butik under det senaste året.
Låt variabeln *antalBesök* representera antalet besök.
- Om *antalBesök* > 7 är rabattprocenten, *rabatt_procent*, 20.
- Annars är *rabatt_procent* 5.
Vi använder den ternära operatorn för att tilldela ett värde till variabeln *rabatt_procent*.
antalBesök = 10 discount_perc = 20 if antalBesök > 7 else 5 print(discount_perc) # 20 (eftersom antalBesök = 10 vilket är > 7)
Härnäst kommer vi att lära oss hur man emulerar den ternära operatorn med hjälp av en Python-tuppel och en ordbok.
Emulera den Ternära Operatorn med en Python-Tuppel
Precis som alla itererbara objekt i Python, följer tupler nollindexering. Så om du har två element i en tuppel, kommer *tuppel_namn[0]* att referera till det första elementet, och *tuppel_namn[1]* kommer att referera till det andra elementet.
De grundläggande datatyperna i Python inkluderar heltal, flyttal, strängar och booleska värden. Python stöder typomvandling, vilket gör att du kan representera en datatyp genom dess motsvarande representation i en annan datatyp.
Starta en Python REPL och kör följande exempel. Om du försöker omvandla heltal till booleska värden kommer du att märka följande:
- bool(0) är *Falskt*.
- bool(<vilket heltal som helst som inte är noll>) returnerar *True*.
>>> bool(0) False >>> bool(1) True >>> bool(-1) True >>> bool(10) True
På liknande sätt, när vi omvandlar booleska värden till heltal, ser vi följande:
>>> int(True) 1 >>> int(False) 0
Genom att kombinera typomvandling och indexering kan vi göra följande:
- Element vid index 0 i tuppeln: Värdet som ska användas när *villkor* är *Falskt*.
- Element vid index 1 i tuppeln: Värdet som ska användas när *villkor* är *True*.
Med ovanstående i åtanke, får vi följande:
>>> antalBesök = 10 >>> rabatt_procent = (5,20)[antalBesök > 7] >>> rabatt_procent # 20
Här är villkoret *antalBesök > 7* sant eftersom *antalBesök* är 10. Eftersom *int(True)* är 1, blir värdet på *rabatt_procent* 20, elementet vid index 1.
Emulera den Ternära Operatorn med en Python-Ordbok
Du kan sätta *True* och *False* som nycklar i en ordbok. Du kan sedan ställa in *uttryck1* och *uttryck2* som värden som motsvarar nycklarna *True* respektive *False*.
some_dict = {True: uttryck1,
False: uttryck2
}
Vad gör du nu? Om du nu använder *some_dict[villkor]*, kommer *uttryck1* motsvarande nyckeln *True* att utvärderas om villkoret är *True*. Och *uttryck2* kommer att utvärderas när villkoret är *False*.
Låt oss koda *rabatt_procent*-exemplet (igen), men den här gången med en Python-ordbok.
>>> antalBesök = 10
>>> rabatt_dict = {True: 20, False:5}
>>> rabatt_procent = rabatt_dict[antalBesök > 7]
>>> rabatt_procent
# 20
Här är *antalBesök = 10*, vilket är större än 7. Därför är villkoret *antalBesök > 7* sant. Så *rabatt_dict[antalBesök > 7]* utvärderas till *rabatt_dict[True]*, vilket är värdet 20.
Bör du Alltid Använda den Ternära Operatorn i Python?
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 operatorn kanske inte är det bästa valet för alla situationer. Det här avsnittet beskriver när det är lämpligt att använda den ternära operatorn istället för if-else-satser. Vi kommer också att utforska när vi bör överväga att använda if-else-satser istället för den ternära operatorn.
Mer Koncis än If-Else-block
Som tidigare nämnts är det ternära operatoruttrycket i Python mer kortfattat än if-else-satser. Därför kan du använda den för att utföra villkorskontroller och utvärdera uttryck direkt.
I följande exempel är *tal* en lista med 100 slumpmässigt genererade heltal. För vart och ett av dessa tal kontrollerar vi om det är jämnt eller udda. Denna utvärdering sker direkt i f-strängen.
import random
tal = [random.choice(range(100)) for i in range(10)]
for num in tal:
print(f"{num} är {'jämnt' if num%2==0 else 'udda'}")
# Exempel på utdata 0 är jämnt 56 är jämnt 6 är jämnt 53 är udda 62 är jämnt 7 är udda 8 är jämnt 77 är udda 41 är udda 94 är jämnt
Den Ternära Operatorn Kräver Else-Klausulen
När du använder if-else-villkorssatser är else-satsen valfri. Låt oss ta ett exempel. Variabeln *game_over* sätts till *True* om *energi* sjunker till ett värde som är mindre än eller lika med noll.
Men om *energi* är större än noll initieras variabeln *game_over* aldrig. Så du kommer att stöta på ett fel om du försöker komma åt variabeln *game_over*.
energi = 5
if energi <= 0:
game_over = True
print(f"Är spelet slut? {game_over}")
Traceback (senaste anropet):
File "ternary_op.py", line 39, in <module>
print(f"Är spelet slut? {game_over}")
NameError: namnet 'game_over' är inte definierat
Ett sätt att åtgärda detta är att initialt sätta *game_over* till *False* och sedan uppdatera den till *True* om energinivån är mindre än eller lika med noll.
energi = 5
game_over = False
if energi <= 0:
game_over1 = True
print(f"Är spelet slut? {game_over}")
Men när du använder Pythons motsvarighet till den ternära operatorn, är else-satsen inte valfri. Den ternära operatorn kräver att ett uttryck utvärderas när villkoret är falskt.
game_over = True if energi <= 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å ett syntaxfel enligt nedan:
File "ternary_op.py", line 42
game_over = True if energi <= 0
^
SyntaxError: ogiltig syntax
För att Kontrollera Flera Villkor, Använd If-Else-Satser
Tänk på följande exempel: Varje fråga i en serie kodningsintervjufrågor har en tillhörande svårighetspoäng. Beroende på denna poäng tilldelar vi en av tre svårighetsnivåer: lätt, medel eller svår, till en specifik fråga. Anta att vi har följande:
| Poäng | Svårighetsnivå |
| Mindre än 10 | Lätt |
| Mellan 10 och 20 | Medel |
| Större än 20 | Svår |
Givet en svårighetspoäng kan du få dess svårighetsnivå med hjälp av Pythons ternära operator enligt följande:
poäng = 12 svårighetsnivå = "lätt" if poäng < 10 else "svår" if poäng > 20 else "medel" print(svårighetsnivå) # medel
Det ternära operatoruttrycket i ovanstående kodblock har följande form:
uttryck1 if villkor1 else uttryck2 if villkor2 else uttryck3
Även om den är kortfattad är den ganska svår att läsa och tolka. Följande bild illustrerar hur kontrollflödet sker i det här fallet.
Följande kodexempel visar en likvärdig implementering med if-else-satser. Som du kan se är kontrollflödet mycket lättare att förstå och koden är mer läsbar.
if poäng < 10:
svårighetsnivå = "lätt"
elif poäng > 20:
svårighetsnivå = "svår"
else:
svårighetsnivå = "medel"
print(svårighetsnivå)
Därför, när du har flera villkor, bör du använda if-else-block 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 utföra flera satser – beroende på om ett villkor är sant eller falskt – bör du överväga att använda en if-else-sats.
Slutsats
Här är en sammanfattning av vad du har lärt dig i den här guiden.
- I Python kan den ternära operatorn användas med följande syntax: *uttryck1 if villkor else uttryck2*.
- Du kan emulera beteendet hos den ternära operatorn med hjälp av Python-tupler och ordböcker.
- Även om den ternära operatorn kan vara ett mer kortfattat alternativ till if-else-block, bör du se till att koden förblir lättläst. För att förbättra läsbarheten för koden kan du använda if-else-satser istället för den ternära operatorn, särskilt när du behöver hantera flera villkor.
Ta sedan en titt på guiden om operatorerna ”lika med” och ”inte lika med” i Python.