[Explained] Hur man implementerar Switch-Case i Python

Önskar du implementera en switch-case struktur i Python? Lär dig olika metoder för att simulera ett switch-case beteende.

Om du har erfarenhet av programmering i C eller JavaScript, har du troligen använt en switch-case sats. Men varför behöver vi egentligen en switch-case struktur?

Anta att du har flera olika handlingar (eller kodblock). Vilken handling som utförs (det kodblock som ska exekveras) bestäms av värdet på en variabel eller ett uttryck.

Några exempel inkluderar:

• Att tilldela betyg till studenter baserat på deras poäng
• Att välja metoder för strängmanipulation beroende på användarens val
• Att utföra aritmetiska operationer på två tal beroende på användarens inmatning

En switch-case konstruktion ger ett praktiskt sätt att implementera denna typ av logik. När du, baserat på variabelns eller uttryckets värde, behöver utföra en av flera möjliga handlingar.

Även om Python saknar en inbyggd switch-case konstruktion, finns det flera metoder du kan använda för att uppnå en liknande funktionalitet. I den här artikeln kommer vi att utforska dessa metoder.

Simulera Switch-Case beteende i Python

Låt oss undersöka hur vi kan emulera switch-case beteende i Python genom ett exempel.

Vi kommer att skapa ett enkelt program som utför följande:

• Väljer slumpmässigt ett ord, en Python sträng, från en lista med ord.
• Ger kontext och frågar användaren. Definiera de strängoperationer (strängmanipulation) som ska utföras på det valda ordet.
• Tillhandahåller operationer för att ändra versalitet (gemener, versaler, titelformat med mera), inklusive ett standardbeteende. Använd inbyggda Python strängmetoder vid behov.
• Ber användaren om inmatning. Då inmatningen som standard är en sträng, konvertera den till ett heltal (int) genom typkonvertering.

Python-strängar är oföränderliga. Strängmetoderna ändrar därför inte den ursprungliga strängen, utan returnerar en kopia med de nödvändiga ändringarna. Låt oss granska de Python strängmetoder vi kommer att använda:

Strängmetod	Beskrivning
lower()	Returnerar en kopia av strängen där alla tecken är i gemener.
upper()	Returnerar en kopia av strängen där alla tecken är i versaler.
title()	Returnerar en kopia av strängen formaterad i titel-format.
swapcase()	Returnerar en kopia av strängen där gemener och versaler byter plats.

Följande kodavsnitt slumpar ett ord från word_list och hämtar användarens inmatning:

  
import random

# Lista med ord att välja ifrån
word_list = ["Python", "programmering", "Hej", "världen", "kontext", "Switch"]

# Välj slumpmässigt ett ord från listan
word = random.choice(word_list)

# Ge kontext och tillgängliga alternativ till användaren
print("Välkommen! Du har fått ett slumpmässigt valt ord.")
print("Välj ett alternativ för att manipulera ordet:")
print("1. Gemener")
print("2. Versaler")
print("3. Titelformat")
print("4. Byt versalitet")
print("5. Standardbeteende")

# Hämta användarens val
option = int(input("Ange ditt val: "))

Här är ett exempel på hur strängen ’Python’ modifieras baserat på användarens val:

När du kör programmet bör du se en fråga om inmatning liknande denna:

  
Välkommen! Du har fått ett slumpmässigt valt ord.

Välj ett alternativ för att manipulera ordet:
1. Gemener
2. Versaler
3. Titelformat
4. Byt versalitet
5. Standardbeteende

Ange ditt val:

Låt oss fortsätta och implementera de olika tillvägagångssätten.

Använda If-Elif-Else Stege

I den här metoden använder vi en serie if-elif-else satser för att kontrollera användarens val mot fördefinierade alternativ. Vi utför sedan motsvarande kodblock baserat på användarens inmatning.

  
# if-elif-else 

if option == 1:
    result = word.lower()
elif option == 2:
    result = word.upper()
elif option == 3:
    result = word.title()
elif option == 4:
    result = word.swapcase()
else:
    result = word

print(f"Ditt slumpmässiga ord är {word} och resultatet är {result}")

Här:

• Jämför vi användarens inmatning med varje alternativ genom if-elif satser.
• När en matchning hittas, kör vi motsvarande kodblock.
• Om inget av if-elif villkoren matchar, kör vi else-blocket för standardbeteende.

Du kan köra skriptet nu, ange ditt val och verifiera resultatet:

  
Välkommen! Du har fått ett slumpmässigt valt ord.

Välj ett alternativ för att manipulera ordet:
1. Gemener
2. Versaler
3. Titelformat
4. Byt versalitet
5. Standardbeteende

Ange ditt val: 2

Ditt slumpmässiga ord är Switch och resultatet är SWITCH.

If-elif-else stegen är enkla att implementera men kan vara svåra att underhålla. I detta exempel hade vi fem fall (inklusive standardbeteendet). I praktiken kan det finnas många fler. Långa if-elif-else steg är en kodlukt man bör undvika.

Låt oss gå vidare till en mer underhållsvänlig implementering.

Använda ordboksmappning och förstklassiga funktioner

Du kan använda Python-ordböcker och funktioner för att emulera switch-case beteende.

📑 Python funktioner är förstklassiga medborgare

I Python är funktioner förstklassiga medborgare. Du kan göra mycket mer än bara definiera och anropa funktioner:

• När du har definierat en funktion kan du tilldela den till en annan variabel, använda funktioner som element i listor, värden i en ordbok med mera.
• Du kan även skicka dem runt: Funktioner kan skickas som argument till andra funktioner och funktioner kan returnera funktioner.

I det här tillvägagångssättet använder vi en ordbok för att mappa användarens val till motsvarande funktioner eller handlingar. Detta är ett mer effektivt sätt att hantera flera val då det undviker en lång kedja av if-elif satser.

Låt oss först definiera följande funktioner för de olika strängoperationerna:

  
# Definiera funktioner för varje alternativ
def lower_case(word):
    return word.lower()

def upper_case(word):
    return word.upper()

def title_case(word):
    return word.title()

def swap_case(word):
    return word.swapcase()

Låt oss sedan göra följande:

• Skapa en ordbok som heter options, där nycklarna är användarens val och värden är funktioner eller handlingar som ska utföras.
• Använd ordbokens metod get() för att hämta den valda handlingen baserat på användarens val. Om valet inte finns i ordboken tillhandahåller vi en standardhandling specificerad av en lambda-funktion.
• Utför sedan den valda handlingen på det slumpmässiga ordet.

  
# Lagra funktioner i en ordbok
options = {
    1: lower_case,
    2: upper_case,
    3: title_case,
    4: swap_case,
}

# Använd ordboken för att välja och anropa lämplig funktion
result = options.get(option, lambda x: x)(word)

print(f"Ditt slumpmässiga ord är {word} och resultatet är {result}")

Här är ett exempel på utdata:

  
Välkommen! Du har fått ett slumpmässigt valt ord.

Välj ett alternativ för att manipulera ordet:
1. Gemener
2. Versaler
3. Titelformat
4. Byt versalitet
5. Standardbeteende

Ange ditt val: 4

Ditt slumpmässiga ord är Hello och resultatet är hELLO.

Använda Match-Case

📝 Obs: Du behöver Python 3.10 eller senare för att kunna använda match-case.

Från och med Python 3.10 kan du använda match-satsen för att implementera en switch-case liknande konstruktion. Match-satsen, med sin enkla syntax, erbjuder ett mer intuitivt sätt att hantera flera fall. _ (understreck) fungerar som standardfall.

Så här kan vi skriva om vårt exempel med hjälp av match-case:

• Vi använder match-satsen för att jämföra användarens inmatning med olika fall.
• Varje fall specificerar ett val och den kod som ska köras om det valet matchar.
• _ (understreck) fungerar som ett standardfall och exekverar kod när inget av de andra fallen matchar.

  
match option:
    case 1:
        result =  word.lower()
    case 2:
        result = word.upper()
    case 3:
        result = word.title()
    case 4:
        result = word.swapcase()
    case _:
        result = word  # Standardbeteende, returnera strängen som den är

print(f"Ditt slumpmässiga ord är {word} och resultatet är {result}.")

Du kan nu köra skriptet och verifiera utdata:

  
Välkommen! Du har fått ett slumpmässigt valt ord.

Välj ett alternativ för att manipulera ordet:
1. Gemener
2. Versaler
3. Titelformat
4. Byt versalitet
5. Standardbeteende

Ange ditt val: 2
Ditt slumpmässiga ord är world och resultatet är WORLD.

⚙ Även om match-satsen är ett bekvämt sätt att implementera en switch-case konstruktion, är den avsedd för mer avancerade strukturell mönstermatchning uppgifter, utöver att simulera switch-case beteende.

Sammanfattning

Låt oss sammanfatta de olika metoderna för att uppnå switch-case funktionalitet i Python:

• If-elif-else stegen är enkla att implementera men kan vara svåra att underhålla. Använd dem sparsamt, endast när du inte har för många alternativ att undersöka.
• Du kan använda Python ordböcker och funktioner för att emulera switch-case beteende. Inkludera de olika valen och motsvarande funktioner som nycklar och värden i ordboken.
• Match-case satsen, introducerad i Python 3.10, hjälper till att implementera denna switch-case konstruktion med en enkel och intuitiv syntax. Match-case satsen är dock ett utmärkt val för mer intressanta strukturella mönstermatchande användningsfall.

Du kan hitta kodexemplen för den här guiden på GitHub. Om du förbereder dig för kodningsintervjuer, kolla in denna sammanställning av de bästa Python intervjufrågorna.