En Innføring i Ternære Operatorer i Python
Denne veiledningen gir en detaljert forklaring på hvordan du bruker den ternære operatoren i Python. Vi vil utforske syntaksen, se på praktiske eksempler for å fremheve funksjonaliteten, og lære om dens anvendelsesområder.
Vi starter med å repetere hvordan `if-else`-setninger fungerer, for deretter å vise hvordan du kan oppnå samme resultat med den ternære operatoren.
Deretter ser vi på noen kodeeksempler og utforsker alternative måter å etterligne den ternære operatorens oppførsel ved å bruke Python-tupler og ordbøker. Til slutt skal vi diskutere situasjoner der det er fordelaktig å bruke ternære operatorer.
La oss sette i gang!
Gjennomgang av `if-else`-setninger i Python
Du kan eksperimentere med kodeeksemplene ved å bruke en Python REPL eller en online Python-editor som tipsbilk.net sin.
Den generelle strukturen for en `if-else`-setning i Python ser slik ut:
if betingelse:
# Utfør denne koden
else:
# Utfør denne koden
I kodesnutten ovenfor, representerer `betingelse` den logiske testen som utføres. Hvis `betingelse` evalueres til `True`, kjøres koden i `if`-blokken. Hvis den evalueres til `False`, utføres koden i `else`-blokken.
Her er et eksempel der variabelen `game_over` settes til en boolsk verdi basert på om verdien av `energi` er mindre enn eller lik null:
- Hvis `energi` <= 0, blir `game_over` satt til `True`.
- Ellers blir `game_over` satt til `False`.
Følgende kode viser hvordan dette kan implementeres med en `if-else`-setning:
energi = -1
if energi <= 0:
game_over = True
else:
game_over = False
print(game_over)
# Output: True
I dette tilfellet er `energi` satt til -1, som er mindre enn 0. Derfor er `game_over` satt til `True`.
Syntaks og Eksempler på Ternære Operatorer i Python
Python har en ternær operator som ligner den betingede operatoren i språk som C og C++. Den grunnleggende syntaksen er som følger:
uttrykk1 if betingelse else uttrykk2
La oss bryte ned syntaksen:
- `betingelse`: Den logiske testen som skal evalueres.
- `uttrykk1`: Uttrykket som evalueres hvis betingelsen er `True`.
- `uttrykk2`: Uttrykket som evalueres hvis betingelsen er `False`.
La oss nå identifisere hva `uttrykk1`, `uttrykk2` og `betingelse` vil være fra `if-else`-versjonen av koden.
Ved å sette alt sammen kan vi skrive følgende kode ved hjelp av Pythons ternære operator:
game_over = True if energi <= 0 else False
print(game_over)
# Output: True
La oss ta et annet eksempel. Forestill deg at du driver en bokhandel og tilbyr rabatter avhengig av hvor ofte kunder har besøkt butikken det siste året.
La `numVisits` representere antall besøk:
- Hvis `numVisits` > 7, er rabattprosenten, `discount_perc`, 20.
- Ellers er `discount_perc` 5.
Vi kan bruke den ternære operatoren for å tilordne verdien til variabelen `discount_perc`:
numVisits = 10
discount_perc = 20 if numVisits > 7 else 5
print(discount_perc)
# Output: 20 (siden numVisits = 10 som er > 7)
Nå skal vi utforske hvordan den ternære operatoren kan etterlignes med tupler og ordbøker.
Emulere den Ternære Operatoren med Tupler
Tupler i Python er null-indeksert. Det vil si at det første elementet i en tuppel kalles med indeks 0, det andre elementet med indeks 1, osv.
De grunnleggende datatypene i Python inkluderer heltall, flyttall, strenger og boolske verdier. Python støtter typekonvertering, som lar oss konvertere en datatype til en annen.
Hvis du starter en Python REPL og prøver å konvertere heltall til boolske verdier, vil du legge merke til følgende:
- `bool(0)` returnerer `False`.
- `bool(
)` returnerer `True`.
>>> bool(0)
False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(10)
True
Tilsvarende, når vi konverterer boolske verdier til heltall, får vi følgende:
>>> int(True)
1
>>> int(False)
0
Ved å kombinere typekonvertering og indeksering, kan vi gjøre følgende:
- Elementet ved indeks 0 i tuppelen: Verdien som brukes når betingelsen er `False`.
- Elementet ved indeks 1 i tuppelen: Verdien som brukes når betingelsen er `True`.
Med utgangspunkt i dette har vi følgende:
>>> numVisits = 10
>>> discount_perc = (5,20)[numVisits > 7]
>>> discount_perc
# Output: 20
Her er betingelsen `numVisits > 7` `True` siden `numVisits` er 10. Siden `int(True)` er 1, blir verdien av `discount_perc` 20, som er elementet ved indeks 1.
Emulere den Ternære Operatoren med Ordbøker
Du kan definere `True` og `False` som nøkler i en ordbok, og tilordne `uttrykk1` og `uttrykk2` som verdiene som tilsvarer henholdsvis `True` og `False`:
some_dict = {True: uttrykk1,
False: uttrykk2
}
Hvis du nå bruker `some_dict[betingelse]`, vil `uttrykk1` bli evaluert hvis betingelsen er `True`, og `uttrykk2` vil bli evaluert hvis betingelsen er `False`.
La oss kode `discount_perc`-eksemplet igjen, men denne gangen ved hjelp av en ordbok:
>>> numVisits = 10
>>> discount_dict = {True: 20, False:5}
>>> discount_perc = discount_dict[numVisits > 7]
>>> discount_perc
# Output: 20
Her er `numVisits` satt til 10, som er større enn 7. Derfor er `numVisits > 7` `True`. Dermed evalueres `discount_dict[numVisits > 7]` til `discount_dict[True]`, som er verdien 20.
Bør du Alltid Bruke den Ternære Operatoren?
Vi har nå sett hvordan vi bruker den ternære operatoren, men spørsmålet er: bør vi alltid bruke den? Den ternære operatoren er ikke alltid det beste valget. I dette avsnittet ser vi på situasjoner der du bør foretrekke ternære operatorer fremfor `if-else`-setninger og omvendt.
Mer Konsis enn `if-else`-blokker
Som tidligere nevnt, er den ternære operatoren mer konsis enn en `if-else`-setning. Du kan bruke den til å sjekke betingelser og evaluere uttrykk i en enkelt linje.
I det følgende eksemplet er `nums` en liste med 10 tilfeldig genererte heltall. For hvert tall sjekker vi om det er partall eller oddetall. Denne evalueringen skjer i samme linje som f-strengen:
import random
nums = [random.choice(range(100)) for i in range(10)]
for num in nums:
print(f"{num} er {'partall' if num%2==0 else 'oddetall'}")
# Eksempel på output
0 er partall
56 er partall
6 er partall
53 er oddetall
62 er partall
7 er oddetall
8 er partall
77 er oddetall
41 er oddetall
94 er partall
Den Ternære Operatoren Krever En `else`-klausul
Når du bruker betingede `if-else`-setninger, er `else`-setningen valgfri. La oss se på et eksempel. Variabelen `game_over` settes til `True` hvis energien faller til en verdi som er mindre enn eller lik null.
Hvis derimot energien er større enn null, blir `game_over`-variabelen aldri initialisert. Du vil derfor få en feilmelding hvis du prøver å bruke `game_over`-variabelen.
energi = 5
if energi <= 0:
game_over = True
print(f"Er spillet over? {game_over}")
Traceback (most recent call last):
File "ternary_op.py", line 39, in <module>
print(f"Er spillet over? {game_over}")
NameError: name 'game_over' is not defined
En måte å løse dette på er å sette `game_over` til `False` i utgangspunktet og deretter oppdatere den til `True` hvis energinivået er mindre enn eller lik null.
energi = 5
game_over = False
if energi <= 0:
game_over1 = True
print(f"Er spillet over? {game_over}")
Men når du bruker den ternære operatoren, er ikke `else`-delen valgfri. Den ternære operatoren krever at et uttrykk evalueres når betingelsen er `False`:
game_over = True if energi <= 0 else False
Hvis du endrer koden over til `game_over = True if energi <= 0` ved å fjerne `else`-delen, vil du få en syntaksfeil, som vist:
File "ternary_op.py", line 42
game_over = True if energi <= 0
^
SyntaxError: invalid syntax
Bruk `if-else`-setninger for å Sjekke Flere Betingelser
La oss se på dette eksemplet: Hvert spørsmål i et sett med intervjuoppgaver har en vanskelighetsgrad. Avhengig av denne poengsummen, gir vi en av tre vanskelighetsgrader til hvert spørsmål: lett, middels eller vanskelig. Anta at vi har følgende:
| Poeng | Vanskelighetsgrad |
| Mindre enn 10 | Lett |
| Mellom 10 og 20 | Middels |
| Større enn 20 | Vanskelig |
Gitt en poengsum, kan du finne vanskelighetsgraden ved å bruke den ternære operatoren:
score = 12
difficulty_level = "lett" if score < 10 else "vanskelig" if score > 20 else "middels"
print(difficulty_level)
# Output: middels
Det ternære uttrykket i koden ovenfor har denne formen:
uttrykk1 if betingelse1 else uttrykk2 if betingelse2 else uttrykk3
Selv om den er konsis, er den litt vanskelig å lese. Følgende bilde viser hvordan kontrollflyten oppstår i dette tilfellet.
Følgende kode viser hvordan det samme kan implementeres ved hjelp av `if-else`-setninger. Som du ser er kontrollflyten enklere å forstå, og koden er mer lesbar:
if score < 10:
difficulty_level="lett"
elif score > 20:
difficulty_level="vanskelig"
else:
difficulty_level="middels"
print(difficulty_level)
Når du har flere betingelser, bør du derfor bruke `if-else`-blokker fremfor den ternære operatoren. Dette sørger for at koden er lett å lese og forstå.
Når du trenger å utføre flere setninger avhengig av om betingelsen er sann eller usann, bør du også vurdere å bruke en `if-else`-setning.
Konklusjon
Her er en oppsummering av det vi har gått gjennom:
- I Python kan den ternære operatoren brukes med følgende syntaks: `uttrykk1 if betingelse else uttrykk2`.
- Du kan etterligne oppførselen til den ternære operatoren med tupler og ordbøker.
- Selv om den ternære operatoren kan være mer konsis enn `if-else`-blokker, bør du sørge for at koden er lett å lese. For å forbedre lesbarheten kan du bruke `if-else`-setninger i stedet, spesielt når du trenger å kombinere flere betingelser.
Nå kan du sjekke ut opplæringen om hvordan du bruker lik og ikke-lik operatorer i Python.