- Den traditionelle switch findes ikke i Python, men den kan effektivt emuleres med betingelsesord og ordbøger.
- Fra og med Python 3.10 bringer den nye match-case-konstruktion øget kraft og læsbarhed ved at erstatte den klassiske switch-case.
- Forskellige teknikker giver dig mulighed for at implementere multiple-choice-logik i Python og tilpasse dig forskellige scenarier og sprogversioner.
Har du nogensinde spekuleret på, hvordan man håndterer flere betingelser i Python enkelt og effektivt? Når du arbejder med sprog som C, Java eller JavaScript, har du sandsynligvis brugt den velkendte switch-case-sætning til at vælge mellem flere muligheder baseret på værdien af en variabel. Men i Python eksisterede denne klassiske mekanisme ikke ... indtil for nylig. Mens udviklere har været nødt til at finde alternativer i årevis, tilbyder sproget nu en moderne og kraftfuld løsning.
Denne artikel er din ultimative guide til at forstå, hvordan man bruger Python-ækvivalenten til `switch` , opdager stærkere alternativer i ældre versioner, afklarer, hvorfor det ikke var inkluderet i de tidlige stadier, og lærer at skrive renere og mere læsbar kode, uanset hvilken version du bruger. Gør dig klar til at lære alle tricks, eksempler og nøgleforskelle i implementeringen af flere betingelseskoder i Python-økosystemet.
Findes kontakten i Python? Historie og årsager til dens fravær
Switch-case-syntaksen, som findes i mange sprog, kom ikke officielt til Python før version 3.10. Hovedårsagen er filosofisk: Pythons skabere har altid prioriteret enkelhed og læsbarhed. De mente, at introduktionen af en ny syntaks til switch-sætninger kunne komplicere tingene, så if-elif-else var tilstrækkeligt til at udfylde dette hul. Desuden var der aldrig enighed om den ideelle syntaks. Faktisk blev flere officielle forslag (PEP 275, PEP 3103) afvist på grund af manglende enighed, og fordi mange mente, at eksisterende alternativer var klare og effektive nok.
I årevis har fællesskabet kompenseret for manglen på en "switch"-sætning ved hjælp af betingede kæder og ordbøger. Det siger sig selv, at dette skabte debat, men langt fra at være en uoverstigelig ulempe, har disse tilgange vist sig at være fleksible og yderst tilpasningsdygtige. Men efterhånden som projekterne voksede i kompleksitet, blev behovet for en mere elegant løsning mere tydeligt.
Hvad er en switch-boks, og hvad bruges den til?
Switch -case-sætningen er en kontrolstruktur, der bruges i mange sprog til at udføre forskellige kodeblokke afhængigt af værdien af en variabel eller et udtryk. Med andre ord giver den dig mulighed for at vælge én mulighed fra mange muligheder på en ren og direkte måde, hvilket undgår endeløse kæder af betingede sætninger.
Typiske brugseksempler ville være: visning af navnet på en ugedag baseret på et tal, tildeling af karakterer, valg af operationer baseret på brugerinput osv. I sprog som C eller Java er syntaksen enkel:
switch(valor) {
case 1:
// acción
break;
case 2:
// otra acción
break;
default:
// acción por defecto
}I Python eksisterede denne klassiske struktur ikke før for nylig, så udviklere har måttet være opfindsomme for at opnå det samme resultat.
Ankomsten af switchen i Python: match-case-sætningen (siden Python 3.10)
Med udgivelsen af version 3.10 inkorporerede Python en længe ventet funktion: match-case-sætningen. Selvom dens syntaks ligner den traditionelle switch-case-sætning, er den faktisk meget mere kraftfuld, da den introducerer mønstermatchning , der muliggør sammenligning af ikke kun simple værdier, men også komplekse strukturer, tupler, klasser, lister, ordbøger og så videre.
Pythons match-case er skrevet således:
def ejemplo_switch(x):
match x:
case 1:
return "uno"
case 2:
return "dos"
case _:
return "desconocido"Understregningstegnet ( _ ) fungerer som et jokertegn og svarer til standardtegnet i andre sprog, der udføres, når intet tidligere mønster matcher.
Hvorfor er det så kraftfuldt? Fordi du kan modtage komplekse mønstre, registrere variabler, åbne tupler eller objekter og endda bruge vagter til at tilføje ekstra betingelser efter case-sætningen:
match dato:
case (a, b) if a > b:
print("El primer elemento es mayor que el segundo")
case (a, b):
print(f"Valores: {a}, {b}")Derudover forbedrer denne struktur læsbarheden, vedligeholdelsen og skalerbarheden af din kode i Python 3.10 og nyere, især når du håndterer mange cases.
Alternativer til at skifte i Python for ældre versioner
Før match-case kom til verden , udtænkte udviklere lige så gyldige alternativer. De to mest almindelige var brugen af if-elif-else-strenge og ordbogsmapping . Lad os se nærmere på dem:
1. Brug af if-elif-else
Den mest direkte og nemmeste løsning er at kæde betingelser sammen ved hjælp af if, elif og else. Dette giver dig mulighed for at dække alle mulige værdier af en variabel og udføre den tilsvarende kodeblok. For eksempel, for at vise ugedagen baseret på et tal:
dia = 4
if dia == 1:
print('lunes')
elif dia == 2:
print('martes')
elif dia == 3:
print('miércoles')
elif dia == 4:
print('jueves')
elif dia == 5:
print('viernes')
elif dia == 6:
print('sábado')
elif dia == 7:
print('domingo')
else:
print('error')Fordele ved denne tilgang:
- Enkel og letlæselig kode.
- Du behøver ingen andre specielle strukturer; det er ren Python.
- Enhver form for sammenligning kan bruges, ikke kun lighed.
Ulemper ved if-elif-else-stigen:
- Tendens til gentagende kode. Du skal gentage variablen i hver sammenligning, hvilket genererer en masse unødvendig tekst, hvis du har mange tilfælde.
- Mindre effektiv, når der er et stort antal betingelser. Hvis sagen er ved at være afsluttet, evalueres alle tidligere sager, inden de ankommer.
- Vanskeligheder med at tilføje eller fjerne sager dynamisk.
2. Brug af ordbøger til at simulere switch-case
En meget pythonisk måde at simulere en switch-sætning på er ved at bruge ordbøger. Ideen er enkel: du forbinder hver mulig værdi (nøgle) med den tilsvarende funktion eller handling (værdi). Derefter forespørger du ordbogen for at hente funktionen og udføre den.
def lunes():
print('lunes')
def martes():
print('martes')
def error():
print('error')
switch_semana = {
1: lunes,
2: martes,
# ... otros días ...
}
dia = 8
switch_semana.get(dia, error)()Fordele ved denne metode:
- Kompakt og let udvidelig kode.
- Meget hurtig adgang til den rigtige funktion. Ordbogen bruger hashing, så søgningen er næsten øjeblikkelig.
- Giver dig mulighed for at tildele den samme funktion til flere taster (for eksempel til grupper af sager).
- Switchen kan ændres under kørsel.
Ulemper:
- Det kræver forudgående definition af alle tilknyttede funktioner, hvilket kan være besværligt ved simple handlinger.
- Den tillader kun sammenligninger for lighed (den fungerer ikke for intervaller, intervaller osv.).
- Den er ikke beregnet til tilfælde med mere kompleks betinget logik inden for hvert valg.
Forskellen mellem if-elif-else og switch (eller match-case)
De interne funktioner i en if-elif-else-kæde adskiller sig fra en switch-sætnings interne funktioner. I en if-elif-else-sætning evalueres betingelserne én efter én, fra top til bund, indtil den første sande betingelse er opfyldt. Derfor, hvis den ønskede værdi er i begyndelsen, er processen hurtig; hvis den er i slutningen, tager den længere tid.
I modsætning hertil bruger traditionelle switch-sætninger (og ordbøger som et alternativ i Python) typisk opslagstabeller, hvilket resulterer i mere ensartet adgang, uanset antallet af cases eller deres position. Med match-case-sætninger og ordbøger er adgangstiderne meget mere konsistente.
Hvornår skal man vælge hvert alternativ?
Der findes ingen universel løsning; det bedste værktøj afhænger af det specifikke problem.
- For et lille antal betingelser eller kompleks logik i hver gren er if-elif-else det mest ligetil valg. Det muliggør enhver sammenligning og er meget fleksibelt.
- Når du har mange tilfælde, og hvert enkelt blot udfører en specifik handling, så stol på ordbøger. Koden er renere, skalerbar og nemmere at vedligeholde.
- Hvis du bruger Python 3.10 eller nyere, tændstiketui Det er den bedste mulighed for klarhed og kraft. Det giver dig mulighed for at kombinere afbryderens elegance med kraften i mønstermatchning på komplekse strukturer.
Tænk altid på din kodes læsbarhed, ydeevne og vedligeholdelsesvenlighed.
Praktiske eksempler på brug af switch i Python og dens alternativer
Lad os se på flere eksempler, hvor hvert af disse alternativer anvendes, fra mindst til størst kompleksitet:
Eksempel 1: Beregn karakter baseret på en score
# Usando if-elif-else
puntuacion = 85
if puntuacion >= 90:
print('Sobresaliente')
elif puntuacion >= 80:
print('Notable')
elif puntuacion >= 70:
print('Bien')
else:
print('Insuficiente')Dette tilfælde er perfekt til brug af betingede sætninger, da du arbejder med intervaller, ikke faste værdier.
Eksempel 2: Vis ugedag efter tal (med ordbog)
# Definición de funciones para cada día
def lunes():
print('lunes')
def martes():
print('martes')
def miercoles():
print('miércoles')
def jueves():
print('jueves')
def viernes():
print('viernes')
def sabado():
print('sábado')
def domingo():
print('domingo')
def error():
print('error')
switch_semana = {
1: lunes,
2: martes,
3: miercoles,
4: jueves,
5: viernes,
6: sabado,
7: domingo
}
dia = 8
switch_semana.get(dia, error)()Eksempel 3: Brug af match-case til at vælge en aritmetisk operation
operacion = 'suma'
a = 10
b = 5
match operacion:
case 'suma':
print(a + b)
case 'resta':
print(a - b)
case 'multiplicacion':
print(a * b)
case 'division':
print(a / b)
case _:
print('Operación no válida')Som du kan se, er syntaksen enkel og meget klar. Understregningen angiver standardstore bogstaver.
Avanceret eksempel: mønstermatchning med match-case
Den store styrke ved match-case-analyse ligger i dens evne til at arbejde med komplekse mønstre. For eksempel kan du analysere tupler, lister, ordbøger, objekter og så videre.
punto = (3, 5)
match punto:
case (0, 0):
print('Origen')
case (0, y):
print(f'Eje Y en {y}')
case (x, 0):
print(f'Eje X en {x}')
case (x, y):
print(f'Coordenadas X={x}, Y={y}')Du kan endda bruge if (guard)-klausulen til at tilføje yderligere betingelser til hvert tilfælde.
Ydelsesforskelle mellem if-elif-else, ordbøger og match-case
I de fleste tilfælde er forskellen i ydeevne ubetydelig for typiske scripts. Men når der er et stort antal alternativer, kan ordbøger og match-case-argumenter være mere effektive, da de reducerer antallet af sammenligninger. Under alle omstændigheder er den vigtigste faktor normalt kodens læsbarhed og vedligeholdelsesvenlighed snarere end mikrooptimeringer, der sjældent gør en forskel i virkelige projekter.
Brug den teknik, der gør koden tydeligere og undgår fejl.
Kreative løsninger: klasser og kontekstadministratorer til at emulere switch
Nogle udviklere har skabt specialiserede klasser, der tillader at emulere switchens klassiske opførsel, herunder avancerede muligheder såsom at tilføje break for at kontrollere udførelsen af efterfølgende cases, gruppere cases, tilpasse sammenligninger eller aktivere en strict mode, der sikrer, at kun én branch udføres.
For eksempel kan en brugerdefineret kontekstmanager implementeres til at bruge en syntaks, der minder meget om andre sprog:
class switch:
def __init__(self, variable, comparator=None, strict=False):
self.variable = variable
self.matched = False
self.matching = False
if comparator:
self.comparator = comparator
else:
self.comparator = lambda x, y: x == y
self.strict = strict
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def case(self, expr, break_=False):
if self.strict:
if self.matched:
return False
if self.matching or self.comparator(self.variable, expr):
if not break_:
self.matching = True
else:
self.matched = True
self.matching = False
return True
else:
return False
else:
if self.matching or self.comparator(self.variable, expr):
if not break_:
self.matching = True
else:
self.matched = True
self.matching = False
return True
else:
return False
def default(self):
return not self.matched and not self.matching
Brug af denne klasse muliggør en syntaks som denne:
dia = 4
with switch(dia) as s:
if s.case(1, True): print('lunes')
if s.case(2, True): print('martes')
if s.case(3, True): print('miércoles')
if s.case(4, True): print('jueves')
if s.case(5, True): print('viernes')
if s.case(6, True): print('sábado')
if s.case(7, True): print('domingo')
if s.default(): print('error')Hvad er fordelene ved denne løsning? Den har en meget velkendt syntaks for dem, der kommer fra andre sprog, og giver mulighed for avancerede tilpasninger, såsom at bruge en hvilken som helst sammenligningsfunktion, gruppere tilfælde, udføre flere grene eller kun én osv. Ulempen er, at den har tendens til at være langsommere og kræver import eller definition af specialklassen.
Brug af lambda-funktioner til at forenkle handlinger i ordbøger
Ofte behøver du ikke at definere separate funktioner for hver handling; du kan bruge anonyme (lambda) funktioner. Dette er især praktisk, når den handling, der skal udføres, er simpel:
switch_operaciones = {
'sumar': lambda a, b: a + b,
'restar': lambda a, b: a - b,
'multiplicar': lambda a, b: a * b
}
operacion = 'sumar'
resultado = switch_operaciones.get(operacion, lambda a, b: None)(5, 3)
print(resultado)Dette gør koden kompakt og nem at udvide uden at miste klarhed.
Avancerede brugsscenarier: Mønstermatchning i Match-Case
Python 3.10's `match-case` -sætning går langt ud over blot at kopiere den klassiske `switch-case`-sætning. Dens sande styrke ligger i at matche strukturelle mønstre . For eksempel giver den dig mulighed for nemt at skelne mellem forskellige datastrukturer, brugerdefinerede klasser, nedbryde objekter og registrere underelementer.
Eksempel med lister og tupler:
datos =
match datos:
case :
print('Lista con 1, 2, 3')
case :
print('Lista que empieza con 1')
case _:
print('Otra lista')Eksempel med objekter (forudsat en Point-klasse):
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y
p = Punto(2, 3)
match p:
case Punto(x=0, y=0):
print('Origen')
case Punto(x, y):
print(f'Coordenadas: {x} {y}')Denne mekanisme giver dig mulighed for at skrive meget udtryksfuld kode, der tilpasser sig komplekse strukturer uden at miste læsbarhed.
Aspekter at overveje ved migrering af kode: kompatibilitet og bedste praksis
Ikke alle projekter har råd til at bruge match-case med det samme. Hvis du arbejder i miljøer med ældre versioner af Python (f.eks. 3.8 eller 3.9), bliver du nødt til at vælge ordbøger. Når det er muligt at opgradere til 3.10+, så udnyt kraften og klarheden ved mønstermatchning, især i projekter, hvor multipel selektionslogik er afgørende.
husk:
- Vælg den mulighed, der tilbyder den bedste læsbarhed, fleksibilitet og nemme vedligeholdelse.
- I meget simple problemer (et par tilfælde) er if-elif-else normalt tilstrækkeligt og mere direkte.
- Brug ordbøger og funktioner til store udvalgstabeller.
- For komplekse strukturer eller for at udnytte moderne Python fuldt ud, vælg match-case.
Et lille trick: du kan konvertere eksisterende funktioner til at acceptere handlingsordbøger, hvilket gør overgangen mellem tilgange endnu nemmere.
Optimerings- og designtips til renere Python-kode
Fald ikke i fælden med at designe endeløse kæder af betingede koder blot for at efterligne den klassiske switch-sætning. Tænk over hvert enkelt tilfælde og vurder hvilken kontrolstruktur der tilføjer mest værdi til dit programs kontekst. Husk, at Python værdsætter klarhed, så undgå at overkomplicere din kode, hvis du nemt kan opnå det samme resultat.
Et vigtigt tip: Når du bruger ordbøger, skal du bruge funktionen get() for at undgå fejl, hvis nøglen ikke findes, og dermed være i stand til elegant at definere en standardsag.
Sammenligning med andre sprog og endelige tanker
I nogle sprog, såsom C, C++ eller Java, tillader switche kun sammenligning af simple værdier (heltal, strenge) og giver ringe værdi til komplekse strukturer. Python går et skridt videre: for det første tilbyder det alsidige alternativer (if-elif-else, ordbøger), og nu åbner det døren til avanceret logik uden ekstra indsats. Nøglen er at udnytte fordelene ved hver version og ikke tvinge sig selv til at imitere andre syntakser, hvis problemet kræver en anden løsning.
Hvis du lige er begyndt at bruge Python eller bruger andre sprog, så bliv ikke frustreret, hvis du ikke kan finde nøgleordet "switch" i manualen. Tænk over alle de tilgængelige muligheder, og vælg den, der passer bedst til din kontekst og dine behov.
Det har aldrig været nemmere eller mere effektivt at administrere flere alternativer i Python. Nu forstår du årsagerne bag fraværet (og den efterfølgende ankomst) af switchen, hvordan man simulerer den effektivt i enhver version, og hvordan man får mest muligt ud af den nye match-case-sætning. Uanset om du skal vælge mellem et halvt dusin muligheder, manipulere komplekse strukturer, følge bedste praksis eller bekymre dig om ydeevne, har du robuste, elegante og fleksible alternativer. Uanset om din kode er til hurtige scripts eller komplekse applikationer, giver Python dig værktøjerne til at skrive den klart, hurtigt og nemt.
