[Explained] Hvordan implementere Switch-Case i Python

Vil du implementere en switch-case-konstruksjon i Python? Lær de forskjellige tilnærmingene du kan bruke for å etterligne atferd med byttetilfeller.

Hvis du har programmert i C eller JavaScript, har du brukt switch-case-setningen. Men hvorfor trenger vi en bryterhuskonstruksjon?

Anta at du har et sett med forskjellige handlinger (eller kodeblokker). Og hvilken handling du utfører (kodeblokken som skal utføres) avhenger av verdien til en variabel eller et uttrykk.

Noen eksempler inkluderer:

• Tildele karakterer til elevene basert på deres poengsum
• Velge strengmanipulasjonsteknikker basert på brukerens valg
• Utføre aritmetiske operasjoner på to tall avhengig av brukerinndata

Så switch-case-konstruksjonen gir en praktisk måte å implementere slik logikk. Når du trenger å utføre – basert på variabelen eller uttrykkets verdi – en av de mange mulige handlingene.

Selv om Python ikke har en innebygd switch-case-konstruksjon, er det flere tilnærminger du kan bruke for å oppnå lignende funksjonalitet. I denne artikkelen skal vi utforske disse tilnærmingene.

Emulering av brytertilfelle-atferd i Python

La oss se hvordan vi kan etterligne switch-case-atferd i Python ved å ta et eksempel.

Vi skal skrive et enkelt program som gjør følgende:

• Prøv et ord, en Python-streng, tilfeldig fra en liste med ord.
• Gi kontekst og spør brukeren. Definer strengoperasjonene – strengmanipulering – som skal utføres på det valgte ordet.
• Gjør rede for operasjoner for endring av store og små bokstaver (små bokstaver, store bokstaver, store bokstaver og mer), inkludert en standard oppførsel. Bruk innebygde Python-strengmetoder etter behov.
• Spør brukeren om innspill. Fordi inngangen som standard er en streng, konverter den til en int etter type casting.

Python-strenger er uforanderlige. Så strengmetodene endrer ikke den opprinnelige strengen. De returnerer heller en kopi av strengen med de nødvendige endringene. La oss se på Python-strengmetodene vi skal bruke:

String MethodDescriptionlower()Returnerer en kopi av strengen der alle tegn er med små bokstaver()Returnerer en kopi av strengen der alle tegn er i store bokstaver()Returnerer en kopi av strengen formatert i tittel casewapcase()Returnerer en kopi av strengen der små og store bokstaver konverteres til henholdsvis store og små bokstaver

Følgende kodebit prøver tilfeldig et ord fra word_list og henter brukerinndata:

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

Her er et eksempel som viser hvordan strengen «Python» endres basert på brukerens valg:

Når du nå kjører programmet, bør du bli bedt om inndata slik:

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: 

La oss deretter fortsette å implementere de forskjellige tilnærmingene.

Bruke If-Elif-Else Ladder

I denne tilnærmingen bruker vi en serie if-elif-else-setninger for å sjekke brukerens valg mot forhåndsdefinerte alternativer. Vi utfører deretter en tilsvarende kodeblokk basert på brukerens input.

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

Her:

• Vi sammenligner brukerens innspill til hvert alternativ ved å bruke if-elif-setninger.
• Når et samsvar er funnet, utfører vi den tilsvarende kodeblokken.
• Hvis ingen av if-elif-betingelsene samsvarer, kjører vi else-blokken for standardoppførsel.

Du kan kjøre skriptet nå, angi valget og bekrefte utdataene:

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-stigen er enkel å implementere. Men det kan være en utfordring å opprettholde. I dette eksemplet hadde vi fem tilfeller (inkludert standardoppførselen). I praksis kan vi imidlertid ha mange flere saker. Slike lange if-elif-else stiger er en kodelukt du bør unngå.

Så la oss gå videre til en implementering som kan vedlikeholdes.

Bruke ordbokkartlegging og førsteklasses funksjoner

Du kan bruke Python-ordbøker og -funksjoner for å etterligne oppførsel i svitsj-tilfeller.

📑 Python-funksjoner er førsteklasses borgere

I Python er funksjoner førsteklasses borgere. Du kan gjøre mye mer enn bare å definere og kalle opp funksjoner:

• Når du har definert en funksjon, kan du tilordne den til en annen variabel, bruke funksjoner som elementer i lister, verdier i en ordbok og mye mer.
• Du kan også sende dem rundt: funksjoner kan sendes inn som argumenter til andre funksjoner og funksjoner kan returnere funksjoner.

I denne tilnærmingen vil vi bruke en ordbok for å kartlegge brukervalg til tilsvarende funksjoner eller handlinger. Dette er en mer effektiv måte å håndtere flere valg på, siden det unngår en lang kjede av if-elif-setninger.

Først, la oss definere følgende funksjoner for de forskjellige strengoperasjonene:

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

La oss deretter gjøre følgende:

• Lag en ordbok kalt valg der tastene er brukervalg, og verdier er funksjoner eller handlinger som skal utføres.
• Bruk ordbokmetoden get() for å hente den valgte handlingen basert på brukerens valg. Hvis valget ikke finnes i ordboken, gir vi en standardhandling spesifisert av en lambda-funksjon.
• Utfør deretter den valgte handlingen på det tilfeldige 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}")

Her er et eksempelutgang:

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.

Bruker Match-Case

📝 Merk: Du trenger Python 3.10 eller en nyere versjon for å bruke setninger som samsvarer med store og små bokstaver.

Fra Python 3.10 kan du bruke match-setningen til å implementere en switch-case-lignende konstruksjon. Match-setningen med sin enkle syntaks gir en mer intuitiv måte å håndtere flere saker på. _ (understrek) fungerer som standard tilfelle.

Slik kan vi omskrive eksemplet vårt ved å bruke match-case:

• Vi bruker samsvarserklæringen til å sammenligne brukerens innspill mot ulike saker.
• Hver sak spesifiserer et valg og koden som skal utføres hvis det valget samsvarer.
• _ (understrek) fungerer som et standard tilfelle, og kjører kode når ingen av de andre tilfellene samsvarer.

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 nå kjøre skriptet og bekrefte utdataene:

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.

⚙ Selv om samsvarserklæringen gir en praktisk måte å implementere en svitsjehuskonstruksjon, er den ment for mer nyttig strukturell mønstertilpasning oppgaver utover å emulere switch-case-atferd.

Innpakning

La oss oppsummere de forskjellige tilnærmingene for å oppnå switch-case-funksjonalitet i Python:

• If-elif-else-stigen er enkel å implementere, men det er vanskelig å vedlikeholde. Så bruk dem minimalt – bare når du ikke har for mange alternativer å se etter.
• Du kan bruke Python-ordbøker og -funksjoner for å etterligne oppførsel i svitsj-tilfeller. Ta med de forskjellige valgene og de tilsvarende funksjonene som henholdsvis nøkler og verdier til ordboken.
• Match-case-setningen, introdusert i Python 3.10, hjelper med å implementere denne switch-case-konstruksjonen med en enkel og intuitiv syntaks. Match-case-uttalelsen er imidlertid et godt valg for mer interessante brukstilfeller med strukturelt mønster.

Du kan finne kodeeksemplene for denne opplæringen på GitHub. Hvis du forbereder deg på kodeintervjuer, sjekk ut denne samlingen av de beste Python-intervjuspørsmålene.