# Orodha (list) katika Python: mbinu, slices, kupanga, append, tuple na seti

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

Orodha (list) katika Python ni mkusanyiko uliopangwa unaoweza kubadilishwa wa thamani zozote kwenye mabano ya mraba, kwa mfano [250, 1200, 99]: vipengele vinaweza kuongezwa kwa append, kuingizwa, kufutwa, kukatwa kwa slices na kupangwa. Mbinu sort hupanga orodha papo hapo na kurudisha None, wakati kazi sorted hurudisha orodha mpya iliyopangwa.

Orodha katika Python (`list`) ni mkusanyiko uliopangwa wa thamani zozote kwenye mabano ya mraba, ambao unaweza kubadilishwa: kuongeza vipengele mwishoni, kuingiza katikati, kufuta na kupanga. Ni mkusanyiko unaotumika zaidi katika lugha: mistari ya faili, matumizi ya mwezi, majibu ya API — karibu kila kitu huanza kama orodha. Hebu tuchunguze python list kwa ukamilifu: kuunda, mbinu, slices, kupanga, list comprehensions, kunakili, na mwisho tuple na seti.

## Orodha ni nini katika Python

Orodha huhifadhi vipengele kwa mpangilio uliouweka, na kuvifikia kwa faharasa kuanzia sifuri. Orodha moja inaweza kuwa na thamani za aina tofauti, ingawa kwa vitendo kwa kawaida huhifadhi data za aina moja.

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — kipengele cha kwanza
print(amounts[-1])    # 99 — cha mwisho
amounts[1] = 1300     # orodha inaweza kubadilishwa
print(len(amounts))   # 3 — urefu wa orodha
```

Ukubwa wa orodha hupatikana kwa kazi `len()`. Kufikia faharasa isiyokuwepo kutatoa `IndexError: list index out of range`.

## Kuunda orodha

```
empty = []                       # orodha tupu
also_empty = list()              # sawa, kwa kazi list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]
```

Kazi `list()` hugeuza kitu chochote kinachoweza kupitiwa kuwa orodha: mfuatano, `range`, seti, funguo za kamusi.

## append na mbinu nyingine za orodha

Mbinu `append` huongeza kipengele kimoja mwishoni mwa orodha — ndiyo mbinu inayotumika zaidi katika Python. Hubadilisha orodha papo hapo na kurudisha `None`.

```
amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # ondoa thamani ya kwanza ya 1200
last = amounts.pop()         # 20 — ondoa na urudishe la mwisho
```

Kosa la kawaida: `a.append([10, 20])` huongeza kipengele kimoja — orodha ndogo ndani ya orodha, si namba mbili. Kwa vipengele kadhaa unahitaji `extend`.

| Mbinu | Inafanya nini |
| --- | --- |

| `append(x)` | kuongeza x mwishoni |

| `extend(iter)` | kuongeza vipengele vyote vya mfuatano |

| `insert(i, x)` | kuingiza x kabla ya faharasa i |

| `remove(x)` | kufuta mara ya kwanza ya x (ValueError kisipokuwepo) |

| `pop(i=-1)` | kufuta na kurudisha kipengele kwa faharasa |

| `index(x)` | faharasa ya mara ya kwanza ya x |

| `count(x)` | x inajitokeza mara ngapi |

| `sort()` | kupanga papo hapo |

| `reverse()` | kugeuza papo hapo |

| `copy()` | nakala ya juu juu (shallow copy) |

| `clear()` | kufuta orodha yote |

Kipengele kwa faharasa au kipande kizima pia kinaweza kufutwa kwa kauli `del`: `del a[0]`, `del a[1:3]`. Kazi zilizojengwa ndani zinazofaa kwa orodha: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`.

## Slices katika Python

Slice huchukua sehemu ya orodha kwa muundo `a[start:stop:step]`: kuanzia `start` ikijumuishwa hadi `stop` isiyojumuishwa, kwa hatua `step`. Sehemu yoyote inaweza kuachwa. Slice daima hurudisha orodha mpya.

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — mbili za kwanza
print(a[-2:])     # [4, 5] — mbili za mwisho
print(a[::2])     # [0, 2, 4] — kila ya pili
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — iliyogeuzwa
print(a[:])       # nakala ya orodha nzima
```

Tofauti na faharasa, slice nje ya mipaka haitoi kosa: `a[10:20]` itarudisha tu `[]`. Slice pia inaweza kupewa thamani na kubadilisha kipande cha orodha: `a[1:3] = ["x", "y", "z"]`.

### Slice ya mfuatano

Slices hufanya kazi kwa njia ile ile kwa mfuatano wowote, ikiwemo mifuatano ya herufi na tuple:

```
s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP
```

Mfuatano hauwezi kubadilishwa kwa slice — mifuatano haibadiliki, slice hutengeneza mfuatano mpya.

## Kupanga orodha: sort na sorted

Hapa ndipo wanaoanza wanapochanganyikiwa zaidi. Mbinu `sort` hupanga vipengele ndani ya orodha yenyewe na kurudisha `None`. Kazi `sorted` haigusi orodha ya awali na inarudisha orodha mpya iliyopangwa.

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — nakala mpya
print(amounts)             # [250, 1200, 99, 450] — ya awali bado ipo

result = amounts.sort()    # inapanga papo hapo
print(result, amounts)     # None [99, 250, 450, 1200]
```

Hapa ndipo kosa maarufu la "kwa nini nina None" linapotokea: `a = a.sort()` inaifuta orodha na thamani `None`. Andika ama `a.sort()`, au `a = sorted(a)`.

### Ufunguo na mpangilio wa kinyume

Njia zote mbili zinakubali vigezo `key` na `reverse`. `key` ni kazi ambayo matokeo yake hutumika kulinganisha vipengele.

```
words = ["kahawa", "Teksi", "usajili"]
print(sorted(words, key=len))               # ['Teksi', 'kahawa', 'usajili']
print(sorted(words, key=str.lower))         # bila kujali herufi kubwa/ndogo
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Chakula", 650), ("Sinema", 120), ("Teksi", 300)]
expenses.sort(key=lambda e: e[1])           # kwa kiasi
```

Kupanga katika Python ni thabiti (stable): vipengele vyenye ufunguo sawa huhifadhi mpangilio wao wa awali. Tofauti nyingine ni wigo wa matumizi: `sorted` hukubali mkusanyiko wowote unaoweza kupitiwa (mfuatano, kamusi, seti), wakati `sort` ipo kwenye orodha pekee.

## Kugeuza orodha

Njia tatu zenye tabia tofauti:

- `a.reverse()` — hugeuza papo hapo, hurudisha `None`;
- `a[::-1]` — orodha mpya iliyogeuzwa;
- `reversed(a)` — iterator ya uvivu, kinafaa katika mzunguko: `for x in reversed(a):`.

## Kupitia orodha

```
items = ["kahawa", "daladala", "sinema"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 kahawa, 2 daladala, 3 sinema

print("sinema" in items)    # True — kukagua kama ipo
```

Usifute vipengele kutoka kwenye orodha inayopitiwa na mzunguko — baadhi ya vipengele vitaruka. Jenga orodha mpya kwa list comprehension, au pitia nakala `a[:]`.

## List comprehension

List comprehension hujenga orodha mpya kwa mstari mmoja: usemi, mzunguko, na sharti la hiari.

```
squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" amina ", "juma"]]
```

List comprehensions kwa kawaida ni haraka na zinasomeka zaidi kuliko mzunguko wenye `append`. Lakini mantiki isipoingia kwenye mstari mmoja unaoeleweka, mzunguko wa kawaida ni bora.

## Kuunganisha, kujumlisha na kutoa orodha

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — orodha mpya
a += b             # sawa na a.extend(b)
print([*a, *b])    # kufungua vipengele kwenye orodha mpya
```

Hakuna opereta ya `-` kwa kutoa orodha. Ili kuondoa kutoka orodha moja vipengele vya nyingine, tumia comprehension: `[x for x in a if x not in set(b)]`. Muingiliano wa orodha ni rahisi kupata kupitia seti: `set(a) & set(b)` (mpangilio na marudio hupotea katika hali hii).

## Orodha zilizoingiana na za pande mbili

Orodha ya orodha ni njia rahisi ya kuhifadhi jedwali au matrix:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # sahihi
bad = [[0] * 3] * 2                  # mtego: marejeo mawili kwa orodha moja
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## Kufungua orodha (unpacking)

```
first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print ya orodha bila mabano
```

Idadi ya vigezo isipolingana na urefu wa orodha, utapata `ValueError` — nyota huokoa hali hiyo.

## Kunakili orodha

`b = a` hainakili orodha, bali inaweka lebo ya pili kwenye kitu kile kile: mabadiliko kupitia `b` yanaonekana kwenye `a`. Nakala huru hufanywa waziwazi: `a.copy()`, `list(a)` au `a[:]`. Kwa data zilizoingiana hiyo haitoshi — orodha za ndani zitabaki zikishirikiwa, na inahitajika `copy.deepcopy(a)`.

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — orodha ya ndani inashirikiwa
c = copy.deepcopy(a)     # nakala huru kabisa
```

## Tuple: orodha isiyobadilika

Tuple (`tuple`) inafanana na orodha, lakini baada ya kuundwa haiwezi kubadilishwa. Ni ishara ya wazi kwa msomaji: mbele yako kuna rekodi moja yenye sehemu zisizobadilika, si mkusanyiko unaokua. Tuple hufunguliwa kwa urahisi, na ndizo kazi hutumia kurudisha thamani kadhaa.

```
expense = (250, "Kahawa")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment
```

Tuple yenye thamani zisizobadilika inaweza kuhashiwa (hashable), kwa hiyo inafaa kuwa ufunguo wa kamusi. Tuple yenye kipengele kimoja huandikwa kwa koma: `(5,)`.

## Seti: za kipekee tu

Seti (`set`) huhifadhi thamani za kipekee tu na haikumbuki mpangilio. Ndiyo njia ya haraka zaidi ya kuondoa marudio na kukagua "je, kipengele hiki kipo", na pia inashughulikia muingiliano, muungano na tofauti.

```
jan = {"Chakula", "Teksi", "Sinema"}
feb = {"Chakula", "Usajili"}
print(jan & feb)    # {'Chakula'}
print(feb - jan)    # {'Usajili'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — bila marudio, mpangilio umehifadhiwa
empty = set()       # {} ni kamusi tupu!
```

## Ni mkusanyiko gani uchague

| Kazi | Mkusanyiko |
| --- | --- |

| Mpangilio na mabadiliko | `list` |

| Rekodi isiyobadilika | `tuple` |

| Utafutaji kwa ufunguo | `dict` |

| Upekee, kukagua "kama kipo" | `set` |

| Mipangilio isiyobadilika | `frozendict` (Python 3.15) |

Ukaguzi wa `x in list` hupitia vipengele moja baada ya jingine, wakati `x in set` hufanya kazi karibu papo hapo. Ukiwa na mzunguko unaokagua mara nyingi kuwepo kwa thamani kwenye orodha kubwa, igeuze kuwa seti.

## Hitimisho

List ya Python ni mkusanyiko uliopangwa unaoweza kubadilishwa: `append` na `extend` huongeza, `pop` na `remove` hufuta, slices `a[start:stop:step]` hukata sehemu, `sort` hupanga papo hapo na kurudisha `None`, na `sorted` hutoa orodha mpya. Nakala fanya waziwazi, kwa rekodi zisizobadilika chagua tuple, na kwa thamani za kipekee chagua seti. Orodha, tuple, kamusi na seti vimefafanuliwa kwa vitendo katika kozi ya "Python 3.15: kutoka mwanzo hadi mtaalamu".

## FAQ

**Orodha katika Python inatofautianaje na array?**

Hakuna array iliyojengwa ndani kwa maana ya lugha nyingine; nafasi yake inachukuliwa na orodha, ambayo inaweza kuhifadhi thamani za aina tofauti. Kwa safu za namba zilizoshikana kuna moduli array na maktaba ya NumPy.

**Ninawezaje kupata faharasa ya kipengele kwenye orodha?**

Mbinu a.index(x) hurudisha faharasa ya mara ya kwanza na hutoa ValueError kisipokuwepo. Kwa hiyo kabla ya kuiita, kagua x in a.

**Ninawezaje kuondoa marudio kwenye orodha huku nikihifadhi mpangilio?**

Tumia list(dict.fromkeys(a)): kamusi huhifadhi funguo za kipekee kwa mpangilio wa kuingizwa. list(set(a)) pia huondoa marudio, lakini haihifadhi mpangilio.

**Ninawezaje kuunganisha orodha ya mifuatano kuwa mfuatano mmoja?**

Kwa mbinu ya mfuatano join: ", ".join(["a", "b", "c"]) inatoa "a, b, c". Vipengele vyote lazima viwe mifuatano; namba zibadilishwe kwanza kwa map(str, a).

**Je, naweza kuweka aina tofauti za thamani kwenye orodha moja?**

Ndiyo, orodha inaweza kuwa na namba, mifuatano, orodha nyingine na vitu vyovyote kwa pamoja. Lakini kupanga orodha kama hiyo bila parameta key kwa kawaida hakuwezekani — kulinganisha namba na mfuatano kutatoa TypeError.


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