Mga loop at kondisyon sa Python: for, while, range, enumerate, break, if/elif, at match/case

Ginagamit ang loop sa Python para ulitin ang isang aksyon: dumaan sa listahan ng mga pamimili, iproseso ang bawat linya ng file, o tanungin ang user hanggang maglagay siya ng tamang numero. May dalawang loop ang wika — for at while — at ang mga kondisyong if/elif/else at match/case ang tumutulong sa pagdedesisyon sa loob nila. Isa-isahin natin ang bawat kasangkapan gamit ang mga halimbawang magagamit mo.

Mga kondisyon: if, elif, else

Pinapatakbo ng conditional statement ang block ng code kung totoo ang ekspresyon. Minamarkahan ang block ng indentation na 4 na espasyo — walang curly brace sa Python, at ang maling indentation ay agad na nagdudulot ng IndentationError.

spent = 4200
limit = 5000

if spent > limit:
    print("Lumampas sa limitasyon")
elif spent > limit * 0.8:
    print("Mas mababa sa 20% ang natitirang badyet")
else:
    print("Maayos ang lahat")

Tinitingnan ang mga sangay na elif mula itaas pababa, at isa lang ang tumatakbo — ang unang tugma. Kaya ilagay sa itaas ang mas mahigpit na kondisyon: kung ang tseke na spent > limit * 0.8 ang nasa unahan, hindi na kailanman lilitaw ang mensahe ng paglampas sa limitasyon.

Ano ang itinuturing na totoo

Hindi kailangang magsulat ng paghahambing sa kondisyon. Mali (False) ang None, ang zero (0, 0.0), at ang walang lamang koleksiyon: "", [], {}. Totoo ang lahat ng iba. Kaya maikli ang tseke na "walang laman ang listahan":

expenses = []
if not expenses:
    print("Wala pang gastos")

Pinagsasama ang mga kondisyon gamit ang and, or, at not, at madaling i-check ang saklaw gamit ang chained comparison: if 0 < amount <= 100_000:. Para sa maikling pagpili ng halaga, may ternary operator: status = "marami" if spent > limit else "normal".

Loop na for sa Python: sintaks at mga halimbawa

Ang for loop sa Python ay hindi counter gaya ng sa C, kundi pagdaan sa mga elemento. Kinukuha nito ang bawat elemento ng iterable object — listahan, string, dictionary, file, o range — isa-isa. Ang katumbas nito sa foreach ng ibang wika ay ang karaniwang for na ito mismo.

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

Sintaks ng for loop: for variable in collection:, sinusundan ng block na may indentation. Nananatili ang variable pagkatapos ng loop na may huling halaga — minsan kapaki-pakinabang iyon, pero huwag itong asahan sa malalaking programa.

Loop sa string, listahan, at dictionary

Dinadaanan ang string kada karakter, at ang listahan kada elemento. Sa dictionary, ang default ay ang mga key; para makuha ang key at value nang sabay, gamitin ang .items():

by_category = {"pagkain": 3200, "transportasyon": 900, "sine": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} ₱")

Para sa mga value lang, may .values(). Hindi puwedeng baguhin ang laki ng dictionary habang dumadaan dito — makakakuha ka ng RuntimeError: dictionary changed size during iteration. Kung kailangang magtanggal ng mga elemento, dumaan sa kopya: for key in list(d):.

Function na range: loop sa mga numero

Kapag kailangan ang pagdaan sa mga numero, ang range() ang gamitin. Hindi ito gumagawa ng listahan sa memorya, kundi naglalabas ng mga numero isa-isa, kaya agad tumatakbo ang range(10**9).

Pangunahing tuntunin: hindi kasama sa range ang kanang hangganan. Ang range(1, 10) ay titigil sa 9 — isa itong madalas na sanhi ng "off-by-one" na error. Puwedeng negatibo ang hakbang, pero hindi puwedeng zero.

for i in range(1, 4):
    print(f"Araw {i}")
# Araw 1
# Araw 2
# Araw 3

enumerate: counter sa loop

Madalas isulat ng mga baguhan ang for i in range(len(items)) para malaman ang numero ng elemento. Gumagana ito, pero mahirap basahin. Ang enumerate() ay naglalabas ng pares na "numero, elemento", at ang parameter na start ang nagtatakda kung saan magsisimula ang bilang:

items = ["kape", "taksi", "tanghalian"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 kape
# 2 taksi
# 3 tanghalian

Para sabay na dumaan sa dalawang listahan, may zip(): for name, price in zip(names, prices):. Huminto ito sa pinakamaikling listahan; mula Python 3.10, puwede itong bigyan ng strict=True, at kapag magkaiba ang haba, magdudulot ito ng error.

Loop na while sa Python

Inuulit ng while ang block habang totoo ang kondisyon. Ginagamit ito kapag hindi alam nang maaga kung ilang ulit: naghihintay ng tamang input, nagbabasa ng datos hanggang dulo, o inuulit ang request hanggang magtagumpay.

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"Sapat ang pera sa loob ng {month} buwan")  # 4

Pangunahing panganib ang makalimutang baguhin ang variable sa kondisyon. Kapag nangyari iyon, hindi kailanman matatapos ang loop. Kung "nag-freeze" ang programa, pindutin ang Ctrl+C: hihinto ang Python sa KeyboardInterrupt.

Walang hanggang loop at ang do while

Minsan sinasadya ang walang hanggang loop sa Python: while True: na may labasan gamit ang break. Ganito rin ginagawa ang loop na may postcondition — walang do while sa Python, at ang pattern na ito ang pumapalit: tatakbo ang katawan kahit isang beses, at nasa dulo ang tseke.

while True:
    raw = input("Halaga: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Maglagay ng buong numero")

Bihira ang walang hanggang for loop — mangyayari lang ito kapag dumaraan ka sa walang hanggang iterator, gaya ng itertools.count().

break at continue: paglabas sa loop at paglaktaw sa isang ulit

Agad na ihihinto ng break ang loop, at magpapatuloy ang code sa labas nito. Lalaktawan naman ng continue ang natitira sa kasalukuyang ulit at lilipat sa susunod.

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # laktawan ang ulit na ito
    if amount > 50_000:
        print("Kahina-hinalang halaga, hinto")
        break             # lumabas sa loop
    print(amount)

Ang lalabas ay 350 at 1200, saka ang mensahe — hindi na aabot ang loop sa 89. Parehong nakaaapekto lang ang dalawang statement sa pinakamalapit na loop na kinabibilangan nila.

else sa loop

May kakaibang sangay na else ang for at while: tatakbo ito kapag natapos ang loop nang mag-isa, nang walang break. Kapaki-pakinabang ito sa paghahanap:

for amount in expenses:
    if amount > 50_000:
        print("May nakitang malaking gastos")
        break
else:
    print("Walang malalaking gastos")

Mga nested loop

Ang loop sa loob ng isa pang loop ay ganap na tatakbo ang panloob sa bawat ulit ng panlabas. Ginagamit ito sa pagdaan sa mga talahanayan, matriks, at mga pares.

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

Dalawang bagay ang tandaan. Una, mabilis lumaki ang gastos: dalawang nested loop na may tig-10,000 elemento ay 100 milyong operasyon. Ikalawa, lalabas ang break sa panloob na loop lang. Para huminto sa dalawa, ilagay ang mga loop sa isang function at gamitin ang return — mas malinis ito kaysa sa mga flag.

Ang match/case statement

Mula Python 3.10, maaaring palitan ng match statement (PEP 634) ang mahabang kadena ng if cmd == ... elif .... Hindi lang ito basta switch: itinutugma nito ang halaga sa pattern ayon sa hugis ng datos, at agad nitong hinahati ang mga bahagi sa mga variable.

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"Idagdag ang {item}: {amount}"
        case ["list"] | ["ls"]:
            return "Ipakita ang mga gastos"
        case ["quit"]:
            return "Labas"
        case _:
            return "Hindi kilalang utos"

print(parse("add Kape 250"))  # Idagdag ang Kape: 250
print(parse("add Kape"))      # Hindi kilalang utos

Ang pattern na listahang ["add", item, amount] ay tutugma lamang sa listahang eksaktong tatlong elemento, at ang una ay "add". Kaya ang utos na walang halaga ay mapupunta sa sangay na _, na sumasalo sa lahat ng iba. Pinagsasama ng simbolong | ang mga alternatibo.

Mga dictionary, uri, at guard na kondisyon

Tinitingnan lang ng dictionary pattern ang mga key na nakalista; ang sobrang key ay binabalewala. Tinitingnan ng int(a) ang uri at kinukuha ang halaga, at ang if pagkatapos ng pattern ay nagdaragdag ng dagdag na kondisyon (guard):

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Malaking gastos", a)
    case {"type": "expense", "amount": int(a)}:
        print("Gastos", a)

Ang pangunahing bitag ng match

Ang payak na pangalan sa case ay capture, hindi paghahambing sa variable. Ang case limit: ay tutugma sa anumang halaga at isusulat ito sa limit. Para ihambing sa mga constant, gamitin ang pangalang may tuldok, halimbawa case Color.RED:, o mga literal.

Halos hindi nagbago ang sintaks ng match mula 3.10. Sa Python 3.15, inayos ang maliit na kawalang-simetriya: dati, minus lang ang pinapayagan bago ang numero sa literal na pattern; ngayon, puwede na ring isulat ang case +1:. Sa mas lumang bersyon, magdudulot ng syntax error ang ganitong code.

Karaniwang pagkakamali sa mga loop

• Pagbabago ng listahan habang dumadaan dito. Ang pagtanggal ng elemento sa for ay nilalaktawan ang mga katabi. Mas mainam na bumuo ng bagong listahan: clean = [x for x in items if x > 0].
• Hangganan ng range. Hindi kasama sa range(1, n) ang n.
• Nakalimutang baguhin ang kondisyon sa while — walang hanggang loop.
• Pagdudugtong ng string sa loop gamit ang += ay mas mabagal sa malalaking dami kaysa sa "".join(parts).
• Assignment sa halip na paghahambing: ang if x = 5 ay syntax error; ang paghahambing ay isinusulat bilang ==.

Mga gawain sa loop para sa praktika

1. Kalkulahin ang kabuuan at average ng listahan ng gastos, nilalaktawan ang mga negatibong halaga.
2. Ipakita ang multiplication table na 1–9 gamit ang nested loop.
3. Tanungin ang user ng mga numero hanggang maglagay siya ng walang laman na linya, saka ipakita ang pinakamalaki.
4. Hanapin ang unang numerong mas malaki sa 1000 sa listahan, at ipaalam kung wala (gamit ang for ... else).
5. Suriin ang mga utos na add, del, at list gamit ang match.

Buod

Dalawang konstruksiyon lang ang bumubuo sa mga loop ng Python: dumadaan ang for sa mga elemento ng koleksiyon o ng range(), at tumatakbo ang while habang totoo ang kondisyon. Kinokontrol ng break at continue ang takbo ng loop, inaalis ng enumerate() at zip() ang mga manwal na counter, at ang if/elif/else at match/case ang humahawak ng mga desisyon. Ang lahat ng ito ay tinalakay nang praktikal sa lektyur ng kurso sa Python gamit ang tagasubaybay ng gastos.