# Mifuatano katika Python: split, replace, strip, join, slices na f-strings

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

Mfuatano (aina str) katika Python ni mfuatano usiobadilika wa herufi za Unicode. split() huigawanya kuwa orodha, join() huziunganisha tena, replace() hubadilisha sehemu ya maandishi, na strip() huondoa nafasi pembeni; kila mbinu hurudisha mfuatano mpya. Kuingiza thamani ni rahisi zaidi kwa f-string: f"{name}: {price:.2f}".

Mifuatano ya Python hupatikana katika kila programu: uingizaji wa mtumiaji, majina ya faili, mistari ya CSV, majibu ya API. Aina `str` huhifadhi maandishi kwa Unicode, kwa hiyo herufi za lugha nyingi na emoji hufanya kazi bila mipangilio ya ziada. Mbinu zinazotumika zaidi ni `split`, `replace`, `strip` na `join`, na kuonyesha thamani ni rahisi zaidi kwa f-strings. Hebu tuchambue yote kwa mifano.

## Mfuatano katika Python unavyofanya kazi

Mfuatano huandikwa kwa nukuu moja au mbili — hakuna tofauti: `'kahawa'` na `"kahawa"` ni sawa. Nukuu tatu huunda mfuatano wa mistari mingi, ambapo mivunjo ya mistari huhifadhiwa kama ilivyo.

```
name = "Kahawa"
note = """Mstari wa kwanza
Mstari wa pili"""
print(len(name))  # 6 — urefu wa mfuatano kwa herufi
```

Sifa kuu ya mifuatano ni kutobadilika. Mbinu haibadilishi mfuatano, bali hurudisha mpya. Kwa hiyo `s.replace("a", "b")` bila mgawo haitafanya chochote — lazima uandike `s = s.replace("a", "b")`. Hili ndilo kosa la kawaida zaidi kwa wanaoanza.

### Herufi maalum, mivunjo ya mistari na mifuatano ghafi

Mivunjo ya mistari huandikwa `\n`, tabo `\t`, na mstari wa nyuma `\\`. Kiambishi `r` hufanya mfuatano kuwa "ghafi": mistari ya nyuma haichakatwi ndani yake. Hii ni rahisi kwa njia za Windows na usemi wa kawaida (regular expressions).

```
print("Jumla:\n350 TSh")
path = r"C:\new\table.csv"   # \n na \t hazitageuka kuwa herufi maalum
```

Usemi mrefu unaweza kuvunjwa kwenda mstari unaofuata kwa kuufunga kwenye mabano: Python yenyewe huunganisha mifuatano ya nukuu iliyo karibu ndani ya mabano.

## split: kugawanya mfuatano kuwa orodha

Mbinu `split()` hugawanya mfuatano kwa kitenganishi na kurudisha orodha. Bila hoja hukata kwa alama yoyote ya nafasi na kupuuza nafasi zinazojirudia — ni rahisi kwa kuchambua amri.

```
"add  Kahawa 250".split()        # ['add', 'Kahawa', '250']
"2026-10-16".split("-")          # ['2026', '10', '16']
"a,b,,c".split(",")              # ['a', 'b', '', 'c']
"key=value=x".split("=", 1)      # ['key', 'value=x']
```

Angalia tofauti: kwa kitenganishi wazi, vipande tupu huhifadhiwa. Hoja ya pili `maxsplit` hupunguza idadi ya kukatwa, na `rsplit()` hukata kutoka kulia. Ili kugawanya maandishi kuwa mistari, tumia `splitlines()`: inaelewa `\n` na `\r\n`, na haiachi kipengele tupu mwishoni.

```
text = "kahawa\nteksi\n"
text.split("\n")     # ['kahawa', 'teksi', '']
text.splitlines()    # ['kahawa', 'teksi']
```

## join: kuunganisha orodha kuwa mfuatano

`join()` ni operesheni ya kinyume. Huitwa kwenye mfuatano wa kitenganishi, na hoja yake ni orodha ya mifuatano:

```
items = ["kahawa", "teksi", "chakula"]
print(", ".join(items))   # kahawa, teksi, chakula
print("\n".join(items))   # kila kipengele kwenye mstari wake
```

Vipengele vyote lazima viwe mifuatano, vinginevyo utapata `TypeError: sequence item 0: expected str instance, int found`. Namba zibadilishe kwanza: `", ".join(str(x) for x in amounts)`.

### Kuunganisha mifuatano

Mifuatano miwili inaweza kujumlishwa kwa `+`, na kurudiwa kwa `*`: `"-" * 20`. Lakini kuunganisha mamia ya vipande kwa `+=` ndani ya mzunguko ni polepole, kwa sababu kila mara mfuatano mpya unatengenezwa. Kusanya vipande kwenye orodha kisha uviunganishe kwa `join()` moja. Mfuatano na namba haviwezi kujumlishwa moja kwa moja: `"Jumla: " + 5` itasababisha `TypeError`; tumia `str()` au f-string.

## replace: kubadilisha sehemu ya mfuatano

`replace(old, new)` hubadilisha mara zote sehemu ndogo inayolingana. Hoja ya tatu inapunguza idadi ya mabadiliko.

```
price = "1 250,50"
price = price.replace(" ", "").replace(",", ".")
print(float(price))                  # 1250.5

"a-b-c".replace("-", "+", 1)         # 'a+b-c'
```

Mbinu hii inajali herufi kubwa/ndogo na inatafuta mlingano kamili. Kwa kubadilisha kwa muundo (kwa mfano "namba zote") unahitaji moduli `re` na kazi `re.sub()`.

## strip, lstrip, rstrip: kupunguza pembe za mfuatano

`strip()` huondoa nafasi, tabo na mivunjo ya mistari pande zote mbili. `lstrip()` husafisha upande wa kushoto tu, `rstrip()` upande wa kulia tu. Hiki ndicho cha kwanza kufanya na uingizaji wa mtumiaji na mistari kutoka faili.

```
raw = "  Kahawa \n"
raw.strip()       # 'Kahawa'
raw.rstrip()      # '  Kahawa'
"xxKahawaxx".strip("x")   # 'Kahawa'
```

Hoja inaonyesha seti ya herufi, si sehemu ndogo: `"abcMaandishicba".strip("abc")` itaondoa a, b na c zote kutoka pembeni kwa mpangilio wowote. Ili kukata kiambishi awali au kiambishi tamati hasa, tumia `removeprefix()` na `removesuffix()` (tangu Python 3.9).

## Mbinu nyingine muhimu za mifuatano

| Mbinu | Inafanya nini | Mfano → matokeo |
| --- | --- | --- |

| `lower()`, `upper()` | herufi kubwa/ndogo | `"Kahawa".lower()` → `'kahawa'` |

| `startswith()`, `endswith()` | kuangalia mwanzo na mwisho | `"a.csv".endswith(".csv")` → `True` |

| `find()` | nafasi ya sehemu ndogo au -1 | `"kahawa".find("w")` → `4` |

| `count()` | idadi ya mara zinazojitokeza | `"mchana".count("a")` → `2` |

| `isdigit()` | ni tarakimu pekee? | `"250".isdigit()` → `True` |

| `zfill()` | kujaza sufuri | `"7".zfill(3)` → `'007'` |

Kuangalia kama mfuatano una sehemu fulani ni rahisi kwa opereta `in`: `if "kahawa" in text.lower():`. Mifuatano hulinganishwa kwa `==` herufi kwa herufi na kwa kuzingatia herufi kubwa/ndogo; kwa ulinganisho usiozingatia hizo, geuza zote mbili kuwa `casefold()`.

## Slices za mifuatano

Mfuatano ni mfuatano wa herufi, kwa hiyo herufi zinaweza kufikiwa kwa faharasa kuanzia sifuri, na faharasa hasi huhesabu kutoka mwisho. Slice `s[start:stop:step]` hurudisha sehemu ndogo; mpaka wa kulia haujumuishwi.

```
s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — kugeuza mfuatano
```

Slice haitoi kosa ikivuka mipaka: `s[0:100]` itarudisha mfuatano mzima. Lakini `s[100]` itatoa `IndexError`. Herufi haiwezi kubadilishwa kwa faharasa (`s[0] = "J"` — `TypeError`); badala yake tengeneza mfuatano mpya: `"J" + s[1:]`.

## f-strings katika Python

Herufi `f` mbele ya mfuatano inamaanisha kuwa misemo iliyo ndani ya mabano ya mikunjo itakokotolewa na kuingizwa kwenye maandishi. Hii ndiyo njia kuu ya kupanga mifuatano tangu Python 3.6: ni fupi kuliko `format()` na ni ya haraka kuliko opereta ya zamani `%`.

```
item = "Kahawa"
price = 250
print(f"{item}: {price} TSh")              # Kahawa: 250 TSh
print(f"Kwa punguzo: {price * 0.9} TSh")   # Kwa punguzo: 225.0 TSh
print(f"{item=}")                           # item='Kahawa' — rahisi kwa utatuzi
```

### Mpangilio wa namba na upangaji

Baada ya koloni ndani ya mabano kunaandikwa kibainishi cha muundo. Kinaelekeza kuzungusha, vitenganishi vya makundi ya tarakimu, upana na upangaji:

| Andiko | Matokeo | Maana |
| --- | --- | --- |

| `f"{3.14159:.2f}"` | `3.14` | kuzungusha hadi tarakimu 2 |

| `f"{1250000:,}"` | `1,250,000` | kitenganishi cha makundi |

| `f"{1250000:_}"` | `1_250_000` | mstari wa chini badala ya koma |

| `f"{0.256:.1%}"` | `25.6%` | asilimia |

| `f"{'kahawa':<10}|"` | `kahawa |` | upande wa kushoto, upana 10 |

| `f"{250:>8}"` | ` 250` | upande wa kulia |

| `f"{7:03d}"` | `007` | kujaza sufuri |

Upangaji ni muhimu kwa majedwali kwenye terminal: `f"{name:<12}{amount:>10.2f}"` itapanga safu kikamilifu. Kumbuka kwamba upangaji unahitajika tu wakati wa kuonyesha. Fedha zihifadhiwe kama senti (`int`) au kwa `Decimal`, si kwa `float`: `0.1 + 0.2` inatoa `0.30000000000000004`.

### Nukuu na mivunjo ndani ya f-string

Kuanzia Python 3.12 (PEP 701) f-strings zina sarufi rasmi: ndani ya mabano ya mikunjo unaweza kutumia nukuu zile zile za nje, mistari ya nyuma na mivunjo, na kiwango cha kuingizwa hakina kikomo tena. Makosa ndani ya mabano sasa yanaonyesha nafasi kamili. Kwenye matoleo ya zamani andika ndani nukuu za aina nyingine: `f"{d['key']}"`, na mivunjo kupitia kigezo tofauti au `chr(10)`.

Kwa maandishi ya mistari mingi, f-string ya nukuu tatu inafaa: `f"""Jumla: {total}\nIdadi: {count}"""`.

### format() na %: njia za zamani

Katika msimbo wa watu wengine utakutana na `"{}: {}".format(item, price)` na `"%s: %d" % (item, price)`. Vibainishi vya `format()` ni vile vile vya f-strings. Mbinu ya `format()` bado ina manufaa pale kiolezo kinapohifadhiwa kando na data, kwa mfano kwenye faili la usanidi.

## Kuchambua mfuatano: mfano wa vitendo

Tuunganishe mbinu pamoja. Tuseme kutoka faili linakuja mstari wa aina `"  2026-10-16; Kahawa ; 250,50 \n"`, na tunahitaji tarehe, jina na kiasi kwa senti. Mpangilio wa kawaida: safisha pembe, kata kwa kitenganishi, safisha kila sehemu, kisha badilisha aina.

```
line = "  2026-10-16; Kahawa ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 Kahawa 25050
print(f"{item:10.2f}")
```

Ikiwa sehemu hazitakuwa tatu, kugawanya kutaanguka kwa `ValueError: not enough values to unpack` au `too many values to unpack`. Katika msimbo halisi mistari kama hiyo inapaswa kukaguliwa mapema au kosa likamatwe. Kwa faili halisi za CSV zenye nukuu na urukaji wa herufi, tumia moduli ya kawaida `csv`, si `split`.

### Makosa ya kawaida na mifuatano

- **Matokeo ya mbinu hayakuhifadhiwa**: `s.strip()` bila mgawo haibadilishi chochote.
- **join kwenye orodha ya namba** — `TypeError`; kwanza `map(str, ...)`.
- **strip na sehemu ndogo**: hoja ni seti ya herufi; kwa kiambishi awali tumia `removeprefix()`.
- **Ulinganisho unaozingatia herufi kubwa/ndogo**: `"Kahawa" == "kahawa"` ni `False`.
- **Mistari ya nyuma katika njia za Windows** bila kiambishi `r` hugeuka kuwa herufi maalum.

## t-strings: kiolezo badala ya maandishi tayari

Python 3.14 imeleta t-strings. Zinaonekana kama f-strings, ila zina kiambishi `t`, na matokeo yake ni tofauti: si mfuatano tayari, bali kitu cha aina `string.templatelib.Template`. Ndani yake vipande vya maandishi (`.strings`) na thamani zilizoingizwa (`.values`) vinakaa kando kando.

```
name = ""
tpl = t"Habari, {name}!"
print(tpl.strings)   # ('Habari, ', '!')
print(tpl.values)    # ('',)
```

Kwa nini hili lina maana: maktaba hupokea thamani kabla ya kuunganishwa na inaweza kuzichakata — kwa mfano kuficha alama za HTML au kupitisha vigezo kwa usalama kwenye swali la SQL. f-string haitoi nafasi hiyo, kwa sababu imeshaunganisha kila kitu. Kwa uchapishaji wa kawaida bado tumia f-strings.

## Hitimisho

Kwa kazi za kila siku na mifuatano katika Python unahitaji seti ndogo: `split()` na `join()` hugawanya na kuunganisha maandishi, `strip()` husafisha uingizaji, `replace()` hubadilisha vipande, slices hukata sehemu ndogo, na f-strings huonyesha thamani kwa muundo unaotaka. Kumbuka kutobadilika: mbinu hurudisha mfuatano mpya, na lazima uuhifadhi. Mifuatano, namba na f-strings vimefafanuliwa kwa vitendo kwa mfano wa kifuatiliaji cha matumizi katika somo la kozi ya Python.

## FAQ

**Ninawezaje kujua urefu wa mfuatano katika Python?**

Kazi len(s) hurudisha idadi ya herufi. Kwa herufi za Unicode na emoji zinahesabiwa herufi, si baiti; ukubwa kwa baiti unapatikana kwa len(s.encode("utf-8")).

**Ninawezaje kugeuza namba kuwa mfuatano na kinyume chake?**

str(250) inatoa '250', na int("250") na float("2.5") ni ubadilishaji wa kinyume. Mfuatano usipofanana na namba, int() itasababisha ValueError, kwa hiyo uingizaji unapaswa kukaguliwa.

**Kwa nini replace haibadilishi mfuatano wangu?**

Mifuatano haibadiliki, replace hurudisha mfuatano mpya. Mpe matokeo mgawo: s = s.replace("a", "b").

**Ninawezaje kukagua kama mfuatano ni tupu?**

Mfuatano tupu ni sivyo (False), kwa hiyo if not s: inatosha. Ikiwa mfuatano unaweza kuwa na nafasi tu, kagua if not s.strip():.

**t-string inatofautianaje na f-string?**

f-string hurudisha str iliyokamilika mara moja, wakati t-string (Python 3.14+) ni kitu cha Template chenye vipande vya maandishi na thamani kando. Hii inaruhusu kuficha data salama kwa HTML na SQL.


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