Wiki 3: Data Structures — Lists, Tuples, Dictionaries na Sets

Mwezi 1 | Lengo kuu: Mwanafunzi aweze kuhifadhi na kuchakata makundi ya data kwa list, tuple, dict na set, na kuchagua muundo unaofaa kwa kazi husika.

Maandalizi ya Mwalimu (soma kabla ya wiki kuanza)

• Tengeneza folder python_darasa\wiki03.
• Soma: https://docs.python.org/3/tutorial/datastructures.html (sehemu 5.1, 5.3, 5.4, 5.5). Pia https://docs.python.org/3/tutorial/introduction.html#lists.
• Wiki hii ina dhana moja ngumu: list na dict ni mutable (zinabadilika), na ukiandika b = a, a na b zinaelekeza kwenye list ile ile. Jaribu mwenyewe kwenye REPL (Kipindi 1, Hatua 6) mpaka uelewe.
• Jizoeze kuandika dict ya wanafunzi (Kipindi 3) — itatumika tena Wiki 4 kwenye mradi wa "Daftari la Wanafunzi".
• Kidokezo cha kufundisha: chora kwenye "whiteboard" (au Paint/Google Jamboard) masanduku ya list yakiwa na index chini yake.

Malengo ya Wiki (mwisho wa wiki mwanafunzi ataweza...)

1. Kutengeneza list, kufikia vipengele kwa index na slicing, na kuibadilisha.
2. Kutumia list methods: append, insert, extend, remove, pop, sort, reverse, index, count, na len, sum, min, max, sorted, in.
3. Kupitia list kwa for (pamoja na enumerate), na kujenga list mpya ndani ya loop.
4. Kutumia tuple na kuelewa kwa nini haibadiliki; tuple unpacking.
5. Kutumia dictionary: kuongeza, kubadilisha, kufuta, .get(), .keys(), .values(), .items(), kupitia kwa loop, kuhesabu (counting).
6. Kutumia set: kuondoa marudio, union, intersection, difference.
7. Kutumia nested structures (list ya dicts, dict ya lists) na kuchagua muundo sahihi.

Kipindi 1 — Lists: kutengeneza, index, slicing, methods

Mtiririko wa kipindi

1. Marudio ya kazi ya nyumbani (FizzBuzz, PIN)
2. Kwa nini tunahitaji list? Kutengeneza list, len, index
3. Slicing na kubadilisha kipengele
4. Methods za kuongeza na kuondoa
5. Mapumziko
6. sort, sorted, sum, min, max, in, index, count
7. Mutability: b = a dhidi ya b = a.copy()
8. Zoezi darasani
9. Q&A + kazi ya nyumbani

Elezo kwa mwalimu (soma kwanza wewe)

• List ni mfuatano wa vitu vilivyopangwa, ndani ya mabano ya mraba [], vimetenganishwa kwa koma: matunda = ["embe", "ndizi", "chungwa"].
• Inaweza kuwa na aina yoyote, hata mchanganyiko: [1, "a", 2.5, True]. List tupu: [].
• Index na slicing ni sawa kabisa na strings (Wiki 2): matunda[0], matunda[-1], matunda[0:2].
• Tofauti kubwa na string: list ni mutable — inaweza kubadilishwa mahali pake: matunda[0] = "papai" inafanya kazi.
• Methods zinazobadilisha list (na kurudisha None):
  • append(x) — ongeza mwishoni
  • insert(i, x) — ongeza kwenye index i
  • extend(list2) — ongeza vipengele vyote vya list nyingine
  • remove(x) — ondoa x ya kwanza inayopatikana (error kama haipo)
  • pop() — ondoa na rudisha cha mwisho; pop(i) — cha index i
  • sort() — panga (kwa namba: ndogo→kubwa; strings: alfabeti); sort(reverse=True)
  • reverse() — geuza mpangilio
  • clear() — futa vyote
• Functions/methods zisizobadilisha: len(l), sum(l), min(l), max(l), sorted(l) (inarudisha list mpya iliyopangwa), l.index(x), l.count(x), x in l.
• Mtego mkubwa: matunda = matunda.sort() → sasa matunda ni None! Kwa sababu sort() inabadilisha list na inarudisha None. Andika matunda.sort() peke yake, au mpya = sorted(matunda).
• Mutability/aliasing: b = a haitengenezi nakala; ni lebo ya pili kwenye list ile ile. Kutengeneza nakala: b = a.copy() au b = a[:].
• Kutoka string kuwa list: "a,b,c".split(",") → ['a', 'b', 'c']. Kutoka list kuwa string: ", ".join(["a", "b"]) → "a, b".

Sema hivi kwa mwanafunzi

• "Hadi sasa variable moja ilishika kitu kimoja. Ukiwa na wanafunzi 40, utatengeneza variables 40? Hapana! List ni kama kabati lenye droo zilizopangwa, kila droo ina namba (index) kuanzia 0."
• "List ni kama orodha ya manunuzi sokoni: unaweza kuongeza kitu (append), kufuta (remove), kupanga (sort)."
• "String ni kama maandishi kwenye jiwe (hayabadiliki); list ni kama maandishi ya penseli (unaweza kufuta na kuandika upya)."
• "b = a ni kama kumpa rafiki ufunguo wa pili wa nyumba yako — si nyumba ya pili! Akihamisha kiti, nyumba yako ndiyo imebadilika. a.copy() ni kujenga nyumba nyingine inayofanana."

Andika code hii live (share screen)

Hatua 1 — lists.py: kutengeneza na kufikia

matunda = ["embe", "ndizi", "chungwa", "nanasi"]
print(matunda)            # ['embe', 'ndizi', 'chungwa', 'nanasi']
print(len(matunda))       # 4
print(matunda[0])         # embe
print(matunda[-1])        # nanasi
print(matunda[1:3])       # ['ndizi', 'chungwa']
print(type(matunda))      # <class 'list'>

Hatua 2 — Kubadilisha

matunda[0] = "papai"
print(matunda)            # ['papai', 'ndizi', 'chungwa', 'nanasi']

Hatua 3 — Kuongeza

manunuzi = []
manunuzi.append("mchele")
manunuzi.append("sukari")
manunuzi.insert(0, "unga")
manunuzi.extend(["chumvi", "mafuta"])
print(manunuzi)    # ['unga', 'mchele', 'sukari', 'chumvi', 'mafuta']

Hatua 4 — Kuondoa

manunuzi.remove("sukari")
print(manunuzi)            # ['unga', 'mchele', 'chumvi', 'mafuta']
cha_mwisho = manunuzi.pop()
print(cha_mwisho)          # mafuta
print(manunuzi)            # ['unga', 'mchele', 'chumvi']
cha_kwanza = manunuzi.pop(0)
print(cha_kwanza)          # unga
print(manunuzi)            # ['mchele', 'chumvi']
del manunuzi[0]
print(manunuzi)            # ['chumvi']

Hatua 5 — Kupanga na takwimu

alama = [67, 82, 45, 90, 73, 82]
print(len(alama), sum(alama), min(alama), max(alama))   # 6 439 45 90
print("Wastani:", round(sum(alama) / len(alama), 2))      # Wastani: 73.17
print(sorted(alama))          # [45, 67, 73, 82, 82, 90]  (mpya)
print(alama)                  # [67, 82, 45, 90, 73, 82]  (haijabadilika)
alama.sort(reverse=True)
print(alama)                  # [90, 82, 82, 73, 67, 45]
print(alama.count(82))        # 2
print(alama.index(73))        # 3
print(100 in alama)           # False

Onyesha mtego:

x = [3, 1, 2]
x = x.sort()
print(x)        # None  ← tatizo!

Hatua 6 — Mutability (REPL ni bora hapa)

>>> a = [1, 2, 3]
>>> b = a
>>> b.append(4)
>>> a
[1, 2, 3, 4]
>>> c = a.copy()
>>> c.append(5)
>>> a
[1, 2, 3, 4]
>>> c
[1, 2, 3, 4, 5]

Hatua 7 — split na join

mstari = "Dodoma,Arusha,Mwanza,Tanga"
miji = mstari.split(",")
print(miji)                    # ['Dodoma', 'Arusha', 'Mwanza', 'Tanga']
print(" | ".join(miji))        # Dodoma | Arusha | Mwanza | Tanga

namba_str = input("Weka namba zilizotenganishwa kwa nafasi: ")   # mf. 4 8 15
vipande = namba_str.split()
print(vipande)                 # ['4', '8', '15']  ← bado ni strings

Maswali ya kumuuliza mwanafunzi

1. l = [10, 20, 30]; l[1]? — Jibu: 20.
2. Tofauti ya append na extend? — Jibu: l.append([1,2]) inaongeza list nzima kama kipengele kimoja; l.extend([1,2]) inaongeza 1 na 2 kila moja.
3. Tofauti ya sort() na sorted()? — Jibu: sort() inabadilisha list yenyewe na kurudisha None; sorted() inarudisha list mpya.
4. pop() na remove()? — Jibu: pop inaondoa kwa index (na kurudisha kitu); remove inaondoa kwa thamani.
5. Baada ya b = a; b.append(9), a imebadilika? — Jibu: Ndiyo, ni list ile ile.

Makosa ya kawaida

Zoezi darasani

1. Tengeneza list ya miji 5 ya Tanzania. Ongeza mmoja mwishoni, mmoja mwanzoni, ondoa wa tatu, panga kialfabeti na chapisha.
2. Kuna list alama = [55, 78, 91, 34, 66, 78]. Chapisha: idadi, jumla, wastani, kubwa, ndogo, na alama 3 bora (top 3).
3. Uliza mtumiaji majina yaliyotenganishwa kwa koma; onyesha idadi ya majina na majina yamepangwa.

# zoezi 1
miji = ["Dodoma", "Arusha", "Mwanza", "Tanga", "Mbeya"]
miji.append("Iringa")
miji.insert(0, "Kigoma")
miji.pop(2)          # wa tatu ni index 2 -> "Arusha"
miji.sort()
print(miji)   # ['Dodoma', 'Iringa', 'Kigoma', 'Mbeya', 'Mwanza', 'Tanga']

# zoezi 2
alama = [55, 78, 91, 34, 66, 78]
print("Idadi:", len(alama))
print("Jumla:", sum(alama))
print("Wastani:", round(sum(alama) / len(alama), 1))
print("Kubwa:", max(alama), "Ndogo:", min(alama))
print("Top 3:", sorted(alama, reverse=True)[:3])   # [91, 78, 78]

# zoezi 3
maandishi = input("Majina (tenganisha kwa koma): ")
majina = maandishi.split(",")
safi = []
for j in majina:
    safi.append(j.strip().title())
print("Idadi:", len(safi))
print("Yamepangwa:", sorted(safi))

Kipindi 2 — Loops juu ya Lists, na Tuples

Mtiririko wa kipindi

1. Marudio ya kazi ya nyumbani
2. for juu ya list; accumulator (jumla, kubwa zaidi)
3. Kujenga list mpya kwenye loop (filter); enumerate; range(len())
4. List comprehension (utangulizi mfupi)
5. Mapumziko
6. Tuples: kutengeneza, immutable, unpacking
7. Lists ndani ya lists (nested lists, kidogo)
8. Zoezi darasani
9. Q&A + kazi ya nyumbani

Elezo kwa mwalimu (soma kwanza wewe)

• for kitu in list: — kitu inapata kila kipengele kwa zamu. Jina kitu unachagua wewe (mf. for tunda in matunda: — jina la umoja kwa list ya wingi ni mazoea mazuri).
• Patterns 3 muhimu:
  1. Accumulate: jumla = 0 → for x in l: jumla += x
  2. Filter: mpya = [] → for x in l: if sharti: mpya.append(x)
  3. Transform: mpya = [] → for x in l: mpya.append(x * 2)
• enumerate(l) inatoa jozi (index, kitu): for i, tunda in enumerate(matunda):. enumerate(l, start=1) kuanza kuhesabu 1.
• List comprehension ni njia fupi ya pattern 2 na 3: [x * 2 for x in l], [x for x in l if x > 50]. Ifundishe kama "njia fupi"; mwanafunzi akiona ngumu, njia ndefu inatosha.
• Usibadilishe list unayoipitia (mf. kutumia remove ndani ya for juu ya list ile ile) — inaruka vipengele. Tengeneza list mpya badala yake.
• Tuple ni kama list lakini haibadiliki (immutable), inatumia mabano (): nafasi = (6.16, 35.75). Inatumika kwa data isiyopaswa kubadilika: tarehe, coordinates, siku za wiki.
  • Tuple ya kipengele kimoja inahitaji koma: (5,). (5) ni int tu!
  • Unpacking: lat, lon = nafasi. Pia kubadilishana: a, b = b, a.
  • Methods: count, index tu.
  • Faida: salama (haibadiliki kwa bahati mbaya), inaweza kuwa key ya dict (Kipindi 3).

Sema hivi kwa mwanafunzi

• "for juu ya list ni kama kusalimiana na kila mtu kwenye mstari — mmoja mmoja, mpaka wa mwisho."
• "Accumulator ni kama kibubu (piggy bank): kinaanza na 0, kila mzunguko unaweka kitu ndani."
• "Tuple ni kama cheti cha kuzaliwa — kimeandikwa mara moja na hakibadilishwi. List ni kama orodha ya manunuzi — inabadilika kila siku."

Andika code hii live (share screen)

Hatua 1 — loop_lists.py

matunda = ["embe", "ndizi", "chungwa"]
for tunda in matunda:
    print("Ninapenda", tunda)

Ninapenda embe
Ninapenda ndizi
Ninapenda chungwa

Hatua 2 — Accumulator: jumla na kubwa zaidi (bila max)

bei = [1500, 3200, 800, 4500, 2000]
jumla = 0
kubwa = bei[0]
for b in bei:
    jumla += b
    if b > kubwa:
        kubwa = b
print("Jumla:", jumla)     # Jumla: 12000
print("Ghali zaidi:", kubwa)   # Ghali zaidi: 4500

Hatua 3 — Filter na transform

alama = [45, 82, 67, 30, 91, 58]

waliofaulu = []
for a in alama:
    if a >= 50:
        waliofaulu.append(a)
print(waliofaulu)              # [82, 67, 91, 58]

zilizoongezwa = []
for a in alama:
    zilizoongezwa.append(a + 5)
print(zilizoongezwa)           # [50, 87, 72, 35, 96, 63]

Kisha njia fupi (list comprehension):

waliofaulu = [a for a in alama if a >= 50]
zilizoongezwa = [a + 5 for a in alama]
print(waliofaulu, zilizoongezwa)

Hatua 4 — enumerate

wanafunzi = ["Amina", "Baraka", "Neema"]
for i, jina in enumerate(wanafunzi, start=1):
    print(f"{i}. {jina}")

1. Amina
2. Baraka
3. Neema

Njia nyingine (ya zamani) — ielewe ukiiona kwenye mtandao:

for i in range(len(wanafunzi)):
    print(i, wanafunzi[i])

Hatua 5 — Kujenga list kutoka input

namba = []
while True:
    x = input("Weka alama (au 'q' kumaliza): ")
    if x == "q":
        break
    namba.append(int(x))
print("Alama:", namba)
if namba:
    print("Wastani:", sum(namba) / len(namba))
else:
    print("Hakuna alama.")

Hatua 6 — Tuples

siku = ("Jumatatu", "Jumanne", "Jumatano", "Alhamisi", "Ijumaa")
print(siku[0], len(siku))       # Jumatatu 5
print(type(siku))               # <class 'tuple'>

dodoma = (-6.16, 35.75)         # (latitude, longitude)
lat, lon = dodoma               # unpacking
print(f"Latitude {lat}, Longitude {lon}")

a, b = 1, 2
a, b = b, a                     # kubadilishana
print(a, b)                     # 2 1

moja = (5,)
si_tuple = (5)
print(type(moja), type(si_tuple))   # <class 'tuple'> <class 'int'>

Onyesha error:

siku[0] = "Monday"
# TypeError: 'tuple' object does not support item assignment

Hatua 7 — List ya tuples (inaandaa Kipindi 3)

bidhaa = [("Sukari", 3000), ("Mchele", 2800), ("Mafuta", 6500)]
jumla = 0
for jina, bei in bidhaa:
    print(f"{jina:<10}{bei:>8,}")
    jumla += bei
print(f"{'JUMLA':<10}{jumla:>8,}")

Sukari       3,000
Mchele       2,800
Mafuta       6,500
JUMLA       12,300

Maswali ya kumuuliza mwanafunzi

1. Tutaandikaje loop inayochapisha namba shufwa tu kutoka list? — Jibu: for n in l: if n % 2 == 0: print(n).
2. Kwa nini jumla = 0 iko nje ya loop? — Jibu: Ingekuwa ndani, ingerudi 0 kila mzunguko.
3. Tofauti kuu ya list na tuple? — Jibu: List inabadilika (mutable) []; tuple haibadiliki (immutable) ().
4. x = (7) — aina gani? — Jibu: int. Tuple ya kimoja ni (7,).
5. enumerate inatoa nini? — Jibu: Jozi ya (index, kipengele).

Makosa ya kawaida

Zoezi darasani

1. Kuna joto = [28, 31, 25, 33, 29, 35, 27] (nyuzi joto za wiki). Chapisha siku (namba 1–7) zilizokuwa na joto zaidi ya 30, kwa enumerate.
2. Kutoka majina = ["amina", "juma", "neema", "ali", "baraka"], tengeneza list mpya ya majina yenye herufi zaidi ya 4, kwa herufi kubwa mwanzo. Fanya kwa loop, kisha kwa list comprehension.
3. Tengeneza list ya tuples (jina, alama) kwa wanafunzi 4; chapisha jina la aliyepata alama kubwa zaidi.

# zoezi 1
joto = [28, 31, 25, 33, 29, 35, 27]
for siku, t in enumerate(joto, start=1):
    if t > 30:
        print(f"Siku {siku}: {t}°C")
# Siku 2: 31°C, Siku 4: 33°C, Siku 6: 35°C

# zoezi 2
majina = ["amina", "juma", "neema", "ali", "baraka"]
mpya = []
for j in majina:
    if len(j) > 4:
        mpya.append(j.title())
print(mpya)                    # ['Amina', 'Neema', 'Baraka']

mpya2 = [j.title() for j in majina if len(j) > 4]
print(mpya2)

# zoezi 3
matokeo = [("Amina", 78), ("Juma", 91), ("Neema", 85), ("Ali", 60)]
bora_jina, bora_alama = matokeo[0]
for jina, alama in matokeo:
    if alama > bora_alama:
        bora_jina, bora_alama = jina, alama
print(f"Bora: {bora_jina} ({bora_alama})")    # Bora: Juma (91)

Kipindi 3 — Dictionaries, Sets, Nested Structures na Kuchagua Muundo Sahihi

Mtiririko wa kipindi

1. Marudio ya kazi ya nyumbani
2. Dictionary: key/value, kuongeza, kubadilisha, kufuta, .get(), in
3. Kupitia dict: .keys(), .values(), .items(); kuhesabu maneno
4. Mapumziko
5. Sets: kuondoa marudio, operations
6. Nested: list ya dicts (wanafunzi), dict ya lists
7. Kuchagua muundo sahihi (jedwali)
8. Q&A + kazi ya nyumbani

Elezo kwa mwalimu (soma kwanza wewe)

• Dictionary (dict) inahifadhi jozi za key: value ndani ya {}: mwanafunzi = {"jina": "Amina", "umri": 20}. Unapata thamani kwa key, si index: mwanafunzi["jina"].
• Keys lazima ziwe za kipekee (unique) na zisizobadilika (str, int, tuple — si list). Values zinaweza kuwa chochote.
• Operesheni:
  • Kusoma: d["key"] → KeyError kama haipo. d.get("key") → None kama haipo; d.get("key", 0) → 0 kama haipo.
  • Kuongeza/kubadilisha: d["key"] = thamani (kama ipo inabadilishwa, kama haipo inaongezwa).
  • Kufuta: del d["key"] au d.pop("key").
  • Kuangalia: "key" in d (inaangalia keys, si values).
  • len(d) → idadi ya jozi.
• Kupitia: for k in d: (keys), for v in d.values():, for k, v in d.items():.
• Tangu Python 3.7, dict inakumbuka mpangilio wa kuingiza.
• Counting pattern: hesabu[neno] = hesabu.get(neno, 0) + 1.
• Set ni mkusanyiko usio na marudio na usio na mpangilio: {1, 2, 3}. Set tupu ni set() — si {} (hiyo ni dict tupu!). Haina index. Matumizi: kuondoa marudio set(l), kuangalia uanachama haraka, na hisabati ya makundi: a | b (union), a & b (intersection), a - b (difference). Methods: add, remove, discard.
• Nested: list ya dicts ni muundo wa kawaida sana kwa "rekodi" (kama jedwali la Excel: kila dict ni mstari): wanafunzi = [{"jina": "Amina", "alama": 78}, ...]. Kufikia: wanafunzi[0]["jina"].
• Kuchagua muundo: | Hitaji | Tumia | |---|---| | Mfuatano unaobadilika, mpangilio muhimu, marudio yanaruhusiwa | list | | Data isiyobadilika (tarehe, coordinates) | tuple | | Kutafuta kwa jina/key (simu kwa jina, bei kwa bidhaa) | dict | | Vitu vya kipekee, kuondoa marudio, kulinganisha makundi | set | | Rekodi nyingi zenye sehemu nyingi | list ya dict |

Sema hivi kwa mwanafunzi

• "Dictionary ni kama kamusi ya TUKI: unatafuta neno (key) unapata maana (value). Hutafuti 'neno la 2,345' — unatafuta kwa neno lenyewe."
• "Au kama phonebook kwenye simu yako: jina → namba."
• "Set ni kama orodha ya waliohudhuria — jina moja haliandikwi mara mbili, hata mtu akiingia mara mbili."
• "List ya dicts ni kama jedwali la Excel: kila mstari ni mwanafunzi mmoja (dict), na safu ni 'jina', 'alama', n.k."

Andika code hii live (share screen)

Hatua 1 — dicts.py

mwanafunzi = {
    "jina": "Amina",
    "umri": 20,
    "mji": "Dodoma",
}
print(mwanafunzi)             # {'jina': 'Amina', 'umri': 20, 'mji': 'Dodoma'}
print(mwanafunzi["jina"])     # Amina
print(len(mwanafunzi))        # 3

mwanafunzi["umri"] = 21               # kubadilisha
mwanafunzi["kozi"] = "Python"         # kuongeza
del mwanafunzi["mji"]                 # kufuta
print(mwanafunzi)             # {'jina': 'Amina', 'umri': 21, 'kozi': 'Python'}

print("jina" in mwanafunzi)           # True
print("Amina" in mwanafunzi)          # False (in inaangalia keys)
print(mwanafunzi.get("simu"))         # None
print(mwanafunzi.get("simu", "hakuna"))   # hakuna

Onyesha error:

print(mwanafunzi["simu"])
# KeyError: 'simu'

Hatua 2 — Kupitia dict: bei za duka

bei = {"sukari": 3000, "mchele": 2800, "mafuta": 6500, "chumvi": 500}

for bidhaa in bei:
    print(bidhaa)

for bidhaa, kiasi in bei.items():
    print(f"{bidhaa.title():<8} {kiasi:>6,} TZS")

print("Jumla ya bei zote:", sum(bei.values()))   # 12800
print("Bidhaa:", list(bei.keys()))

Hatua 3 — Mfano: duka (dict + input)

bei = {"sukari": 3000, "mchele": 2800, "mafuta": 6500, "chumvi": 500}
jumla = 0
while True:
    bidhaa = input("Bidhaa (au 'mwisho'): ").strip().lower()
    if bidhaa == "mwisho":
        break
    if bidhaa not in bei:
        print("Hatuna bidhaa hiyo.")
        continue
    idadi = int(input("Idadi: "))
    jumla += bei[bidhaa] * idadi
print(f"Jumla ya kulipa: {jumla:,} TZS")

Hatua 4 — Counting pattern: kuhesabu maneno

sentensi = "haba na haba hujaza kibaba na haba"
hesabu = {}
for neno in sentensi.split():
    hesabu[neno] = hesabu.get(neno, 0) + 1
print(hesabu)
# {'haba': 3, 'na': 2, 'hujaza': 1, 'kibaba': 1}

Eleza mstari wa ndani polepole: "hesabu.get(neno, 0) — kama neno tayari lipo, chukua idadi yake; kama halipo, chukua 0. Kisha ongeza 1, na weka tena."

Hatua 5 — Sets

mahudhurio = ["Amina", "Juma", "Amina", "Neema", "Juma", "Ali"]
wa_kipekee = set(mahudhurio)
print(wa_kipekee)          # {'Juma', 'Ali', 'Amina', 'Neema'} (mpangilio unaweza kutofautiana)
print(len(wa_kipekee))     # 4

python_darasa = {"Amina", "Juma", "Neema"}
hisabati_darasa = {"Juma", "Ali", "Neema", "Zawadi"}
print(python_darasa | hisabati_darasa)   # wote (union)
print(python_darasa & hisabati_darasa)   # walio madarasa yote mawili: {'Juma', 'Neema'}
print(python_darasa - hisabati_darasa)   # wa Python tu: {'Amina'}

python_darasa.add("Baraka")
python_darasa.discard("Mtu_asiyekuwepo")   # haileti error
print("Amina" in python_darasa)            # True

tupu = {}
print(type(tupu))          # <class 'dict'>  ← si set!
tupu_set = set()
print(type(tupu_set))      # <class 'set'>

Hatua 6 — Nested: list ya dicts

wanafunzi = [
    {"jina": "Amina", "alama": [78, 85, 90]},
    {"jina": "Juma", "alama": [65, 70, 58]},
    {"jina": "Neema", "alama": [92, 88, 95]},
]

print(wanafunzi[0]["jina"])        # Amina
print(wanafunzi[2]["alama"][1])    # 88

for m in wanafunzi:
    wastani = sum(m["alama"]) / len(m["alama"])
    print(f"{m['jina']:<8} wastani: {wastani:.1f}")

wanafunzi.append({"jina": "Ali", "alama": [50, 61, 47]})
print("Idadi ya wanafunzi:", len(wanafunzi))

Amina
88
Amina    wastani: 84.3
Juma     wastani: 64.3
Neema    wastani: 91.7
Idadi ya wanafunzi: 4

Angalia: ndani ya f-string yenye "..." tumetumia m['jina'] (nukuu moja) — muhimu kwa Python 3.11 na chini. Python 3.12+ inaruhusu hata nukuu zile zile, lakini tabia hii ni salama zaidi.

Hatua 7 — Dict ya lists

masomo = {
    "Jumatatu": ["Hisabati", "Python"],
    "Jumatano": ["Kiingereza"],
}
masomo["Jumatano"].append("Python")
masomo["Ijumaa"] = ["Fizikia", "Python"]
for siku, orodha in masomo.items():
    print(f"{siku}: {', '.join(orodha)}")

Jumatatu: Hisabati, Python
Jumatano: Kiingereza, Python
Ijumaa: Fizikia, Python

Maswali ya kumuuliza mwanafunzi

1. Kwa phonebook (jina → namba), utatumia muundo gani? — Jibu: dict.
2. Tofauti ya d["x"] na d.get("x") key isipokuwepo? — Jibu: ya kwanza KeyError; ya pili None.
3. {} ni set au dict? — Jibu: dict tupu. Set tupu ni set().
4. Utaondoaje marudio kwenye list? — Jibu: list(set(l)) (lakini mpangilio unaweza kupotea).
5. Unafikiaje alama ya kwanza ya mwanafunzi wa pili kwenye wanafunzi? — Jibu: wanafunzi[1]["alama"][0].
6. Kwa siku za wiki (hazibadiliki) utatumia nini? — Jibu: tuple.
7. Kwa nini list haiwezi kuwa key ya dict? — Jibu: Kwa sababu inabadilika (mutable/unhashable); tumia tuple.

Makosa ya kawaida

Zoezi darasani

1. Tengeneza phonebook (dict) ya watu 3. Uliza jina; onyesha namba au "Hayupo".
2. Hesabu herufi kwenye neno "mississippi" kwa dict (counting pattern).
3. Una orodha_a = ["Amina", "Juma", "Ali"] na orodha_b = ["Ali", "Neema", "Juma"]. Onyesha waliopo kwenye orodha zote mbili, na wote bila marudio.
4. Kwa list ya dicts wanafunzi (Hatua 6), chapisha jina la mwanafunzi mwenye wastani mkubwa zaidi.

# zoezi 1
simu = {"Amina": "0712000111", "Juma": "0754222333", "Neema": "0688444555"}
jina = input("Jina: ").strip().title()
print(simu.get(jina, "Hayupo"))

# zoezi 2
hesabu = {}
for h in "mississippi":
    hesabu[h] = hesabu.get(h, 0) + 1
print(hesabu)     # {'m': 1, 'i': 4, 's': 4, 'p': 2}

# zoezi 3
a = set(["Amina", "Juma", "Ali"])
b = set(["Ali", "Neema", "Juma"])
print("Kwenye zote:", a & b)      # {'Juma', 'Ali'}
print("Wote:", a | b)             # {'Amina', 'Juma', 'Ali', 'Neema'}

# zoezi 4
wanafunzi = [
    {"jina": "Amina", "alama": [78, 85, 90]},
    {"jina": "Juma", "alama": [65, 70, 58]},
    {"jina": "Neema", "alama": [92, 88, 95]},
]
bora = None
bora_wastani = -1
for m in wanafunzi:
    w = sum(m["alama"]) / len(m["alama"])
    if w > bora_wastani:
        bora_wastani = w
        bora = m["jina"]
print(f"Bora: {bora} ({bora_wastani:.1f})")    # Bora: Neema (91.7)

Kazi ya Nyumbani

KN1 (baada ya Kipindi 1, leta Kipindi 2): orodha_manunuzi.py — programu inayomruhusu mtumiaji kuongeza bidhaa kwenye list mpaka aandike "mwisho" (bila kurudia bidhaa iliyopo — tumia in). Mwishoni onyesha orodha iliyopangwa na idadi ya bidhaa.

KN2 (baada ya Kipindi 2, leta Kipindi 3): takwimu.py — uliza namba zilizotenganishwa kwa nafasi (mf. 4 8 15 16 23 42). Bila kutumia sum/max/min, kwa loop, hesabu jumla, kubwa, ndogo, na wastani. Kisha tengeneza list ya namba zilizo juu ya wastani. Rudisha kubwa na ndogo kama tuple (ndogo, kubwa) na uichapishe.

KN3 (baada ya Kipindi 3, leta kipindi kijacho): kamusi.py — kamusi ndogo ya Kiswahili→Kiingereza (maneno 5+). Menyu kwenye while True: 1) Tafsiri neno, 2) Ongeza neno jipya, 3) Onyesha maneno yote (yamepangwa), 4) Toka. Bonus: hesabu ni maneno mangapi yametafutwa ambayo hayapo (tumia set kuhifadhi maneno hayo bila marudio).

# orodha_manunuzi.py
orodha = []
while True:
    bidhaa = input("Bidhaa (au 'mwisho'): ").strip().lower()
    if bidhaa == "mwisho":
        break
    if bidhaa == "":
        continue
    if bidhaa in orodha:
        print(f"'{bidhaa}' tayari iko kwenye orodha.")
    else:
        orodha.append(bidhaa)
orodha.sort()
print("Orodha yako:")
for i, b in enumerate(orodha, start=1):
    print(f"{i}. {b}")
print("Idadi:", len(orodha))

# takwimu.py
vipande = input("Namba (tenganisha kwa nafasi): ").split()
namba = []
for v in vipande:
    namba.append(float(v))

jumla = 0
kubwa = namba[0]
ndogo = namba[0]
for n in namba:
    jumla += n
    if n > kubwa:
        kubwa = n
    if n < ndogo:
        ndogo = n
wastani = jumla / len(namba)
juu_ya_wastani = [n for n in namba if n > wastani]
mipaka = (ndogo, kubwa)

print("Jumla:", jumla)
print("Wastani:", round(wastani, 2))
print("Juu ya wastani:", juu_ya_wastani)
print("(ndogo, kubwa):", mipaka)
# 4 8 15 16 23 42 -> Jumla 108.0, Wastani 18.0, Juu: [23.0, 42.0], (4.0, 42.0)

# kamusi.py
kamusi = {
    "maji": "water",
    "chakula": "food",
    "nyumba": "house",
    "rafiki": "friend",
    "shule": "school",
}
hayapo = set()

while True:
    print("\n1) Tafsiri  2) Ongeza  3) Onyesha yote  4) Toka")
    chaguo = input("Chagua: ").strip()
    if chaguo == "1":
        neno = input("Neno la Kiswahili: ").strip().lower()
        if neno in kamusi:
            print(f"{neno} = {kamusi[neno]}")
        else:
            print("Neno hilo halipo.")
            hayapo.add(neno)
    elif chaguo == "2":
        sw = input("Kiswahili: ").strip().lower()
        en = input("Kiingereza: ").strip().lower()
        kamusi[sw] = en
        hayapo.discard(sw)
        print("Limeongezwa!")
    elif chaguo == "3":
        for sw in sorted(kamusi):
            print(f"{sw:<10} -> {kamusi[sw]}")
    elif chaguo == "4":
        print(f"Maneno {len(hayapo)} yalitafutwa bila kupatikana: {hayapo}")
        print("Kwaheri!")
        break
    else:
        print("Chaguo si sahihi.")

Ukiulizwa swali usilolijua

• Kwenye REPL andika help(list) au dir(dict) kuona methods zote — hiyo ni njia rasmi ya "kuuliza Python yenyewe". Pia help(list.insert).
• Tafuta: "python list vs tuple", "python dictionary get default", "python set operations".
• Docs: https://docs.python.org/3/tutorial/datastructures.html , https://docs.python.org/3/library/stdtypes.html#mapping-types-dict , https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset

Checklist ya mwisho wa wiki

• Anatengeneza list, anatumia index/slicing, na anabadilisha kipengele
• Anatumia append, insert, extend, remove, pop, sort
• Anajua tofauti ya sort() na sorted() (na mtego wa l = l.sort())
• Anaelewa b = a dhidi ya a.copy()
• Anaandika patterns za accumulate, filter, transform kwa for
• Anatumia enumerate na split/join
• Anajua tuple ni immutable, anafanya unpacking, na anajua (5,)
• Anatumia dict: kusoma, .get(), kuongeza, kufuta, .items()
• Anaandika counting pattern kwa dict
• Anatumia set kuondoa marudio na | & -; anajua set() si {}
• Anafikia data ndani ya list ya dicts (l[0]["jina"])
• Anaweza kueleza lini kutumia list, tuple, dict, au set