Kaip naudoti jungiklį Python kalboje: išsamus vadovas su pavyzdžiais ir alternatyvomis

Informatec Digital » programavimas » Kaip naudoti jungiklį Python kalboje: išsamus vadovas su pavyzdžiais ir alternatyvomis

Ar kada susimąstėte, kaip lengvai ir efektyviai apdoroti kelias sąlygas Python kalboje? Kai dirbote su tokiomis kalbomis kaip C, Java ar JavaScript, tikrai naudojote garsųjį jungiklis pasirinkti iš kelių variantų pagal kintamojo reikšmę. Tačiau „Python“ kalboje šis klasikinis mechanizmas neegzistavo... iki šiol. Žinoma, nors kūrėjams metų metus teko ieškoti alternatyvų, dabar kalba siūlo modernų ir galingą sprendimą.

Šis straipsnis yra jūsų pagrindinis vadovas, padėsiantis suprasti, kaip naudoti jungiklio atitikmenį Python kalboje., atraskite patikimiausias alternatyvas senesnėse versijose, paaiškinkite, kodėl tai nebuvo įtraukta ankstyvosiose stadijose, ir sužinokite, kaip rašyti aiškesnį, lengviau skaitomą kodą, nepriklausomai nuo naudojamos versijos. Pasiruoškite sužinoti visas gudrybes, pavyzdžius ir pagrindinius skirtumus, kaip įdiegti kelias sąlygines komandas Python ekosistemoje.

Ar „Python“ kalboje egzistuoja jungiklis? Jo nebuvimo istorija ir priežastys

„Switch-case“ (liet. „switch-case“) raidė, esanti daugelyje kalbų, oficialiai „Python“ programoje nepasirodė iki 3.10 versijos. Pagrindinė priežastis yra filosofinė: „Python“ kūrėjai visada siekė paprastumo ir skaitomumo. Jie manė, kad naujos jungiklio sintaksės įvedimas gali viską apsunkinti, todėl jei-elifas-kitas pakako užpildyti šią spragą. Be to, niekada nebuvo sutarimo dėl idealios sintaksės. Tiesą sakant, keli oficialūs pasiūlymai (PEP 275, PEP 3103) buvo atmesti dėl sutarimo stokos ir dėl to, kad daugelis manė, jog esamos alternatyvos yra pakankamai aiškios ir veiksmingos.

Jau daugelį metų bendruomenė kompensavo jungiklių nebuvimą naudodama sąlyginių sakinių grandines ir žodynus. Savaime suprantama, ši tema sukėlė diskusijas, tačiau šie metodai toli gražu nėra neįveikiamas trūkumas, o lankstūs ir lengvai pritaikomi. Tačiau projektams tampant sudėtingesniems, vis labiau iškilo poreikis elegantiškesniam sprendimui.

Kas yra jungiklio korpusas ir kam jis naudojamas?

El jungiklis Tai valdymo struktūra, naudojama daugelyje kalbų, skirta vykdyti skirtingus kodo blokus pagal kintamojo arba išraiškos reikšmę. Kitaip tariant, ji leidžia aiškiai ir paprastai pasirinkti vieną variantą iš daugelio galimų variantų, išvengiant begalinių sąlyginių sakinių grandinių.

Tipiniai naudojimo pavyzdžiai būtų: savaitės dienos pavadinimo rodymas pagal skaičių, pažymių priskyrimas, operacijų pasirinkimas pagal vartotojo įvestį ir kt. Tokiose kalbose kaip C ar Java, jos sintaksė yra paprasta:

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

Python kalboje ši klasikinė struktūra neegzistavo iki šiol, todėl kūrėjai turėjo būti išradingi, kad pasiektų tą patį rezultatą.

Jungiklio atsiradimas Python kalboje: match-case sakinys (nuo Python 3.10 versijos)

Išleidus 3.10 versiją, „Python“ įdiegė ilgai lauktą funkciją: rungtynių atvejo pareiškimas. Nors jos sintaksė primena tradicinį „switch case“ (liet. „switch case“), ji iš tikrųjų yra daug galingesnė, nes pristato šablonų atitikimas (modelių atitikimas), leidžiantis palyginti ne tik paprastas reikšmes, bet ir sudėtingas struktūras, rinkinius, klases, sąrašus, žodynus ir kt.

Python'o atitikmenų atvejis užrašomas taip:

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

Pabraukimo ženklas (_) veikia kaip pakaitos simbolis ir yra lygiavertis numatytasis Kitomis kalbomis vykdoma, kai nėra atitikmenų ankstesniame šablone.

Kodėl jis toks galingas? Nes galite gauti sudėtingus šablonus, fiksuoti kintamuosius, atidaryti rinkinius ar objektus ir netgi naudoti apsaugas, kad pridėtumėte papildomų sąlygų po atvejo:

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

Be to, „Python 3.10“ ir naujesnėse versijose ši struktūra pagerina kodo skaitomumą, priežiūrą ir mastelio keitimą, ypač tvarkant daug atvejų.

Alternatyvos perjungimui senesnėse Python versijose

Prieš atvykstant degtuko dėklaskūrėjai pateikia lygiavertes alternatyvas. Du dažniausiai pasitaikantys būdai yra „if-elif-else“ grandinių naudojimas ir atvaizdavimas naudojant žodynus.Pažvelkime atidžiau:

1. Naudojant if-elif-else

Tiesiausias ir lengviausiai suprantamas sprendimas yra susieti sąlygas naudojant if, elif ir else. Tokiu būdu galite aprėpti visas galimas kintamojo reikšmes ir vykdyti atitinkamą kodo bloką. Pavyzdžiui, norint parodyti savaitės dieną pagal skaičių:

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

Šio metodo privalumai:

• Paprastas ir lengvai skaitomas kodas.
• Jums nereikia jokių kitų specialių struktūrų; tai grynas Python.
• Galima naudoti bet kokį palyginimo būdą, ne tik lygybę.

„if-elif-else“ kopėčių trūkumai:

• Polinkis į pasikartojantį kodą. Kiekviename palyginime turite pakartoti kintamąjį, o tai sukuria daug nereikalingo teksto, jei turite daug atvejų.
• Mažiau efektyvu, kai yra daug sąlygų. Jei byla jau baigta, prieš atvykstant įvertinamos visos ankstesnės bylos.
• Sunku dinamiškai pridėti arba pašalinti atvejus.

2. Žodynų naudojimas imituojant didžiųjų ir mažųjų raidžių perjungimą

Labai pythoniškas būdas imituoti jungiklius yra naudoti žodynus. Idėja paprasta: kiekvieną galimą reikšmę (raktą) susiejate su atitinkama funkcija arba veiksmu (reikšme). Tada žodyne ieškote funkcijos ir ją vykdote:

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

Šio metodo privalumai:

• Kompaktiškas ir lengvai išplečiamas kodas.
• Labai greita prieiga prie reikiamos funkcijos. Žodynas naudoja maišą, todėl paieška vyksta beveik akimirksniu.
• Leidžia priskirti tą pačią funkciją keliems klavišams (pavyzdžiui, grupuoti atvejus).
• Jungiklį galima modifikuoti vykdymo metu.

Trūkumai:

• Tam reikia iš anksto apibrėžti visas susijusias funkcijas, o tai gali būti sudėtinga atliekant paprastus veiksmus.
• Tai leidžia palyginti tik siekiant lygybės (neveikia su intervalais, diapazonais ir pan.).
• Jis nėra skirtas atvejams, kai kiekviename pasirinkime yra sudėtingesnė sąlyginė logika.

Skirtumas tarp „if-elif-else“ ir „switch“ (arba „match-case“)

Vidinis „if-elif-else“ grandinės veikimas skiriasi nuo komutatoriaus veikimo. Funkcijoje „if-elif-else“ sąlygos vertinamos po vieną, nuo viršaus iki apačios, kol pirmoji sąlyga tampa teisinga. Todėl, jei ieškoma reikšmė yra pradžioje, paieška vykdoma greitai; jei pabaigoje, užtruks ilgiau.

Tradiciniai jungikliai (ir žodynas kaip alternatyva „Python“ kalboje) dažnai naudoja paieškos lenteles, todėl prieiga yra vienodesnė, nepriklausomai nuo egzempliorių skaičiaus ar jų padėties. degtuko dėklas ir žodynų, prieigos laikas yra daug vienodesnis.

Kada rinktis kiekvieną alternatyvą?

Nėra vieno universalaus sprendimo; geriausias įrankis priklauso nuo konkrečios problemos.

• Esant nedideliam sąlygų skaičiui arba sudėtingai logikai kiekvienoje šakoje, paprasčiausias pasirinkimas yra if-elif-else. Tai leidžia atlikti bet kokius palyginimus ir yra labai lanksti.
• Kai turite daug atvejų ir kiekvienas iš jų tiesiog atlieka konkretų veiksmą, pasikliaukite žodynais. Kodas yra švaresnis, keičiamo dydžio ir lengviau prižiūrimas.
• Jei naudojate „Python 3.10“ ar naujesnę versiją, degtuko dėklas Tai geriausias pasirinkimas norint aiškumo ir galios. Tai leidžia suderinti jungiklio eleganciją su sudėtingų konstrukcijų šablonų derinimo galia.

Visada pagalvokite apie savo kodo skaitomumą, našumą ir prižiūrimumą.

Praktiniai „switch“ naudojimo „Python“ kalboje ir jo alternatyvų pavyzdžiai

Pažvelkime į kelis pavyzdžius, kur taikoma kiekviena iš šių alternatyvų, nuo mažiausio iki didžiausio sudėtingumo:

1 pavyzdys: įvertinimo apskaičiavimas pagal balą

# 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 atvejis puikiai tinka sąlyginėms operacijoms naudoti, nes dirbate su intervalais, o ne su fiksuotomis reikšmėmis.

2 pavyzdys: Savaitės dienos rodymas skaičiumi (su žodynu)

# 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 pavyzdys: Aritmetinio veiksmo pasirinkimas naudojant didžiąsias ir mažąsias raides

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

Kaip matote, sintaksė paprasta ir labai aiški. Pabraukimas žymi numatytąją didžiųjų ir mažųjų raidžių rūšį.

Išplėstinis pavyzdys: šablonų atitikimas naudojant „match-case“

Didžiausias „Match-Case“ privalumas yra gebėjimas dirbti su sudėtingais raštais. Pavyzdžiui, galite analizuoti rinkinius, sąrašus, žodynus, objektus ir kt.

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

Jūs netgi galite naudoti išlygą if (sargybinis), kad kiekvienu atveju pridėtų papildomų sąlygų.

Našumo skirtumai tarp „if-elif-else“, žodynų ir „match-case“

Daugeliu atvejų įprastų scenarijų našumo skirtumas yra nereikšmingas. Tačiau, kai yra daug alternatyvų, žodynai ir atitikmenų taikymas gali būti efektyvesni, nes jie sumažina palyginimų skaičių. Tačiau svarbiausias veiksnys paprastai yra kodo skaitomumas ir priežiūra, o ne mikrooptimizavimus, kurie retai kada pakeičia realius projektus.

Naudokite techniką, kuri padaro kodą aiškesnį ir išvengia klaidų.

Kūrybiniai sprendimai: klasės ir konteksto tvarkyklės, skirtos imituoti perjungimą

Kai kurie kūrėjai sukūrė specializuotas klases, kurios leidžia mėgdžioti klasikinį jungiklio elgesį, įskaitant išplėstines parinktis, pvz., pridėjimą pertrauka norėdami valdyti vėlesnių atvejų vykdymą, grupuoti atvejus, pritaikyti palyginimus arba įjungti griežtą režimą, kad būtų vykdoma tik viena šaka.

Pavyzdžiui, galima įdiegti pasirinktinį konteksto tvarkytuvą, kad būtų naudojama labai panaši sintaksė kaip ir kitose kalbose:

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

Šios klasės naudojimas leidžia sukurti tokią sintaksę:

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

Šio sprendimo privalumai? Jis turi labai gerai žinomą sintaksę tiems, kurie kalba iš kitų kalbų, ir leidžia atlikti išplėstinius pritaikymus, pvz., naudoti bet kokią palyginimo funkciją, grupuoti atvejus, paleisti kelias šakas arba tik vieną ir pan. Trūkumas yra tas, kad jis paprastai yra lėtesnis ir reikalauja importuoti arba apibrėžti specialiąją klasę.

Lambda funkcijų naudojimas žodynų veiksmams supaprastinti

Dažnai nereikia kiekvienam veiksmui apibrėžti atskirų funkcijų; galite naudoti anonimines funkcijas (lambdas). Tai ypač praktiška, kai atliekamas paprastas veiksmas:

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)

Dėl to kodas yra kompaktiškas ir lengvai plečiamas neprarandant aiškumo.

Išplėstiniai naudojimo atvejai: šablonų atitikimas naudojant „Match-Case“

Sakinys degtuko dėklas „Python 3.10“ gerokai viršija klasikinio „switchcase“ kopijavimą. Tikroji jo galia slypi tame, kad struktūrinių modelių atitikimasPavyzdžiui, tai leidžia atskirti skirtingas duomenų struktūras, pasirinktines klases, skaidyti objektus ir lengvai užfiksuoti subelementus.

Pavyzdys su sąrašais ir rinkiniais:

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

Pavyzdys su objektais (darant prielaidą, kad tai yra „Point“ klasė):

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 mechanizmas leidžia rašyti labai išraiškingą kodą, kuris prisitaiko prie sudėtingų struktūrų neprarandant skaitomumo.

Aspektai, į kuriuos reikia atsižvelgti migruojant kodą: suderinamumas ir geriausia praktika

Ne visi projektai gali sau leisti iš karto naudoti „match-case“. Jei dirbate aplinkoje su senesnėmis „Python“ versijomis (pvz., 3.8 arba 3.9), turėsite rinktis žodynus. Kai galėsite atnaujinti į 3.10 ar naujesnę versiją, pasinaudokite šablonų atitikimo galia ir aiškumu, ypač projektuose, kuriuose būtina naudoti kelių pasirinkimų logiką.

Atminkite:

• Pasirinkite parinktį, kuri užtikrina geriausią įskaitomumą, lankstumą ir lengvą priežiūrą.
• Labai paprastose problemose (keliais atvejais) paprastai pakanka `if-elif-else` ir tai yra tiesesnis sprendimas.
• Didelėms pasirinkimo lentelėms naudokite žodynus ir funkcijas.
• Sudėtingoms struktūroms arba norint išnaudoti visas šiuolaikinio Python galimybes, rinkitės „match-case“ (skirtingą raidę)

Mažas triukas: galite konvertuoti esamas funkcijas, kad jos priimtų veiksmų žodynus, taip dar labiau palengvindami perėjimą nuo vieno metodo prie kito.

Optimizavimo ir dizaino patarimai, kaip sukurti švaresnį Python kodą

Nedarykite klaidos kurdami begalines sąlyginių sakinių grandines vien tam, kad imituotumėte klasikinį perjungimą. Apsvarstykite kiekvieną konkretų atvejį ir įvertinkite, kuri valdymo struktūra suteikia daugiausia vertės jūsų programos kontekstui. Atminkite, kad Python vertina aiškumą, todėl venkite per daug komplikuoti savo kodą, jei tą patį rezultatą galite pasiekti lengviau.

Svarbus patarimas: Naudodami žodynus, naudokite funkciją get() kad būtų išvengta klaidų, jei rakto nėra, ir tokiu būdu būtų galima elegantiškai apibrėžti numatytąjį atvejį.

Palyginimas su kitomis kalbomis ir baigiamosios mintys

Kai kuriose kalbose, tokiose kaip C, C++ ar Java, jungikliai leidžia palyginti tik paprastas reikšmes (sveikuosius skaičius, eilutes) ir suteikia mažai vertės sudėtingoms struktūroms. „Python“ žengia dar vieną žingsnį: pirma, jis siūlo lanksčias alternatyvas („if-elif-else“, žodynus), o dabar atveria duris į pažangią logiką be papildomų pastangų. Svarbiausia yra pasinaudoti kiekvienos versijos privalumais ir neversti savęs mėgdžioti kitų sintaksių, jei problemai reikia kitokio sprendimo.

Jei tik pradedate dirbti su Python arba esate susipažinę su kitomis programavimo kalbomis, nesijaudinkite, jei vadove nerandate raktinio žodžio „switch“. Pagalvokite apie visas įmanomas galimybes ir pasirinkite tą, kuri geriausiai atitinka jūsų kontekstą ir poreikius.

Kelių alternatyvų valdymas „Python“ kalboje dar niekada nebuvo toks paprastas ar efektyvus. Dabar jūs suprantate priežastis, kodėl nėra (ir vėlesnio atsiradimo) šio jungiklio, kaip jį efektyviai imituoti bet kurioje versijoje ir kaip maksimaliai išnaudoti naująją „match-case“ formuluotę. Nesvarbu, ar jums reikia rinktis iš šešių variantų, manipuliuoti sudėtingomis struktūromis, laikytis geriausios praktikos ar nerimauti dėl našumo, turite tvirtų, elegantiškų ir lanksčių alternatyvų. Nesvarbu, ar jūsų kodas skirtas greitiems scenarijams, ar sudėtingoms programoms, „Python“ suteikia jums įrankius, leidžiančius jį parašyti aiškiai, greitai ir lengvai.