# Karatasi ya kudanganya ya Python: sintaksia, amri na kazi zilizojengwa ndani kwenye majedwali

URL: https://skillaria.top/sw/guides/python/karatasi-ya-kudanganya-python

Sintaksia ya Python inategemea kujongea badala ya mabano ya mikunjo: kizuizi kinachofuata koloni kinasogezwa kwa nafasi 4. Msingi ni vigezo bila kutangaza aina, masharti ya if/elif/else, mizunguko for na while, kazi def, na kazi zilizojengwa ndani kama print, len, range, input, type, pamoja na mbinu za nyuzi, orodha na kamusi.

Karatasi hii ya kudanganya ya Python inakusanya kwenye ukurasa mmoja kila kitu unachohitaji kuwa nacho karibu katika miezi ya kwanza: sintaksia ya Python, mizunguko, kazi zilizojengwa ndani, mbinu za nyuzi, orodha na kamusi, na amri za terminal. Kila jedwali ni marejeo mafupi yenye mifano inayofanya kazi, ambayo unaweza kuiweka moja kwa moja kwenye REPL.

## Misingi ya sintaksia ya Python

Kipengele kikuu cha lugha ni kwamba vizuizi vinaelezwa kwa kujongea, si kwa mabano. Baada ya mstari wenye koloni (`if`, `for`, `def`, `class`) mistari inayofuata inasogezwa kwa nafasi 4. Kuchanganya tabu na nafasi hakuruhusiwi — utapata `IndentationError`.

| Muundo | Mfano | Maelezo |
| --- | --- | --- |

| Maoni | `# maandishi` | kila kilicho baada ya # hadi mwisho wa mstari hupuuzwa |

| Kigezo | `age = 25` | aina haitangazwi, inaamuliwa na thamani |

| Upeanaji wa mara nyingi | `a, b = 1, 2` | kufungua (unpacking); kubadilishana thamani: `a, b = b, a` |

| Kuchapisha | `print("Habari", name)` | hoja zinatenganishwa kwa nafasi |

| Kuingiza | `s = input("Jina: ")` | daima hurudisha nyuzi |

| F-string | `f"{name}: {price:.2f}"` | kuingiza misemo na muundo wa kuonyesha |

| Alama ya aina | `count: int = 0` | dokezo kwa IDE na wakaguzi, halikaguliwi wakati wa kuendesha |

| Kizuizi tupu | `pass` | kishikilia nafasi pale sintaksia inahitaji mwili |

| Uagizaji | `from math import sqrt` | kuunganisha moduli au jina kutoka ndani yake |

### Aina za data

| Aina | Literali | Inaweza kubadilishwa |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | hapana |

| `float` | `3.14`, `1e-3` | hapana |

| `bool` | `True`, `False` | hapana |

| `str` | `"maandishi"`, `'maandishi'`, `"""mistari mingi"""` | hapana |

| `list` | `[1, 2, 3]` | ndiyo |

| `tuple` | `(1, 2)`, `(1,)` | hapana |

| `dict` | `{"a": 1}` | ndiyo |

| `set` | `{1, 2}`, tupu — `set()` | ndiyo |

| `NoneType` | `None` | — |

### Waendeshaji

| Kundi | Waendeshaji | Mfano → matokeo |
| --- | --- | --- |

| Hesabu | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Ulinganisho | `== != < > <= >=` | `1 < x < 10` — mnyororo wa ulinganisho |

| Mantiki | `and or not` | `x or "chaguo-msingi"` |

| Umiliki | `in`, `not in` | `"a" in "abc"` → True |

| Utambulisho | `is`, `is not` | `x is None` |

| Upeanaji | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Masharti na ulinganishaji

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "mtu mzima" if age >= 18 else "mtoto"   # opereta wa masharti

match command:
    case "start":
        print("Inaanza")
    case "stop" | "exit":
        print("Inasimama")
    case _:
        print("Amri isiyojulikana")
```

Thamani za uongo ni `False`, `None`, `0`, nyuzi tupu na makusanyo matupu, kwa hiyo badala ya `if len(items) > 0` wanaandika tu `if items`.

## Mizunguko katika Python: sintaksia ya for na while

### Mzunguko wa for

Sintaksia ya mzunguko wa for katika Python: `for kigezo in mfuatano:` na mwili uliojongezwa. Mzunguko unapitia kitu chochote kinachoweza kurudiwa — nyuzi, orodha, kamusi, faili, `range`.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["tufaha", "peari"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### Mzunguko wa while

```
attempts = 3
while attempts > 0:
    password = input("Nenosiri: ")
    if password == "secret":
        print("Umeingia")
        break
    attempts -= 1
else:
    print("Majaribio yameisha")   # hutekelezwa ikiwa hapakuwa na break
```

| Amri | Inafanya nini |
| --- | --- |

| `break` | kutoka kwenye mzunguko kabla ya wakati |

| `continue` | nenda kwenye marudio yanayofuata |

| `else` ya mzunguko | hutekelezwa ikiwa mzunguko umemalizika bila `break` |

| `range(stop)`, `range(start, stop, step)` | mfuatano wa namba, `stop` haijumuishwi |

### Orodha za kutengeneza (comprehensions)

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # usemi wa jenereta
```

## Kazi

```
def greet(name: str, greeting: str = "Habari") -> str:
    """Inarudisha salamu."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Amina"))                 # Habari, Amina!
print(greet("Amina", greeting="Hujambo"))  # Hujambo, Amina!
```

| Kipengele | Maana |
| --- | --- |

| `def f(a, b=1)` | kigezo chenye thamani ya chaguo-msingi |

| `*args` | idadi yoyote ya hoja za nafasi (tuple) |

| `**kwargs` | idadi yoyote ya hoja zenye majina (kamusi) |

| `return` | kurudisha thamani; bila hiyo kazi itarudisha `None` |

| `lambda x: ...` | kazi fupi isiyo na jina, ya usemi mmoja |

| `global`, `nonlocal` | kubadilisha kigezo kutoka eneo la nje |

Usitumie thamani ya chaguo-msingi inayoweza kubadilika kama `def f(items=[])`: orodha inaundwa mara moja tu na inakusanyika kati ya miito. Njia sahihi ni `items=None` na ndani yake `if items is None: items = []`.

## Kazi zilizojengwa ndani za Python

Kazi zilizojengwa ndani za Python zinapatikana bila uagizaji. Hizi ni kazi kuu zinazoonekana karibu kila script.

| Kazi | Inafanya nini | Mfano → matokeo |
| --- | --- | --- |

| `print()` | inaonyesha thamani | `print(1, 2, sep="-")` → 1-2 |

| `input()` | inasoma mstari kutoka kibodi | `int(input())` |

| `len()` | urefu wa kontena au nyuzi | `len("abc")` → 3 |

| `type()` | aina ya kitu | `type(3.0)` → <class 'float'> |

| `isinstance()` | kukagua aina | `isinstance(5, int)` → True |

| `int() float() str() bool()` | kubadilisha aina | `int("42")` → 42 |

| `list() tuple() set() dict()` | kuunda makusanyo | `list("ab")` → ['a', 'b'] |

| `range()` | safu ya namba | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | jozi (faharasa, kipengele) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | inaunganisha mfuatano jozi kwa jozi | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | jumla, kiwango cha chini, cha juu | `max([3, 7, 1])` → 7 |

| `abs() round()` | thamani kamili na kuzungusha | `round(3.14159, 2)` → 3.14 |

| `sorted()` | orodha mpya iliyopangwa | `sorted(words, key=len, reverse=True)` |

| `reversed()` | kirudiaji kwa mpangilio wa nyuma | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | kutumia kazi / kuchuja | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | angalau moja / zote ni kweli | `all(x > 0 for x in nums)` |

| `open()` | inafungua faili | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | msaada na orodha ya sifa | `help(str.split)`, `dir(list)` |

| `id() hash()` | kitambulisho na hash ya kitu | `hash("a")` |

Kitabu bora cha marejeo kiko nawe kila wakati — kazi `help()` kwenye REPL: `help(dict)` itaonyesha mbinu zote za kamusi pamoja na maelezo, na `dir(obj)` — orodha ya majina yanayopatikana.

## Mbinu za nyuzi

Sintaksia ya nyuzi za Python: nyuzi haibadiliki, na kila mbinu inarudisha nyuzi mpya. Kukata (slices) kunafanya kazi kama kwenye orodha: `s[1:4]`, `s[::-1]` — kugeuza.

| Mbinu | Mfano → matokeo |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"bata".replace("b", "k")` → 'kata' |

| `find() index()` | `"hello".find("l")` → 2; ikiwa haipo — -1 (kwa `index` — kosa) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Amri za orodha ya Python

Orodha ni kontena linaloweza kubadilishwa na lenye mpangilio. Mbinu nyingi zinabadilisha orodha papo hapo na kurudisha `None`, kwa hiyo `a = a.sort()` ni kosa la kawaida.

| Operesheni | Inafanya nini | Mfano |
| --- | --- | --- |

| `append(x)` | inaongeza mwishoni | `a.append(4)` |

| `extend(iter)` | inaongeza vipengele vyote | `a.extend([5, 6])` |

| `insert(i, x)` | inaingiza kwa faharasa | `a.insert(0, "first")` |

| `remove(x)` | inafuta mara ya kwanza thamani inapotokea | `a.remove(3)` |

| `pop(i)` | inafuta na kurudisha kipengele (chaguo-msingi la mwisho) | `last = a.pop()` |

| `clear()` | inafuta orodha yote | `a.clear()` |

| `index(x)` | faharasa ya mara ya kwanza | `a.index("b")` |

| `count(x)` | idadi ya marudio | `a.count(1)` |

| `sort()` | inapanga papo hapo | `a.sort(key=str.lower)` |

| `reverse()` | inageuza papo hapo | `a.reverse()` |

| `copy()` | nakala ya juu juu | `b = a.copy()` |

| `del a[i]` | kufuta kwa faharasa au kukata | `del a[1:3]` |

| Kukata | `a[start:stop:step]` | `a[-1]` — la mwisho, `a[:3]` — tatu za kwanza |

## Amri za kamusi ya Python

| Operesheni | Inafanya nini | Mfano |
| --- | --- | --- |

| `d[key]` | thamani kwa ufunguo, ikiwa hakuna — `KeyError` | `d["name"]` |

| `get(key, default)` | thamani au ya akiba | `d.get("age", 0)` |

| `d[key] = value` | kuongeza au kubadilisha | `d["city"] = "Arusha"` |

| `keys() values() items()` | funguo, thamani, jozi | `for k, v in d.items():` |

| `update()` | kuunganisha na kamusi nyingine | `d.update({"a": 1})` |

| `d1 | d2` | kamusi mpya iliyounganishwa | `merged = defaults | user` |

| `pop(key, default)` | kufuta na kurudisha thamani | `d.pop("tmp", None)` |

| `popitem()` | kufuta jozi iliyoongezwa mwisho | `d.popitem()` |

| `setdefault(key, value)` | kurudisha thamani, na ikiwa ufunguo haupo — kuuunda | `d.setdefault("tags", []).append("py")` |

| `key in d` | kukagua kama ufunguo upo | `if "name" in d:` |

| `dict.fromkeys()` | kamusi kutoka funguo zenye thamani moja | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | ukubwa na kufuta | `del d["old"]` |

### Tuple na seti

| Operesheni | Mfano → matokeo |
| --- | --- |

| Kufungua tuple | `x, y = (3, 4)` |

| Kuongeza kwenye seti | `s.add(5)`, kufuta — `s.discard(5)` |

| Muungano / makutano | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Tofauti | `{1, 2} - {2}` → {1} |

| Kuondoa marudio kwenye orodha | `list(dict.fromkeys(items))` — pamoja na kuhifadhi mpangilio |

## Vighairi na mafaili

```
try:
    number = int(input("Namba: "))
except ValueError as err:
    print("Hii si namba:", err)
else:
    print("Imefanikiwa")
finally:
    print("Inatekelezwa kila wakati")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("mstari\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| Kighairi | Kinatokea lini |
| --- | --- |

| `SyntaxError`, `IndentationError` | kosa katika sintaksia au kujongea |

| `NameError` | jina halijafafanuliwa (kosa la kuandika) |

| `TypeError` | operesheni yenye aina isiyofaa: `"1" + 1` |

| `ValueError` | aina sahihi, lakini thamani si sahihi: `int("abc")` |

| `IndexError`, `KeyError` | hakuna faharasa au ufunguo kama huo |

| `FileNotFoundError` | faili halikupatikana |

| `ZeroDivisionError` | kugawanya kwa sifuri |

## Madarasa

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: Wau!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Fifi").bark())    # Fifi: Wau!
print(Point(1, 2))           # Point(x=1, y=2)
```

## Moduli zilizojengwa ndani za Python

Maktaba ya kawaida inakuja pamoja na mkalimani — inatosha kufanya `import`.

| Moduli | Kwa nini | Mfano |
| --- | --- | --- |

| `math` | hisabati | `math.sqrt(16)` → 4.0 |

| `random` | namba za kubahatisha | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | tarehe na wakati | `datetime.date.today()` |

| `pathlib` | njia na mafaili | `Path("data").glob("*.csv")` |

| `os`, `sys` | mfumo, vigezo vya mazingira, hoja | `os.environ.get("HOME")`, `sys.argv` |

| `json` | kusoma na kuandika JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | jedwali za CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | mchanganyiko na minyororo ya virudiaji | `itertools.chain(a, b)` |

| `re` | misemo ya kawaida (regular expressions) | `re.findall(r"\d+", s)` |

| `time` | kusitisha na kupima muda | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | msimbo wa usawazishaji | `asyncio.run(main())` |

Katika Python 3.15 kuna lazy import (PEP 810): `lazy import pandas as pd` huahirisha upakiaji wa moduli hadi itakapotumika kwa mara ya kwanza, na script yenye utegemezi mzito huanza kwa kasi zaidi.

## Amri za Python kwenye terminal

Kundi tofauti la maswali «amri za python» ni amri za kuendesha mkalimani na kusakinisha maktaba. Kwenye Windows badala ya `python3` kwa kawaida huandikwa `python` au `py`.

| Amri | Inafanya nini |
| --- | --- |

| `python3 --version` | kuonyesha toleo |

| `python3` | kufungua kiweko shirikishi REPL (kutoka — `exit()`) |

| `python3 script.py` | kuendesha faili |

| `python3 -c "print(2 + 2)"` | kutekeleza mstari mmoja |

| `python3 -m venv .venv` | kuunda mazingira pepe |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | kuwasha mazingira (Linux, macOS / Windows) |

| `python3 -m pip install requests` | kusakinisha kifurushi |

| `pip list`, `pip freeze > requirements.txt` | orodha ya vifurushi na kuvihifadhi |

| `pip install -r requirements.txt` | kusakinisha utegemezi kutoka faili |

| `python3 -m http.server 8000` | seva rahisi ya wavuti kwenye folda ya sasa |

| `uv init`, `uv add requests`, `uv run main.py` | mradi, utegemezi na kuendesha kupitia kidhibiti uv |

## Makosa ya kawaida ya wanaoanza

- **Kulinganisha kwa `=`** — katika sharti inahitajika `==`; `=` moja ni upeanaji.
- **Koloni lililosahauliwa** baada ya `if`, `for`, `def` linatoa `SyntaxError`.
- **Kujumlisha nyuzi na namba**: `"Umri: " + 25` ni kosa, andika `f"Umri: {25}"`.
- **Kubadilisha orodha wakati wa kuizungusha** — pitia nakala `for x in a[:]` au jenga orodha mpya.
- **`input()` hurudisha nyuzi** — kwa hesabu funga kwenye `int()` au `float()`.

## Hitimisho

Sintaksia ya Python inategemea kujongea, koloni na seti ndogo ya miundo: masharti, mizunguko ya for na while, kazi, madarasa. Ongeza kwao kazi kadhaa zilizojengwa ndani na mbinu za nyuzi, orodha na kamusi — utamaliza sehemu kubwa ya kazi za kila siku. Hifadhi karatasi hii, na mambo haya yakishakuwa ya kawaida, endelea na moduli na usawazishaji; yote haya yanafafanuliwa kwa hatua kwa vitendo katika kozi «Python 3.15: kutoka mwanzoni hadi mtaalamu».

## FAQ

**Ni nafasi ngapi za kujongea katika Python?**

Kwa kiwango cha PEP 8 — nafasi 4 kwa kila ngazi. Muhimu ni kuwa sawa katika kizuizi chote na kutochanganya na tabu.

**Orodha inatofautianaje na tuple?**

Orodha inaweza kubadilishwa, unaweza kuiongezea na kuipanga papo hapo; tuple haibadiliki, kwa hiyo inafaa kama ufunguo wa kamusi na kwa seti za thamani zisizobadilika.

**Ninawezaje kuona mbinu zote za kitu moja kwa moja kwenye Python?**

Ita dir(obj) kwa orodha ya majina na help(obj) kwa maelezo — kwa mfano help(str) itaonyesha mbinu zote za nyuzi.

**Kuna tofauti gani kati ya sort() na sorted()?**

Mbinu list.sort() inapanga orodha yenyewe na kurudisha None, wakati kazi sorted() inarudisha orodha mpya na inafanya kazi na mkusanyiko wowote unaoweza kurudiwa.

**Je, mstari unahitaji nukta-koma mwishoni?**

Hapana. Nukta-koma inaruhusiwa kwa amri kadhaa kwenye mstari mmoja, lakini kwenye msimbo wa kawaida kila amri inaandikwa kwenye mstari wake.


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