Kā lietot slēdzi Python valodā: galīgs ceļvedis ar piemēriem un alternatīvām

Informatec Digital » Programmēšana » Kā lietot slēdzi Python valodā: Pilnīgs ceļvedis ar piemēriem un alternatīvām

Vai esat kādreiz domājuši, kā vienkārši un efektīvi pārvaldīt vairākus nosacījumus Python valodā? Strādājot ar tādām valodām kā C, Java vai JavaScript, jūs, iespējams, esat izmantojuši pazīstamo burtu maiņas operatoru , lai izvēlētos starp vairākām iespējām, pamatojoties uz mainīgā vērtību. Tomēr Python valodā šis klasiskais mehānisms nepastāvēja… līdz nesenam laikam. Lai gan izstrādātājiem gadiem ilgi bija jāmeklē alternatīvas, tagad valoda piedāvā modernu un jaudīgu risinājumu.

Šis raksts ir jūsu galvenais ceļvedis, lai izprastu, kā lietot Python ekvivalentu funkcijai `switch` , atklātu spēcīgākas alternatīvas vecākās versijās, noskaidrotu, kāpēc tā netika iekļauta agrīnajos posmos, un iemācītos rakstīt tīrāku, lasāmāku kodu neatkarīgi no izmantotās versijas. Gatavojieties apgūt visus trikus, piemērus un galvenās atšķirības vairāku nosacījumu ieviešanā Python ekosistēmā.

Vai slēdzis pastāv Python valodā? Vēsture un tā neesamības iemesli

Daudzās valodās sastopamā pārslēgšanas sintakse Python valodā oficiāli parādījās tikai 3.10 versijā. Galvenais iemesls ir filozofisks: Python veidotāji vienmēr ir prioritāri izvirzījuši vienkāršību un lasāmību. Viņi uzskatīja, ka jaunas sintakses ieviešana pārslēgšanas paziņojumiem varētu sarežģīt lietas, tāpēc if-elif-else bija pietiekams, lai aizpildītu šo robu. Turklāt nekad nebija vienprātības par ideālo sintaksi. Faktiski vairāki oficiāli priekšlikumi (PEP 275, PEP 3103) tika noraidīti vienprātības trūkuma un tāpēc, ka daudzi uzskatīja, ka esošās alternatīvas ir pietiekami skaidras un spēcīgas.

Gadiem ilgi kopiena ir kompensējusi “pārslēgšanas” paziņojuma trūkumu, izmantojot nosacījumu ķēdes un vārdnīcas. Lieki piebilst, ka tas izraisīja diskusijas, taču šīs pieejas nebūt nav nepārvarams trūkums, bet gan ir izrādījušās elastīgas un ļoti pielāgojamas. Tomēr, projektiem kļūstot sarežģītākiem, arvien acīmredzamāka kļuva nepieciešamība pēc elegantāka risinājuma.

Kas ir slēdža korpuss un kam tas tiek izmantots?

Pārslēgšanas -reģistra priekšraksts ir vadības struktūra, ko izmanto daudzās valodās, lai izpildītu dažādus koda blokus atkarībā no mainīgā vai izteiksmes vērtības. Citiem vārdiem sakot, tas ļauj tīrā un tiešā veidā izvēlēties vienu opciju no daudzām iespējām, izvairoties no bezgalīgām nosacījumu priekšrakstu ķēdēm.

Tipiski lietošanas piemēri būtu: nedēļas dienas nosaukuma attēlošana, pamatojoties uz skaitli, atzīmju piešķiršana, darbību izvēle, pamatojoties uz lietotāja ievadi utt. Valodās, piemēram, C vai Java, tās sintakse ir vienkārša:

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

Python valodā šī klasiskā struktūra nepastāvēja līdz nesenam laikam, tāpēc izstrādātājiem ir bijis jābūt izgudrojošiem, lai sasniegtu tādu pašu rezultātu.

Slēdža parādīšanās Python valodā: match-case paziņojums (kopš Python 3.10)

Izlaižot 3.10 versiju, Python iekļāva ilgi gaidītu funkciju: match-case paziņojumu. Lai gan tā sintakse atgādina tradicionālo switch-case paziņojumu, tā patiesībā ir daudz jaudīgāka, jo ievieš modeļu saskaņošanu , kas ļauj salīdzināt ne tikai vienkāršas vērtības, bet arī sarežģītas struktūras, kortežus, klases, sarakstus, vārdnīcas utt.

Python match-case tiek rakstīts šādi:

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

Pasvītrojums ( _ ) darbojas kā aizstājējzīme un ir noklusējuma vērtības ekvivalents citās valodās, kas tiek izpildīta, ja nav neviena iepriekšēja atbilstības parauga.

Kāpēc tas ir tik spēcīgs? Tāpēc, ka jūs varat saņemt sarežģītus modeļus, tvert mainīgos, atvērt kortežus vai objektus un pat izmantot aizsargus, lai pievienotu papildu nosacījumus pēc case paziņojuma:

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

Turklāt Python 3.10 un jaunākās versijās šī struktūra uzlabo koda lasāmību, uzturēšanas iespējas un mērogojamību, īpaši, apstrādājot daudzus gadījumus.

Alternatīvas pārslēgšanai Python vecākām versijām

Pirms match-case parādīšanās izstrādātāji izstrādāja vienlīdz derīgas alternatīvas. Divas visizplatītākās bija if-elif-else virkņu izmantošana un vārdnīcas kartēšana . Apskatīsim tās sīkāk:

1. Izmantojot if-elif-else

Vistiešākais un vienkāršākais risinājums ir ķēdēt nosacījumus, izmantojot if, elif un else. Tas ļauj aptvert visas iespējamās mainīgā vērtības un izpildīt atbilstošo koda bloku. Piemēram, lai parādītu nedēļas dienu, pamatojoties uz skaitli:

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

Šīs pieejas priekšrocības:

• Vienkāršs un viegli lasāms kods.
• Jums nav nepieciešamas nekādas citas īpašas struktūras; tas ir tīrs Python.
• Var izmantot jebkura veida salīdzinājumu, ne tikai vienādību.

"if-elif-else" kāpņu trūkumi:

• Tendence uz atkārtotu kodu. Katrā salīdzinājumā mainīgais ir jāatkārto, kas ģenerē daudz nevajadzīga teksta, ja ir daudz gadījumu.
• Mazāk efektīva, ja ir daudz nosacījumu. Ja lieta ir nonākusi līdz beigām, pirms nonākšanas pie tās tiek izvērtētas visas iepriekšējās lietas.
• Grūtības dinamiski pievienot vai noņemt pieteikumus.

2. Vārdnīcu izmantošana, lai simulētu burtu reģistru maiņu

Ļoti pythonisks veids, kā simulēt slēdža paziņojumu, ir vārdnīcu izmantošana. Ideja ir vienkārša: katru iespējamo vērtību (atslēgu) saistāt ar atbilstošo funkciju vai darbību (vērtību). Pēc tam vaicājat vārdnīcai, lai iegūtu funkciju un to izpildītu.

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

Šīs metodes priekšrocības:

• Kompakts un viegli paplašināms kods.
• Ļoti ātra piekļuve vajadzīgajai funkcijai. Vārdnīca izmanto jaukšanu, tāpēc meklēšana notiek gandrīz acumirklī.
• Ļauj piešķirt vienu un to pašu funkciju vairākām atslēgām (piemēram, grupēt lietas).
• Slēdzi var modificēt izpildes laikā.

Trūkumi:

• Tas prasa iepriekš definēt visas saistītās funkcijas, kas vienkāršām darbībām var būt apgrūtinoši.
• Tas atļauj salīdzinājumus tikai vienlīdzības nolūkos (tas nedarbojas intervāliem, diapazoniem utt.).
• Tas nav paredzēts gadījumiem ar sarežģītāku nosacīto loģiku katrā atlasē.

Atšķirība starp if-elif-else un switch (vai match-case)

If-elif-else ķēdes iekšējā darbība atšķiras no switch priekšraksta darbības. If-elif-else priekšrakstā nosacījumi tiek novērtēti pa vienam, no augšas uz leju, līdz tiek izpildīts pirmais patiesais nosacījums. Tādēļ, ja vēlamā vērtība ir sākumā, process ir ātrs; ja tā ir beigās, tas aizņem ilgāku laiku.

Turpretī tradicionālie pārslēgšanas paziņojumi (un vārdnīcas kā alternatīva Python valodā) parasti izmanto uzmeklēšanas tabulas, kā rezultātā piekļuve ir vienmērīgāka neatkarīgi no reģistru skaita vai to pozīcijas. Ar atbilstības reģistru paziņojumiem un vārdnīcām piekļuves laiki ir daudz konsekventāki.

Kad izvēlēties katru alternatīvu?

Nav viena universāla risinājuma; labākais rīks ir atkarīgs no konkrētās problēmas.

• Nelielam skaitam nosacījumu vai sarežģītai loģikai katrā atzarā visvienkāršākā izvēle ir if-elif-else. Tas ļauj veikt jebkādu salīdzināšanu un ir ļoti elastīgs.
• Ja jums ir daudz gadījumu un katrs no tiem vienkārši veic noteiktu darbību, paļaujieties uz vārdnīcām. Kods ir tīrāks, mērogojamāks un vieglāk uzturējams.
• Ja izmantojat Python 3.10 vai jaunāku versiju, sērkociņu futrālis Tā ir labākā izvēle skaidrībai un jaudai. Tas ļauj apvienot slēdža eleganci ar rakstu saskaņošanas jaudu sarežģītās konstrukcijās.

Vienmēr domājiet par sava koda lasāmību, veiktspēju un uzturēšanas iespējām.

Praktiski piemēri, kā izmantot slēdzi Python valodā un tā alternatīvas

Apskatīsim vairākus piemērus, kuros tiek piemērota katra no šīm alternatīvām, sākot no mazākās līdz lielākajai sarežģītībai:

1. piemērs: atzīmes aprēķināšana, pamatojoties uz rezultātu

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

Šis gadījums ir ideāli piemērots nosacījumu lietošanai, jo jūs strādājat ar intervāliem, nevis fiksētām vērtībām.

2. piemērs: nedēļas dienas attēlošana pēc skaitļa (ar vārdnīcu)

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

3. piemērs: aritmētiskās darbības izvēle, izmantojot burtu reģistru (match-case)

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

Kā redzat, sintakse ir vienkārša un ļoti skaidra. Pasvītrojums norāda noklusējuma burtu reģistru.

Paplašināts piemērs: modeļu saskaņošana ar match-case

Atbilstības gadījuma analīzes lielākā priekšrocība ir tās spēja strādāt ar sarežģītiem modeļiem. Piemēram, var analizēt kortežus, sarakstus, vārdnīcas, objektus utt.

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

Varat pat izmantot if (aizsarga) klauzulu, lai katram gadījumam pievienotu papildu nosacījumus.

Veiktspējas atšķirības starp if-elif-else, vārdnīcām un match-case

Vairumā gadījumu veiktspējas atšķirība tipiskiem skriptiem ir niecīga. Tomēr, ja ir liels skaits alternatīvu, vārdnīcas un atbilstības reģistru argumenti var būt efektīvāki, jo tie samazina salīdzinājumu skaitu. Jebkurā gadījumā vissvarīgākais faktors parasti ir koda lasāmība un uzturēšanas iespējas , nevis mikrooptimizācijas, kas reti rada izmaiņas reālās pasaules projektos.

Izmantojiet tehniku, kas padara kodu skaidrāku un novērš kļūdas.

Radoši risinājumi: klases un konteksta pārvaldnieki, lai atdarinātu slēdzi

Daži izstrādātāji ir izveidojuši specializētas klases, kas ļauj atdarināt slēdža klasisko darbību, tostarp tādas uzlabotas opcijas kā pārtraukuma pievienošana , lai kontrolētu nākamo gadījumu izpildi, gadījumu grupēšana, salīdzinājumu pielāgošana vai stingra režīma aktivizēšana, kas nodrošina, ka tiek izpildīta tikai viena atzara.

Piemēram, pielāgotu konteksta pārvaldnieku var ieviest, lai izmantotu sintaksi, kas ir ļoti līdzīga citām valodām:

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

Šīs klases izmantošana ļauj izveidot šādu sintaksi:

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

Kādas ir šī risinājuma priekšrocības? Tam ir ļoti pazīstama sintakse arī citu valodu lietotājiem, un tas ļauj veikt papildu pielāgojumus, piemēram, izmantot jebkuru salīdzināšanas funkciju, grupēt gadījumus, izpildīt vairākas atzaras vai tikai vienu utt. Trūkums ir tāds, ka tas parasti ir lēnāks un prasa importēt vai definēt speciālo klasi.

Lambda funkciju izmantošana, lai vienkāršotu darbības vārdnīcās

Bieži vien nav nepieciešams definēt atsevišķas funkcijas katrai darbībai; var izmantot anonīmas (lambda) funkcijas. Tas ir īpaši praktiski, ja veicamā darbība ir vienkārša:

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)

Tas padara kodu kompaktu un viegli paplašināmu, nezaudējot skaidrību.

Papildu lietošanas gadījumi: modeļu saskaņošana, izmantojot reģistru un burtu saskaņošanu

Python 3.10 `match-case` priekšraksts sniedzas daudz tālāk par klasiskā `switch-case` priekšraksta vienkāršu kopēšanu. Tā patiesā jauda slēpjas strukturālo modeļu saskaņošanā . Piemēram, tas ļauj viegli atšķirt dažādas datu struktūras, pielāgotas klases, sadalīt objektus un tvert apakšelementus.

Piemērs ar sarakstiem un kortežiem:

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

Piemērs ar objektiem (pieņemot, ka tā ir Point klase):

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

Šis mehānisms ļauj rakstīt ļoti izteiksmīgu kodu, kas pielāgojas sarežģītām struktūrām, nezaudējot lasāmību.

Aspekti, kas jāņem vērā, migrējot kodu: saderība un labākā prakse

Ne visi projekti var atļauties nekavējoties izmantot reģistru saskaņošanu. Ja strādājat vidē ar vecākām Python versijām (piemēram, 3.8 vai 3.9), jums būs jāizvēlas vārdnīcas. Ja ir iespējams jaunināt uz 3.10+ versiju, izmantojiet modeļu saskaņošanas iespējas un skaidrību, īpaši projektos, kuros būtiska ir vairāku atlases loģika.

Atcerieties:

• Izvēlieties opciju, kas piedāvā vislabāko lasāmību, elastību un ērtu apkopi.
• Ļoti vienkāršās problēmās (dažos gadījumos) parasti pietiek ar if-elif-else un tas ir tiešāks risinājums.
• Lielām atlases tabulām izmantojiet vārdnīcas un funkcijas.
• Sarežģītām struktūrām vai lai pilnībā izmantotu mūsdienu Python priekšrocības, izvēlieties match-case.

Neliels triks: jūs varat konvertēt esošās funkcijas, lai tās akceptētu darbību vārdnīcas, tādējādi vēl vairāk atvieglojot pāreju starp pieejām.

Optimizācijas un dizaina padomi tīrākam Python kodam

Neiekrītiet slazdā, veidojot bezgalīgas nosacījumu ķēdes, lai tikai atdarinātu klasisko switch priekšrakstu. Padomājiet par katru konkrēto gadījumu un novērtējiet, kura vadības struktūra sniedz vislielāko vērtību jūsu programmas kontekstam. Atcerieties, ka Python augstu vērtē skaidrību, tāpēc izvairieties no koda pārspīlēšanas, ja to pašu rezultātu varat sasniegt vienkārši.

Svarīgs padoms: Izmantojot vārdnīcas, izmantojiet funkciju get() lai izvairītos no kļūdām, ja atslēga neeksistē, un tādējādi varētu eleganti definēt noklusējuma gadījumu.

Salīdzinājums ar citām valodām un noslēguma domas

Dažās valodās, piemēram, C, C++ vai Java, slēdži ļauj salīdzināt tikai vienkāršas vērtības (veselos skaitļus, virknes) un sniedz mazu vērtību sarežģītām struktūrām. Python iet soli tālāk: pirmkārt, tas piedāvā daudzpusīgas alternatīvas (if-elif-else, vārdnīcas), un tagad tas paver durvis uz progresīvu loģiku bez papildu piepūles. Galvenais ir izmantot katras versijas priekšrocības un nepiespiest sevi atdarināt citas sintakses, ja problēmai nepieciešams atšķirīgs risinājums.

Ja jūs tikai sākat strādāt ar Python vai esat iepazinies ar citām valodām, neuztraucieties, ja rokasgrāmatā nevarat atrast atslēgvārdu “switch”. Apsveriet visas pieejamās iespējas un izvēlieties to, kas vislabāk atbilst jūsu kontekstam un vajadzībām.

Vairāku alternatīvu pārvaldība programmā Python nekad nav bijusi vienkāršāka vai efektīvāka. Tagad jūs saprotat iemeslus, kāpēc slēdzis nav (un pēc tam parādās), kā to efektīvi simulēt jebkurā versijā un kā maksimāli izmantot jauno match-case paziņojumu. Neatkarīgi no tā, vai jums ir jāizvēlas starp sešām iespējām, jāmanipulē ar sarežģītām struktūrām, jāievēro labākā prakse vai jāuztraucas par veiktspēju, jums ir pieejamas stabilas, elegantas un elastīgas alternatīvas. Neatkarīgi no tā, vai jūsu kods ir paredzēts ātriem skriptiem vai sarežģītām lietojumprogrammām, Python sniedz jums rīkus, lai to uzrakstītu skaidri, ātri un vienkārši.