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

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.

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 <= 0:
        continue          # ruka mzunguko huu
    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.