Branching sa Python: if-elif-else, dict, match-case

1 1. Panimula
2 2. Ang dahilan kung bakit walang switch statement sa Python
3 3. Halimbawa ng paggamit ng if-elif-else
- 3.1 Mga problema kapag nadagdagan ang mga kondisyon
4 4. Paggamit ng uri ng diksyunaryo (dictionary) sa conditional branching
- 4.1 Mga Benepisyo ng Diksyunaryo
5 5. Ang bagong tampok ng Python 3.10: Pagpapakilala ng match‑case statement
- 5.1 Pangunahing sintaks ng match‑case
6 6. Mga Halimbawa ng Paggamit ng match-case
- 6.1 match-case na pahayag na sumasaklaw sa maraming
7 7. Paghahambing ng if-elif-else, uri ng diksyunaryo, at match-case
8 8. Buod

1. Panimula

Ang Python ay minamahal ng maraming programmer dahil sa kanyang kasimplihan at intuitibong syntax, ngunit maaaring magulat ang ilan dahil wala itong “switch-case” na syntax na makikita sa ibang wika. Dahil dito, kailangan gamitin sa Python ang “if-elif-else” o ang “dictionary” upang maisakatuparan ang katulad na pagproseso. Sa artikulong ito, tatalakayin natin ang tradisyonal na mga paraan ng conditional branching sa Python, ang alternatibong paggamit ng dictionary, at ang bagong “match-case” statement na ipinakilala sa Python 3.10. Sa pamamagitan nito, mapapalalim mo ang iyong pag-unawa sa epektibong paraan ng conditional branching sa Python at magagamit ito sa aktwal na pag-coding.

2. Ang dahilan kung bakit walang switch statement sa Python

Ang dahilan kung bakit hindi isinasama ang switch-case statement sa Python ay ang pagiging simple at nababasa nito. Ang mga tagalikha ng Python ay naghangad na gawing simple hangga’t maaari ang wika, at alisin ang mga pag-uulit at labis na syntax. Bagaman kapaki-pakinabang ang switch statement sa ibang wika, sa Python ay maaaring makamit ang parehong functionality gamit ang “if-elif-else” statement o dictionary, kaya hindi na kailangan magdagdag ng switch statement. Sa katunayan, sinasabi rin sa opisyal na dokumentasyon ng Python na maaaring takpan ang functionality ng switch statement sa pamamagitan ng paggamit ng if-elif-else statement. Ang sumusunod na code ay halimbawa ng switch statement sa C language at iba pa.

switch (value) {
  case 1:
    printf("Value is 1");
    break;
  case 2:
    printf("Value is 2");
    break;
  default:
    printf("Other value");
}

Sa Python, maaaring isulat ito nang ganito.

value = 1
if value == 1:
    print("Value is 1")
elif value == 2:
    print("Value is 2")
else:
    print("Other value")

Sa pamamaraang ito, madaling makakagawa ng conditional branching ang Python kahit walang switch statement.

3. Halimbawa ng paggamit ng if-elif-else

Ang pinaka-pangunahing paraan ng paggawa ng conditional branching sa Python ay ang “if-elif-else” statement. Ito ay napaka-epektibo kapag nagpapatupad ng iba’t ibang proseso batay sa maraming kondisyon. Narito ang isang tipikal na halimbawa ng paggamit nito.

value = 100
if value < 50:
    print("Maliit na halaga")
elif value < 100:
    print("Katamtamang halaga")
else:
    print("Malaking halaga")

Sa code na ito, ang iba’t ibang mensahe ay inilalabas batay sa halaga ng variable value. Ang if-elif-else statement ay nagbibigay-daan sa isang simple at intuitive na conditional branching.

Mga problema kapag nadagdagan ang mga kondisyon

Gayunpaman, kapag ang hierarchy ng if-elif-else statement ay nagiging mas malalim, maaaring maging mahirap basahin ang code. Lalo na kapag humahawak ng komplikadong mga kondisyon, ang pamamaraan na gumagamit ng “dictionary type” na ipapakilala sa susunod ay epektibo.

4. Paggamit ng uri ng diksyunaryo (dictionary) sa conditional branching

Sa pamamagitan ng paggamit ng uri ng diksyunaryo ng Python, maaaring magpatupad ng conditional branching na katulad ng switch-case statement. Ang diksyunaryo ay isang istruktura ng datos na nag-iimbak ng mga pares ng susi at halaga, na nagpapahintulot na maipahayag nang maikli ang maraming conditional branches. Sa susunod na halimbawa, ipapakita ang kaukulang resulta batay sa numerong ipinasok ng gumagamit.

numbers = {1: "Isa", 2: "Dalawa", 3: "Tatlo"}
value = int(input("Pakilagay ang numero mula 1 hanggang 3: "))

if value in numbers:
    print(f"Napiling numero: {numbers[value]}")
else:
    print("Pakilagay ang numero mula 1 hanggang 3")

Sa ganitong paraan, sa pamamagitan ng paggamit ng diksyunaryo, kahit na maraming kondisyon, maikli at madaling basahin pa rin ang code.

Mga Benepisyo ng Diksyunaryo

Ang conditional branching gamit ang diksyunaryo ay may mataas na nababasa na code at madaling i-maintain kahit na dumami ang mga kondisyon. Lalo na kapag maraming operasyon ang kailangang gawin sa mga halaga, mas epektibo ito kaysa sa if-elif-else na pahayag.

5. Ang bagong tampok ng Python 3.10: Pagpapakilala ng match‑case statement

Ang “match‑case” na pahayag na ipinakilala mula sa Python 3.10 ay may sintaks na halos katulad ng switch‑case, at nagbibigay-daan upang ilahad ang maraming kondisyon nang maikli. Ang bagong tampok na ito ay lalo na malakas sa pattern matching, at kumpara sa tradisyunal na if‑elif‑else na pahayag o mga paraan gamit ang dictionary, malaki ang pagpapabuti nito sa nababasa at napapanatiling code.

Pangunahing sintaks ng match‑case

Narito ang isang pangunahing halimbawa ng paggamit ng match‑case statement.

def check_value(value):
    match value:
        case 1:
            print("Napili ang isa")
        case 2:
            print("Napili ang dalawa")
        case _:
            print("Napili ang iba maliban sa 1 o 2")

Sa code na ito, iba‑ibang proseso ang isinasagawa batay sa halaga ng variable value. Ang case _ ay nagsisilbing default na proseso, na isinasagawa kapag walang anumang kondisyon ang tumugma.

6. Mga Halimbawa ng Paggamit ng match-case

Ang match-case na pahayag ay angkop din para sa mas kumplikadong pag-branch ng kondisyon at pattern matching. Halimbawa, maaari itong magsagawa ng pagproseso batay sa bilang ng mga elemento ng listahan o uri ng data.

match-case na pahayag na sumasaklaw sa maraming

def process_data(data):
    match data:
        case [x, y]:
            print(f"Ang listahan ay may 2 elemento: {x}, {y}")
        case [x, y, z]:
            print(f"Ang listahan ay may 3 elemento: {x}, {y}, {z}")
        case _:
            print("Ang bilang ng mga elemento ng listahan ay iba.")

Sa halimbawang ito, isinasagawa ang iba’t ibang pagproseso batay sa bilang ng mga elemento ng listahan. Ang match-case na pahayag ay may katangiang ito: maaaring ilarawan nang simple ang maraming kondisyon at pattern.

7. Paghahambing ng if-elif-else, uri ng diksyunaryo, at match-case

Ang bawat pamamaraan ng pag-branch ng kondisyon ay may kani-kaniyang mga kalamangan at kahinaan. Ipinapakita sa ibaba ang kanilang paghahambing na talahanayan.

Pamamaraan	Kalamangan	Kahinaan
if-elif-else	Simple at madaling intindihin	Kapag maraming kondisyon, nagiging kumplikado ang code
Uri ng diksyunaryo (dictionary)	Mataas ang nababasa, epektibo kapag maraming kondisyon	Hindi lahat ng kondisyon ay maaaring ilagay sa diksyunaryo
match-case	Epektibo para sa maraming pag-branch ng kondisyon at pattern matching	Magagamit lamang mula Python 3.10 pataas

Sa pamamagitan ng talahanayang ito, mas madali mong mapili kung aling pamamaraan ng pag-branch ang pinakaangkop. Lalo na ang match-case ay napakabisa para sa komplikadong pattern matching, at nakakatulong ito upang maiwasan ang kalabisan ng if-elif-else.

8. Buod

Bagaman walang switch-case statement sa Python, posible pa rin ang epektibong conditional branching gamit ang if-elif-else statement, dictionary, at ang match-case statement ng Python 3.10. Lalo na ang match-case ay malakas sa pattern matching, at nagpapahintulot na isulat nang simple ang kumplikadong mga kondisyon, kaya magiging kapaki-pakinabang ito sa mga susunod na development. Sa pamamagitan ng paggamit ng mga pamamaraang ito ayon sa pangangailangan, makakalikha ka ng code na epektibo at madaling basahin. Sa ganitong paraan, sa pamamagitan ng mas malalim na pag-unawa sa bawat pamamaraan, magagawa mong pumili ng pinakamainam na lapit ayon sa aktwal na proyekto.