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

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

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:

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}{amount_kop / 100:>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 = "<script>"
tpl = t"Habari, {name}!"
print(tpl.strings)   # ('Habari, ', '!')
print(tpl.values)    # ('<script>',)

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.