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

URL: https://skillaria.top/tl/guides/python/loop-python-kondisyon

Ang loop sa Python ay paulit-ulit na pagpapatakbo ng aksyon: ang for ay dumadaan sa bawat elemento ng koleksiyon o ng range(), at ang while ay tumatakbo habang totoo ang kondisyon. Maaaring huminto ang loop gamit ang break, at lumaktaw sa isang ulit gamit ang continue; ang numero ng elemento ay ibinibigay ng enumerate(). Ang desisyon ay gawa ng if/elif/else, at ang paghahati ng datos ayon sa hugis ay ng match/case (mula Python 3.10).

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)`.

| Tawag | Mga numero |
| --- | --- |

| `range(5)` | 0, 1, 2, 3, 4 |

| `range(2, 6)` | 2, 3, 4, 5 |

| `range(0, 10, 3)` | 0, 3, 6, 9 |

| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |

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  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.

## FAQ

**Ano ang pagkakaiba ng for at while sa Python?**

Dumadaan ang for sa isang handang sunod-sunod na datos at alam nito kung kailan titigil, samantalang inuulit ng while ang sarili habang totoo ang kondisyon. Kung alam ang bilang ng ulit o may koleksiyon, gamitin ang for; kung naghihintay ng pangyayari, gamitin ang while.

**Paano dumaan sa loop nang pabaliktad?**

Gamitin ang reversed(items) para sa koleksiyon, o range(n - 1, -1, -1) para sa mga numero. Hindi kinokopya ng reversed ang listahan, kundi dinadaanan ito mula sa dulo.

**Mayroon bang switch sa Python?**

Walang hiwalay na switch. Ang kadena ng if/elif at ang match/case, na lumitaw sa Python 3.10, ang gumaganap ng papel nito. Mas marami ang kayang gawin ng match: naghahati ito ng mga listahan at dictionary ayon sa hugis at kumukuha ng mga halaga.

**Alin ang mas mabilis, loop o list comprehension?**

Kadalasan bahagyang mas mabilis ang list comprehension na gaya ng [x * 2 for x in items] kaysa sa katumbas na loop na may append, at mas maikli ito. Para sa mas komplikadong lohika na may maraming kondisyon, mas madaling basahin ang karaniwang loop.

**Paano lumabas agad sa dalawang nested loop?**

Hinihinto ng break ang panloob na loop lamang. Pinakamadaling ilagay ang mga loop sa isang function at lumabas gamit ang return.


---
Source: Skillaria.Top (https://skillaria.top)