Hur man använder Switch i Python: En definitiv guide med exempel och alternativ

Informatec Digital » programmering » Hur man använder Switch i Python: En definitiv guide med exempel och alternativ

Har du någonsin undrat hur man hanterar flera villkor i Python enkelt och effektivt? När du har arbetat med språk som C, Java eller JavaScript har du säkert använt de berömda switch fallet att välja mellan flera alternativ baserat på värdet på en variabel. I Python existerade dock inte denna klassiska mekanism... förrän nyligen. Naturligtvis, medan utvecklare har varit tvungna att leta efter alternativ i åratal, erbjuder språket nu en modern och kraftfull lösning.

Den här artikeln är din ultimata guide till att förstå hur man använder switch-ekvivalenten i Python., upptäck de mest robusta alternativen i äldre versioner, förtydliga varför det inte införlivades i ett tidigt skede och lär dig hur du skriver renare och mer läsbar kod, oavsett vilken version du använder. Gör dig redo att lära dig alla knep, exempel och viktiga skillnader i att implementera flera villkor i Pythons ekosystem.

Finns omkopplaren i Python? Historik och orsaker till dess frånvaro

Switch-case, som finns på många språk, kom aldrig officiellt till Python förrän version 3.10. Den främsta anledningen är filosofisk: Pythons skapare har alltid varit engagerade i enkelhet och läsbarhet. De trodde att införandet av en ny switchsyntax kunde komplicera saker och ting, så om-elif-annat var tillräckligt för att fylla den luckan. Dessutom fanns det aldrig enighet om den ideala syntaxen. Faktum är att flera officiella förslag (PEP 275, PEP 3103) förkastades på grund av bristande enighet och eftersom många ansåg att de befintliga alternativen var tillräckligt tydliga och kraftfulla.

I åratal har gemenskapen kompenserat för avsaknaden av växlar genom att använda kedjor av villkor och ordböcker. Naturligtvis skapade ämnet debatt, men långt ifrån att vara en oöverstiglig nackdel har dessa metoder visat sig vara flexibla och mycket anpassningsbara. Men i takt med att projekten växte i komplexitet uppstod behovet av en mer elegant lösning alltmer.

Vad är ett strömbrytarhölje och vad används det till?

El switch fallet Det är en kontrollstruktur som används i många språk för att exekvera olika kodblock baserat på värdet på en variabel eller ett uttryck. Med andra ord låter den dig välja ett alternativ från många möjliga alternativ på ett rent och enkelt sätt, vilket undviker oändliga kedjor av villkor.

Typiska användningsexempel skulle vara: visa namnet på en veckodag baserat på ett nummer, tilldela betyg, välja operationer baserat på användarinmatning, etc. I språk som C eller Java är syntaxen enkel:

switch(valor) {
    case 1:
        // acción
        break;
    case 2:
        // otra acción
        break;
    default:
        // acción por defecto
}

I Python existerade inte denna klassiska struktur förrän nyligen, så utvecklare har varit tvungna att vara uppfinningsrika för att uppnå samma resultat.

Ankomsten av switchen i Python: match-case-satsen (sedan Python 3.10)

Med lanseringen av version 3.10 införlivade Python en länge efterlängtad funktion: matchningsfallsutlåtandet. Även om dess syntax påminner om det traditionella switch-caset, är det faktiskt mycket kraftfullare, eftersom det introducerar mönstermatchning (mönstermatchning), vilket gör det möjligt att jämföra inte bara enkla värden, utan även komplexa strukturer, tupler, klasser, listor, ordböcker etc.

Pythons matchningsfall skrivs så här:

def ejemplo_switch(x):
    match x:
        case 1:
            return "uno"
        case 2:
            return "dos"
        case _:
            return "desconocido"

Understrecket (_) fungerar som ett jokertecken och motsvarar standard I andra språk, körs när inget tidigare mönster matchar.

Varför är den så kraftfull? Eftersom du kan ta emot komplexa mönster, fånga variabler, öppna tupler eller objekt och till och med använda guards för att lägga till extra villkor efter fallet:

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}")

Dessutom förbättrar den här strukturen läsbarheten, underhållbarheten och skalbarheten för din kod i Python 3.10 och senare, särskilt vid hantering av många fall.

Alternativ för att byta i Python för äldre versioner

Före ankomsten av tändsticksfodral, utvecklare kommer med lika giltiga alternativ. De två vanligaste är användningen av if-elif-else-kedjor och mappning med hjälp av ordböcker.Låt oss ta en närmare titt:

1. Använda if-elif-else

Den mest direkta och lättförståeliga lösningen är att kedjekoppla villkor med hjälp av if, elif och else. På så sätt kan du täcka alla möjliga värden för en variabel och köra motsvarande kodblock. Till exempel, för att visa veckodagen baserat på ett 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')

Fördelar med denna metod:

• Enkel och lättläst kod.
• Du behöver inga andra speciella strukturer; det är ren Python.
• Alla typer av jämförelser kan användas, inte bara jämlikhet.

Nackdelar med if-elif-else-stegen:

• Tendens till repetitiv kod. Du måste upprepa variabeln i varje jämförelse, vilket genererar mycket onödig text om du har många fall.
• Mindre effektivt när det finns ett stort antal villkor. Om ärendet är i slutet utvärderas alla tidigare ärenden innan de anländer.
• Svårigheter att lägga till eller ta bort ärenden dynamiskt.

2. Använda ordböcker för att simulera switchfall

Ett mycket pythoniskt sätt att simulera switchar är att använda ordböcker. Idén är enkel: du associerar varje möjligt värde (nyckel) med motsvarande funktion eller åtgärd (värde). Sedan slår du upp ordboken för att hitta funktionen och kör 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)()

Fördelar med denna metod:

• Kompakt och lätt utökningsbar kod.
• Mycket snabb åtkomst till rätt funktion. Ordboken använder hashing, så sökningen sker nästan omedelbart.
• Låter dig tilldela samma funktion till flera tangenter (till exempel till gruppärenden).
• Växeln kan ändras under körning.

Nackdelar:

• Det kräver att alla tillhörande funktioner definieras i förväg, vilket kan vara besvärligt för enkla åtgärder.
• Den tillåter bara jämförelser för likhet (den fungerar inte för intervall, intervall etc.).
• Den är inte avsedd för fall med mer komplex villkorlig logik inom varje val.

Skillnaden mellan if-elif-else och switch (eller match-case)

De interna funktionerna i en if-elif-else-kedja skiljer sig från en switch. I if-elif-else utvärderas villkoren ett efter ett, uppifrån och ner, tills det första villkoret är sant. Därför, om det sökta värdet är i början, körs det snabbt; om det är i slutet tar det längre tid.

Traditionella switchar (och ordboken som ett alternativ i Python) använder istället ofta uppslagstabeller, så åtkomsten är mer enhetlig, oavsett hur många instanser det finns eller deras position. tändsticksfodral och ordböcker, är åtkomsttiden mycket mer homogen.

När ska man välja varje alternativ?

Det finns ingen universell lösning; det bästa verktyget beror på det specifika problemet.

• För ett litet antal villkor eller komplex logik i varje gren är if-elif-else det enklaste valet. Den möjliggör alla jämförelser och är mycket flexibel.
• När du har många fall och vart och ett helt enkelt utför en specifik handling, förlita dig på ordböcker. Koden är renare, skalbar och enklare att underhålla.
• Om du använder Python 3.10 eller senare, tändsticksfodral Det är det bästa alternativet för tydlighet och kraft. Det låter dig kombinera elegansen hos en strömbrytare med kraften i mönstermatchning på komplexa strukturer.

Tänk alltid på din kods läsbarhet, prestanda och underhållbarhet.

Praktiska exempel på att använda switch i Python och dess alternativ

Låt oss titta på flera exempel där vart och ett av dessa alternativ tillämpas, från minst till största komplexitet:

Exempel 1: Beräkna betyg baserat på ett resultat

# Usando if-elif-else
puntuacion = 85
if puntuacion >= 90:
    print('Sobresaliente')
elif puntuacion >= 80:
    print('Notable')
elif puntuacion >= 70:
    print('Bien')
else:
    print('Insuficiente')

Det här fallet är perfekt för att använda villkor, eftersom du arbetar med intervall, inte fasta värden.

Exempel 2: Visa veckodag med siffror (med ordbok)

# 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)()

Exempel 3: Använda match-case för att välja 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 ni kan se är syntaxen enkel och mycket tydlig. Understrecket indikerar standardversionen av versaler och gemener.

Avancerat exempel: mönstermatchning med match-case

Match-cases stora styrka är dess förmåga att arbeta med komplexa mönster. Du kan till exempel analysera tupler, listor, ordböcker, objekt etc.

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 till och med använda klausulen if (vakt) för att lägga till ytterligare villkor i varje fall.

Prestandaskillnader mellan if-elif-else, ordböcker och match-case

I de flesta fall är prestandaskillnaden försumbar för vanliga skript. Men när det finns ett stort antal alternativ kan ordböcker och matchningsverktyg vara mer effektiva, eftersom de minskar antalet jämförelser. Den viktigaste faktorn är dock vanligtvis kodläsbarhet och underhållbarhet, snarare än mikrooptimeringar som sällan gör skillnad i verkliga projekt.

Använd den teknik som gör koden tydligare och undviker fel.

Kreativa lösningar: klasser och kontexthanterare för att emulera switch

Vissa utvecklare har skapat specialiserade klasser som tillåter emulering av klassiskt switchbeteende, inklusive avancerade alternativ som att lägga till bryta för att styra körningen av efterföljande fall, gruppera fall, anpassa jämförelser eller aktivera strict-läge för att säkerställa att endast en gren körs.

Till exempel kan en anpassad kontexthanterare implementeras för att använda en syntax som är mycket lik den i andra språk:

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

Att använda den här klassen möjliggör en syntax som denna:

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')

Fördelar med denna lösning? Den har en mycket välbekant syntax för de som kommer från andra språk och möjliggör avancerade anpassningar, som att använda valfri jämförelsefunktion, gruppera fall, köra flera grenar eller bara en, etc. Nackdelen är att den vanligtvis är långsammare och kräver import eller definition av specialklassen.

Använda lambdafunktioner för att förenkla åtgärder i ordböcker

Många gånger behöver du inte definiera separata funktioner för varje åtgärd; du kan använda anonyma funktioner (lambdas). Detta är särskilt praktiskt när åtgärden som ska utföras är enkel:

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)

Detta gör koden kompakt och enkel att utöka utan att förlora tydlighet.

Avancerade användningsfall: Mönstermatchning i Match-Case

Mening tändsticksfodral Python 3.10 går långt bortom att kopiera det klassiska switchfallet. Dess verkliga kraft ligger i strukturell mönstermatchningTill exempel låter det dig skilja mellan olika datastrukturer, anpassade klasser, dela upp objekt och enkelt fånga underelement.

Exempel med listor och tupler:

datos = 
match datos:
    case :
        print('Lista con 1, 2, 3')
    case :
        print('Lista que empieza con 1')
    case _:
        print('Otra lista')

Exempel med objekt (förutsatt en Point-klass):

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}')

Denna mekanism låter dig skriva mycket uttrycksfull kod som anpassar sig till komplexa strukturer utan att förlora läsbarhet.

Aspekter att beakta vid migrering av kod: kompatibilitet och bästa praxis

Inte alla projekt har råd att använda tändsticksfodral direkt. Om du arbetar i miljöer med äldre versioner av Python (till exempel 3.8 eller 3.9) behöver du välja ordböcker. När du kan uppgradera till 3.10 eller senare kan du dra nytta av kraften och tydligheten hos mönstermatchning, särskilt i projekt där logik med flera val är avgörande.

kom ihåg:

• Välj det alternativ som erbjuder bäst läsbarhet, flexibilitet och enkelt underhåll.
• I mycket enkla problem (ett fåtal fall) är if-elif-else vanligtvis tillräckligt och mer direkt.
• För stora urvalstabeller, använd ordböcker och funktioner.
• För komplexa strukturer eller för att dra full nytta av moderna Python, välj match-case.

Ett litet knep: du kan konvertera befintliga funktioner för att acceptera handlingsordböcker, vilket gör övergången mellan metoder ännu enklare.

Optimerings- och designtips för renare Python-kod

Gör inte misstaget att designa oändliga kedjor av villkor bara för att imitera den klassiska växlingen. Tänk på varje specifikt fall och bedöm vilken kontrollstruktur som ger mest värde till ditt programs kontext. Kom ihåg att Python värdesätter tydlighet, så undvik att överkomplicera din kod om du kan uppnå samma resultat lättare.

Ett viktigt tips: När du använder ordböcker, använd funktionen get() för att undvika fel om nyckeln inte finns och därmed kunna definiera ett standardfall/fall elegant.

Jämförelse med andra språk och slutliga tankar

I vissa språk, som C, C++ eller Java, tillåter switchar bara jämförelse av enkla värden (heltal, strängar) och ger lite värde för komplexa strukturer. Python går ett steg längre: för det första erbjuder det mångsidiga alternativ (if-elif-else, ordböcker), och nu öppnar det dörren till avancerad logik utan extra ansträngning. Nyckeln är att dra nytta av fördelarna med varje version och inte tvinga sig själv att imitera andra syntaxer om problemet kräver en annan lösning.

Om du precis har börjat använda Python eller använder andra språk, bli inte frustrerad om du inte hittar nyckelordet switch i manualen. Tänk på alla tillgängliga möjligheter och välj den som bäst passar ditt sammanhang och dina behov.

Att hantera flera alternativ i Python har aldrig varit enklare eller kraftfullare. Nu förstår du orsakerna bakom frånvaron (och den efterföljande ankomsten) av switchen, hur man simulerar den effektivt i vilken version som helst och hur man får ut det mesta av den nya match-case-satsen. Oavsett om du måste välja mellan ett halvdussin alternativ, manipulera komplexa strukturer, följa bästa praxis eller oroa dig för prestanda, har du robusta, eleganta och flexibla alternativ. Oavsett om din kod är för snabba skript eller komplexa applikationer, ger Python dig verktygen för att skriva den tydligt, snabbt och enkelt.