[Explained] Hur man implementerar Switch-Case i Python

Vill du implementera en switch-case-konstruktion i Python? Lär dig de olika tillvägagångssätten du kan ta för att efterlikna växelfallsbeteende.

Om du har programmerat i C eller JavaScript har du använt switch-case-satsen. Men varför behöver vi en växelhuskonstruktion?

Anta att du har en uppsättning olika åtgärder (eller kodblock). Och vilken åtgärd du utför (kodblocket som ska utföras) beror på värdet på en variabel eller ett uttryck.

Några exempel inkluderar:

  • Tilldela betyg till elever baserat på deras poäng
  • Att välja tekniker för strängmanipulation baserat på användarens val
  • Utföra aritmetiska operationer på två siffror beroende på användarens inmatning

Så switch-case-konstruktionen ger ett bekvämt sätt att implementera sådan logik. När du behöver utföra – baserat på variabeln eller uttryckets värde – en av många möjliga åtgärder.

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

Emulera Switch-Case Behavior i Python

Låt oss se hur vi kan emulera switch-case-beteende i Python genom att ta ett exempel.

Vi kommer att skriva ett enkelt program som gör följande:

  • Prova ett ord, en Python-sträng, slumpmässigt från en lista med ord.
  • Ange sammanhang och fråga användaren. Definiera strängoperationerna – strängmanipulation – som ska utföras på det valda ordet.
  • Redovisa operationer för förändring av skiftlägen (gemener, versaler, rubriker och mer) inklusive ett standardbeteende. Använd inbyggda Python-strängmetoder efter behov.
  • Be användaren om input. Eftersom indata, som standard, är en sträng, konvertera den till en int efter typ casting.

Python-strängar är oföränderliga. Så strängmetoderna ändrar inte den ursprungliga strängen. Snarare returnerar de en kopia av strängen med de nödvändiga ändringarna. Låt oss granska Python-strängmetoderna som vi kommer att använda:

String MethodDescriptionlower()Returnerar en kopia av strängen där alla tecken är i gemen versupper()Returnerar en kopia av strängen där alla tecken är i versaler titel()Returnerar en kopia av strängen formaterad i titel casewapcase()Returnerar en kopia av strängen där gemener och versaler konverteras till versaler respektive gemener

Följande kodavsnitt samplar ett ord från word_list slumpmässigt och hämtar användarinmatning:

import random

# List of words to choose from
word_list = ["Python", "programming", "Hello", "world", "context", "Switch"]

# Randomly select a word from the list
word = random.choice(word_list)

# Provide context and available options to the user
print("Welcome! You have a randomly selected word.")
print("Choose an option to manipulate the word:")
print("1. Lowercase")
print("2. Uppercase")
print("3. Titlecase")
print("4. Swapcase")
print("5. Default behavior")

# Get user option
option = int(input("Enter your option: "))

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

När du nu kör programmet bör du bli tillfrågad om inmatningen så här:

Welcome! You have a randomly selected word.

Choose an option to manipulate the word:
1. Lowercase
2. Uppercase
3. Titlecase
4. Swapcase
5. Default behavior

Enter your option: 

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

Använder If-Elif-Else Ladder

I detta tillvägagångssätt använder vi en serie if-elif-else-satser för att kontrollera användarens val mot fördefinierade alternativ. Vi exekverar sedan ett 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"Your random word is {word} and the result is {result}")

Här:

  • Vi jämför användarens input med varje alternativ med 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 valet och verifiera resultatet:

Welcome! You have a randomly selected word

Choose an option to manipulate the word:
1. Lowercase
2. Uppercase
3. Titlecase
4. Swapcase
5. Default behavior

Enter your option: 2

Your random word is Switch and the result is SWITCH.

If-elif-else-stegen är lätt att implementera. Men det kan vara en utmaning att underhålla. I det här exemplet hade vi fem fall (inklusive standardbeteendet). I praktiken kan vi dock ha många fler fall. Så långa if-elif-else-stegar är en kodlukt man bör undvika.

Så låt oss gå vidare till en implementering som är underhållbar.

Använda ordboksmappning och förstklassiga funktioner

Du kan använda Python-ordböcker och funktioner för att efterlikna växelfallsbeteende.

📑 Python-funktioner är förstklassiga medborgare

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

  • När du väl har definierat en funktion kan du tilldela den till en annan variabel, använda funktioner som element i listor, värden i en ordbok och mycket mer.
  • Du kan också skicka dem runt: funktioner kan skickas in som argument till andra funktioner och funktioner kan returnera funktioner.

I detta tillvägagångssätt kommer vi att använda en ordbok för att mappa användarens val till motsvarande funktioner eller åtgärder. Detta är ett mer effektivt sätt att hantera flera val, eftersom 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:

# Define functions for each option
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 val där nycklarna är användarval och värden är funktioner eller åtgärder som ska utföras.
  • Använd ordboksmetoden get() för att hämta den valda åtgärden baserat på användarens val. Om valet inte finns i ordboken tillhandahåller vi en standardåtgärd specificerad av en lambda-funktion.
  • Utför sedan den valda åtgärden på det slumpmässiga ordet.
# Store functions in a dictionary
options = {
    1: lower_case,
    2: upper_case,
    3: title_case,
    4: swap_case,
}

# Use the dictionary to select and call the appropriate function
result = options.get(option, lambda x: x)(word)

print(f"Your random word is {word} and the result is {result}")

Här är ett exempel på utdata:

Welcome! You have a randomly selected word.

Choose an option to manipulate the word:
1. Lowercase
2. Uppercase
3. Titlecase
4. Swapcase
5. Default behavior

Enter your option: 4

Your random word is Hello and the result is hELLO.

Använder Match-Case

📝 Obs: Du behöver Python 3.10 eller en senare version för att kunna använda siffror.

Från och med Python 3.10 kan du använda matchsatsen för att implementera en switch-case-liknande konstruktion. Matchningssatsen med sin enkla syntax ger 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 skiftläge:

  • Vi använder matchningsförklaringen för att jämföra användarens input med olika fall.
  • Varje fall specificerar ett val och koden 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  # Default behavior, return the string as is

print(f"Your random word is {word} and the result is {result}.")

Du kan nu köra skriptet och verifiera utdata:

Welcome! You have a randomly selected word.

Choose an option to manipulate the word:
1. Lowercase
2. Uppercase
3. Titlecase
4. Swapcase
5. Default behavior

Enter your option: 2
Your random word is world and the result is WORLD.

⚙ Även om matchförklaringen är ett bekvämt sätt att implementera en switch-case-konstruktion, är den avsedd för mer användbar strukturell mönstermatchning uppgifter utöver att emulera växelfallsbeteende.

Avslutar

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

  • If-elif-else-stegen är lätt att implementera men är jobbigt att underhålla. Så använd dem minimalt – bara när du inte har för många alternativ att leta efter.
  • Du kan använda Python-ordböcker och funktioner för att efterlikna växelfallsbeteende. Inkludera de olika valen och motsvarande funktioner som nycklar och värden för 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 denna handledning på GitHub. Om du förbereder dig för kodningsintervjuer, kolla in den här sammanställningen av de bästa Python-intervjufrågorna.