# Mizunguko na masharti katika Python: for, while, range, enumerate, break, if/elif na match/case

URL: https://skillaria.top/sw/guides/python/cikly-python

Mizunguko katika Python hurudia kitendo: for hupitia kila kipengele cha mkusanyiko au range(), while hufanya kazi mradi sharti ni kweli. Mzunguko unasitishwa kwa break, kipengele kinaruka kwa continue, na namba ya kipengele hupatikana kwa enumerate(). Maamuzi hufanywa na masharti if/elif/else, na kuchambua data kwa umbo lake kwa match/case (tangu Python 3.10).

Mizunguko katika Python hutumika kurudia kitendo: kupitia orodha ya manunuzi, kushughulikia kila mstari wa faili, au kumuuliza mtumiaji hadi aweke namba sahihi. Lugha ina mizunguko miwili — `for` na `while` — na ndani yake maamuzi hufanywa kwa masharti `if/elif/else` na kwa kauli `match/case`. Hebu tuchambue kila zana kwa mifano ya vitendo.

## Masharti: if, elif, else

Kauli ya masharti hutekeleza kizuizi cha msimbo tu ikiwa usemi ni kweli. Kizuizi kinatambuliwa kwa ujongezaji wa nafasi 4 — Python haina mabano ya mikunjo, na ujongezaji usio sahihi unatoa `IndentationError` mara moja.

```
spent = 4200
limit = 5000

if spent > limit:
    print("Kikomo kimezidi")
elif spent > limit * 0.8:
    print("Imebaki chini ya 20% ya bajeti")
else:
    print("Kila kitu kiko sawa")
```

Matawi ya `elif` hukaguliwa kutoka juu kwenda chini, na ni tawi la kwanza linalofaa tu ndilo linalotekelezwa. Kwa hiyo weka masharti makali zaidi juu: kama ukaguzi wa `spent > limit * 0.8` ungekuwa wa kwanza, ujumbe wa kuzidi kikomo usingeonekana kamwe.

### Kipi kinachukuliwa kuwa kweli

Katika sharti si lazima kuandika ulinganisho. Thamani zisizo kweli ni `False`, `None`, sifuri (`0`, `0.0`) na mkusanyiko mtupu: `""`, `[]`, `{}`. Kila kitu kingine ni kweli. Kwa hiyo ukaguzi wa "orodha si tupu" huandikwa kwa ufupi:

```
expenses = []
if not expenses:
    print("Bado hakuna matumizi")
```

Masharti huunganishwa kwa `and`, `or`, `not`, na safu ya namba hukaguliwa kwa mnyororo wa ulinganisho: `if 0 < amount <= 100_000:`. Kwa uchaguzi mfupi wa thamani kuna opereta ya masharti: `status = "juu" if spent > limit else "kawaida"`.

## Mzunguko wa for katika Python: sintaksia na mifano

Mzunguko `for` katika Python si kaunta kama katika C, bali ni kupitia vipengele. Huchukua kila kipengele cha kitu kinachoweza kupitiwa: orodha, mfuatano, kamusi, faili au range. Kile ambacho lugha nyingine huita foreach ndicho `for` ya kawaida hapa.

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

Sintaksia ya for: `for kigezo in mkusanyiko:`, kisha kizuizi kilichojongezwa. Kigezo kinabaki na thamani ya mwisho baada ya mzunguko — wakati mwingine ni muhimu, lakini kukitegemea kwenye programu kubwa si wazo zuri.

### Mzunguko kwenye mfuatano, orodha na kamusi

Mfuatano hupitiwa herufi kwa herufi, orodha kwa vipengele. Mzunguko kwenye kamusi kwa kawaida hupita kwenye funguo; ili kupata ufunguo na thamani pamoja tumia `.items()`:

```
by_category = {"chakula": 3200, "usafiri": 900, "sinema": 600}

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

Kwa thamani pekee kuna `.values()`. Huwezi kubadilisha ukubwa wa kamusi wakati wa kuipitia — utapata `RuntimeError: dictionary changed size during iteration`. Ukihitaji kufuta vipengele, pitia nakala: `for key in list(d):`.

## Kazi ya range: mzunguko juu ya namba

Pale unapohitaji kupitia namba, `range()` ndiyo msaada. Haitengenezi orodha kwenye kumbukumbu, bali hutoa namba moja moja, kwa hiyo `range(10**9)` hufanya kazi papo hapo.

| Mwito | Namba |
| --- | --- |

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

Kanuni kuu: mpaka wa kulia hauingii kwenye safu. `range(1, 10)` itaishia kwenye 9 — hili ni chanzo cha kawaida cha kosa la "moja zaidi au moja pungufu". Hatua inaweza kuwa hasi, lakini haiwezi kuwa sifuri.

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

## enumerate: kaunta katika mzunguko

Wanaoanza mara nyingi huandika `for i in range(len(items))` ili kujua namba ya kipengele. Hufanya kazi, lakini husomeka vibaya. Kazi `enumerate()` hutoa jozi "namba, kipengele", na kigezo `start` kinaonyesha tangu namba gani kuhesabu:

```
items = ["kahawa", "teksi", "chakula"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 kahawa
# 2 teksi
# 3 chakula
```

Kwa kupitia orodha mbili kwa wakati mmoja kuna `zip()`: `for name, price in zip(names, prices):`. Huacha kwenye orodha fupi kabisa; tangu Python 3.10 unaweza kutoa `strict=True`, na hapo urefu tofauti utasababisha kosa.

## Mzunguko wa while katika Python

Mzunguko `while` hurudia kizuizi mradi sharti ni kweli. Huchaguliwa pale idadi ya marudio isipojulikana mapema: tunangojea uingizaji sahihi, tunasoma data hadi mwisho, au tunarudia ombi hadi lifanikiwe.

```
balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"Pesa itatosha kwa miezi {month}")  # 4
```

Hatari kubwa ni kusahau kubadilisha kigezo kilicho kwenye sharti. Kisha mzunguko hautaisha kamwe. Programu ikiwa "imeganda", bonyeza Ctrl+C: Python itasimamisha utekelezaji kwa `KeyboardInterrupt`.

### Mzunguko usio na mwisho na do while

Wakati mwingine mzunguko usio na mwisho huandikwa kwa makusudi: `while True:` yenye kutoka kwa `break`. Hivyo hivyo hufanywa mzunguko wenye sharti mwishoni — Python haina kauli ya `do while`, na mbinu hii inaichukua nafasi: kizuizi hutekelezwa angalau mara moja, na ukaguzi uko mwishoni.

```
while True:
    raw = input("Kiasi: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Tafadhali weka namba nzima")
```

Mzunguko wa for usio na mwisho ni nadra — hutokea tu ukipitia jenereta isiyo na mwisho, kwa mfano `itertools.count()`.

## break na continue: kutoka kwenye mzunguko na kuruka mzunguko

`break` huvunja mzunguko mara moja, na utekelezaji unaendelea kwenye msimbo unaofuata. `continue` huruka mabaki ya mzunguko wa sasa na kwenda kwenye unaofuata.

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

for amount in expenses:
    if amount  50_000:
        print("Kiasi cha kutiliwa shaka, simama")
        break             # toka kwenye mzunguko
    print(amount)
```

Itachapisha 350 na 1200, kisha ujumbe — mzunguko haufiki 89. Kauli zote mbili zinaathiri mzunguko wa karibu zaidi ulio nao.

### else ya mzunguko

`for` na `while` zina tawi la `else` lisilo la kawaida: hutekelezwa iwapo mzunguko umemalizika wenyewe, bila `break`. Ni rahisi kwa kutafuta:

```
for amount in expenses:
    if amount > 50_000:
        print("Tumepata matumizi makubwa")
        break
else:
    print("Hakuna matumizi makubwa")
```

## Mizunguko iliyoingiana

Mzunguko ndani ya mzunguko: kwa kila hatua ya mzunguko wa nje, mzunguko wa ndani hukamilika wote. Hivyo hupitiwa jedwali, matrix, au jozi za vitu.

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

Zingatia mambo mawili. Kwanza, ugumu wa kazi hukua haraka: mizunguko miwili iliyoingiana ya vipengele 10 000 kila moja ni shughuli milioni 100. Pili, `break` hutoka kwenye mzunguko wa ndani tu. Ili kusimamisha yote mawili, weka mizunguko kwenye kazi na tumia `return` — ni safi zaidi kuliko bendera.

## Kauli ya match/case

Mnyororo mrefu wa `if cmd == ... elif ...` tangu Python 3.10 unaweza kubadilishwa na kauli ya `match` (PEP 634). Si switch tu: inalinganisha thamani na mfano kwa umbo la data, na mara moja inagawanya sehemu zake kwenye vigezo.

```
def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"Ongeza {item}: {amount}"
        case ["list"] | ["ls"]:
            return "Onyesha matumizi"
        case ["quit"]:
            return "Toka"
        case _:
            return "Amri isiyojulikana"

print(parse("add Kahawa 250"))  # Ongeza Kahawa: 250
print(parse("add Kahawa"))      # Amri isiyojulikana
```

Mfano wa orodha `["add", item, amount]` utalingana tu na orodha yenye vipengele vitatu hasa, cha kwanza kikiwa `"add"`. Kwa hiyo amri bila kiasi inaenda kwenye tawi la `_`, linalonasa kila kitu kingine. Alama `|` huunganisha chaguo.

### Kamusi, aina na sharti la ulinzi

Mfano wa kamusi hukagua funguo zilizotajwa tu; funguo za ziada hupuuzwa. Andiko `int(a)` hukagua aina na kunasa thamani, na `if` baada ya mfano huongeza sharti la ziada (guard):

```
match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Matumizi makubwa", a)
    case {"type": "expense", "amount": int(a)}:
        print("Matumizi", a)
```

### Mtego mkuu wa match

Jina pekee katika `case` ni kunasa, si ulinganisho na kigezo. `case limit:` italingana na thamani yoyote na kuiandika kwenye `limit`. Ili kulinganisha na thamani zisizobadilika, tumia jina lenye nukta, kwa mfano `case Color.RED:`, au literal.

Sintaksia ya match tangu 3.10 haijabadilika sana. Katika Python 3.15 ilirekebishwa kasoro ndogo ya ulinganifu: awali katika mifano ya literal ruhusa ilikuwa ya alama ya minus tu mbele ya namba, sasa unaweza pia kuandika `case +1:`. Kwenye matoleo ya zamani msimbo kama huo utatoa kosa la sintaksia.

## Makosa ya kawaida katika mizunguko

- **Kubadilisha orodha wakati wa kuipitia.** Kufuta vipengele ndani ya `for` kunaruka vilivyo jirani. Ni bora kujenga orodha mpya: `clean = [x for x in items if x > 0]`.
- **Mpaka wa range.** `range(1, n)` haijumuishi `n`.
- **Kusahau kubadilisha sharti katika while** — mzunguko usio na mwisho.
- **Kuunganisha mifuatano kwa += ndani ya mzunguko** kwa data nyingi ni polepole kuliko `"".join(parts)`.
- **Mgawo badala ya ulinganisho**: `if x = 5` ni kosa la sintaksia; ulinganisho huandikwa `==`.

## Kazi za mizunguko kwa mazoezi

1. Hesabu jumla na wastani wa orodha ya matumizi, ukiruka thamani hasi.
2. Chapisha jedwali la kuzidisha 1–9 kwa mizunguko iliyoingiana.
3. Uliza mtumiaji namba hadi aandike mstari tupu, kisha chapisha kubwa zaidi.
4. Tafuta namba ya kwanza kubwa kuliko 1000 kwenye orodha, na ujulishe kama haipo (kwa `for ... else`).
5. Chambua amri `add`, `del`, `list` kwa `match`.

## Hitimisho

Mizunguko ya Python inakuja kwa miundo miwili: `for` hupitia vipengele vya mkusanyiko au `range()`, `while` hufanya kazi mradi sharti ni kweli. `break` na `continue` huongoza mwenendo wa mzunguko, `enumerate()` na `zip()` huondoa kaunta za mkono, na `if/elif/else` pamoja na `match/case` hushughulikia maamuzi. Zana hizi zote zimefafanuliwa kwa vitendo kwa mfano wa kifuatiliaji cha matumizi katika somo la kozi ya Python.

## FAQ

**For inatofautianaje na while katika Python?**

For hupitia mfuatano uliopo na yenyewe hujua wakati wa kusimama, wakati while hurudia mradi sharti ni kweli. Ikiwa idadi ya marudio inajulikana au una mkusanyiko, tumia for; ikiwa unangoja tukio, tumia while.

**Ninawezaje kupitia mzunguko kwa mpangilio wa nyuma?**

Tumia reversed(items) kwa mkusanyiko au range(n - 1, -1, -1) kwa namba. Kazi ya reversed haitengenezi nakala ya orodha, bali inapita kutoka mwisho.

**Je, Python ina switch?**

Hakuna switch tofauti; nafasi yake inachukuliwa na mnyororo wa if/elif na kauli ya match/case iliyoletwa katika Python 3.10. match inaweza zaidi: inachambua orodha na kamusi kwa umbo na kunasa thamani.

**Kipi ni cha haraka zaidi — mzunguko au generator ya orodha?**

Generator ya orodha kama [x * 2 for x in items] kwa kawaida ni kidogo haraka kuliko mzunguko sawa na append, na ni mfupi. Kwa mantiki tata yenye sharti kadhaa, mzunguko wa kawaida husomeka vizuri zaidi.

**Ninawezaje kutoka mara moja kwenye mizunguko miwili iliyoingiana?**

break hutoka kwenye mzunguko wa ndani tu. Njia rahisi ni kuweka mizunguko kwenye kazi na kutoka kwa return.


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