String sa Python: mga method na split, replace, strip, join, slice, at f-string

Makikita ang string sa halos bawat programa sa Python: input ng user, pangalan ng file, linya ng CSV, at sagot ng API. Iniimbak ng uri na str ang teksto sa Unicode, kaya gumagana ang Cyrillic, Tagalog, at emoji nang walang espesyal na setting. Ang pinakaginagamit na method ay split, replace, strip, at join, at pinakamaginhawang ilabas ang mga halaga gamit ang f-string. Isa-isahin natin ang mga ito gamit ang mga halimbawa.

Paano gumagana ang string sa Python

Isinusulat ang string sa single o double na quote — walang pagkakaiba: magkapareho ang 'kape' at "kape". Ang triple quote ay gumagawa ng multiline na string, kung saan nananatili ang mga line break.

name = "Kape"
note = """Unang linya
Ikalawang linya"""
print(len(name))  # 4 — haba ng string sa mga karakter

Pangunahing katangian ng string ang hindi pagkakabago. Hindi binabago ng method ang string, kundi nagbabalik ng bago. Kaya ang s.replace("a", "b") na walang assignment ay walang gagawin — dapat isulat ang s = s.replace("a", "b"). Ito ang pinakakaraniwang pagkakamali ng mga baguhan.

Mga espesyal na karakter, line break, at raw string

Ang line break ay \n, ang tab ay \t, at ang backslash ay \\. Ang prefix na r ay gumagawa ng "raw" na string: hindi pinoproseso ang mga backslash dito. Kapaki-pakinabang ito para sa Windows path at regular expression.

print("Kabuuan:\n350 ₱")
path = r"C:\new\table.csv"   # hindi magiging special character ang \n at \t

Maaaring ilipat sa susunod na linya ng code ang mahabang ekspresyon kung ilalagay ito sa loob ng mga bracket: pinagdurugtong ng Python mismo ang magkakasunod na string literal sa loob ng bracket.

split: hatiin ang string sa listahan

Hinahati ng split() ang string ayon sa delimiter at nagbabalik ng listahan. Kapag walang argumento, hinihiwa ito sa anumang whitespace at binabalewala ang magkasunod na espasyo — kapaki-pakinabang sa pagbasa ng mga utos.

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

Pansinin ang pagkakaiba: kapag may tahasang delimiter, nananatili ang mga walang laman na piraso. Nililimita ng ikalawang argumentong maxsplit ang bilang ng paghati, at ang rsplit() ay naghahati mula sa kanan. Para hatiin ang teksto sa mga linya, gamitin ang splitlines(): kinikilala nito ang \n at \r\n, at hindi nag-iiwan ng walang lamang elemento sa dulo.

text = "kape\ntaksi\n"
text.split("\n")     # ['kape', 'taksi', '']
text.splitlines()    # ['kape', 'taksi']

join: pagsamahin ang listahan sa string

Ang join() ang kabaligtaran. Tinatawag ito sa string na delimiter, at ang argumento nito ay listahan ng mga string:

items = ["kape", "taksi", "tanghalian"]
print(", ".join(items))   # kape, taksi, tanghalian
print("\n".join(items))   # bawat item sa sariling linya

Dapat na string lahat ng elemento, kung hindi, makakakuha ka ng TypeError: sequence item 0: expected str instance, int found. I-convert muna ang mga numero: ", ".join(str(x) for x in amounts).

Pagdudugtong at pagsasama ng mga string

Maaaring pagdugtungin ang dalawang string gamit ang +, at ulitin gamit ang *: "-" * 20. Pero mabagal ang pagdudugtong ng daan-daang piraso sa loob ng loop gamit ang +=, dahil bawat beses ay gumagawa ng bagong string. Ilagay ang mga piraso sa listahan at pagsamahin sa iisang join(). Hindi maaaring idugtong nang diretso ang string at numero: ang "Kabuuan: " + 5 ay magdudulot ng TypeError; kailangan ang str() o f-string.

replace: palitan ang bahagi ng string

Pinapalitan ng replace(old, new) ang lahat ng pagkakataon ng substring. Nililimita ng pangatlong argumento ang bilang ng pagpapalit.

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

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

Sensitibo sa malaki at maliit na letra ang method at naghahanap ng eksaktong tugma. Para sa pagpapalit ayon sa pattern (halimbawa, "lahat ng numero"), kailangan ang module na re at ang function na re.sub().

strip, lstrip, rstrip: putulin ang mga gilid ng string

Inaalis ng strip() ang mga espasyo, tab, at line break sa magkabilang gilid. Ang lstrip() ay sa kaliwa lang, at ang rstrip() ay sa kanan lang. Ito ang unang dapat gawin sa input ng user at sa mga string na galing sa file.

raw = "  Kape \n"
raw.strip()       # 'Kape'
raw.rstrip()      # '  Kape'
"xxKapexx".strip("x")   # 'Kape'

Hanay ng mga karakter ang argumento, hindi substring: ang "abcTekstocba".strip("abc") ay magtatanggal ng lahat ng a, b, at c sa mga gilid, anuman ang pagkakasunod-sunod. Para tanggalin nang eksakto ang prefix o suffix, gamitin ang removeprefix() at removesuffix() (mula Python 3.9).

Iba pang kapaki-pakinabang na method ng string

Pinakamadaling suriin kung nasa string ang isang substring gamit ang operator na in: if "kape" in text.lower():. Ikinukumpara ang mga string gamit ang ==, karakter kada karakter at may pagkakaiba sa malaki/maliit na letra; para sa paghahambing na hindi sensitibo sa letra, gawing casefold() ang pareho.

Mga slice ng string

Ang string ay sunod-sunod na datos, kaya maaaring kunin ang mga karakter gamit ang index na nagsisimula sa zero, at ang negatibong index ay nagbibilang mula sa dulo. Ibinabalik ng slice na s[start:stop:step] ang substring; hindi kasama ang kanang hangganan.

s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — baligtarin ang string

Hindi kailanman nagbibigay ng error ang slice kapag lumampas sa hangganan: ang s[0:100] ay magbabalik ng buong string. Pero ang s[100] ay magbibigay ng IndexError. Hindi maaaring palitan ang karakter sa pamamagitan ng index (s[0] = "J" — TypeError); bumuo ng bagong string: "J" + s[1:].

f-string sa Python

Ang letrang f sa unahan ng string ay nangangahulugang kakalkulahin ang mga ekspresyon sa loob ng curly brace at ilalagay sa teksto. Ito ang pangunahing paraan ng pag-format ng string simula Python 3.6: mas maikli ito kaysa sa format() at mas mabilis kaysa sa lumang operator na %.

item = "Kape"
price = 250
print(f"{item}: {price} ₱")              # Kape: 250 ₱
print(f"Pagkatapos ng diskwento: {price * 0.9} ₱")    # Pagkatapos ng diskwento: 225.0 ₱
print(f"{item=}")                         # item='Kape' — maginhawa sa debugging

Pag-format ng numero at pag-align

Pagkatapos ng colon sa loob ng braces, isinusulat ang format specifier. Itinatakda nito ang pagbilog, ang separator ng libo, lapad, at pag-align:

Kapaki-pakinabang ang alignment sa mga talahanayan sa terminal: ang f"{name:<12}{amount:>10.2f}" ay magpapantay ng mga kolum nang eksakto. Tandaan na sa pag-print lang kailangan ang pag-format. Itago ang pera bilang sentimo (int) o sa Decimal, hindi sa float: ang 0.1 + 0.2 ay nagbibigay ng 0.30000000000000004.

Mga quote at line break sa loob ng f-string

Mula Python 3.12 (PEP 701), may pormal nang grammar ang mga f-string: sa loob ng braces, maaaring gamitin ang parehong quote ng panlabas na string, mga backslash, at mga line break, at wala nang limitasyon sa pagkakabuhol. Ipinapakita rin ng mga error sa loob ng braces ang eksaktong posisyon. Sa mas lumang bersyon, gumamit ng ibang uri ng quote sa loob: f"{d['key']}", at ang line break ay ilagay sa hiwalay na variable o gamitin ang chr(10).

Para sa multiline na teksto, angkop ang f-string na may triple quote: f"""Kabuuan: {total}\nBilang ng posisyon: {count}""".

format() at %: mga lumang paraan

Makakasalubong mo sa lumang code ang "{}: {}".format(item, price) at "%s: %d" % (item, price). Pareho ang mga specifier ng format() sa mga f-string. Kapaki-pakinabang pa rin ang method na format() kapag nakahiwalay ang template sa datos, halimbawa sa config file.

Pag-parse ng string: praktikal na halimbawa

Pagsamahin natin ang mga method. Ipagpalagay na may mga linyang tulad ng " 2026-10-16; Kape ; 250,50 \n" na galing sa file, at kailangang makuha ang petsa, pangalan, at halaga sa sentimo. Karaniwang pagkakasunod-sunod: linisin ang mga gilid, hatiin sa delimiter, linisin ang bawat bahagi, at i-convert ang mga uri.

line = "  2026-10-16; Kape ; 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 Kape 25050
print(f"{item:<10}{amount_kop / 100:>10.2f}")

Kapag hindi tatlo ang bilang ng piraso, mag-e-error ang unpacking ng ValueError: not enough values to unpack o too many values to unpack. Sa totoong code, suriin ang mga linyang ito nang maaga o hulihin ang exception. Para sa totoong CSV na may quote at escape, mas mainam ang standard module na csv kaysa sa split.

Karaniwang pagkakamali sa string

• Hindi na-save ang resulta ng method: ang s.strip() na walang assignment ay walang binabago.
• join sa listahan ng numero — TypeError; gawin muna ang map(str, ...).
• strip na may substring: hanay ng karakter ang argumento; para sa prefix, gamitin ang removeprefix().
• Paghahambing na sensitibo sa letra: ang "Kape" == "kape" ay False.
• Backslash sa Windows path na walang prefix na r ay nagiging special character.

t-string: template sa halip na tapos na teksto

Sa Python 3.14, lumitaw ang t-string. Kamukha ito ng f-string, pero may prefix na t, at iba ang resulta: hindi tapos na string kundi object na string.templatelib.Template. Hiwalay na nakaimbak dito ang mga bahagi ng teksto (.strings) at ang mga ipinasok na halaga (.values).

name = "<script>"
tpl = t"Kumusta, {name}!"
print(tpl.strings)   # ('Kumusta, ', '!')
print(tpl.values)    # ('<script>',)

Bakit ito mahalaga: natatanggap ng library ang mga halaga bago pagdugtungin, at maaari nitong iproseso ang mga ito — halimbawa, i-escape ang mga angle bracket sa HTML o ipasa nang tama ang mga parameter sa SQL query. Walang ganitong pagkakataon ang f-string, dahil tapos na nitong pinagdugtong ang lahat. Para sa karaniwang output, gamitin pa rin ang f-string.

Buod

Para sa araw-araw na gawain sa string sa Python, sapat na ang maliit na hanay ng mga tool: pinaghahati at binubuo ng split() at join() ang teksto, nililinis ng strip() ang input, pinapalitan ng replace() ang mga bahagi, pinpuputol ng slice ang mga substring, at inilalabas ng f-string ang mga halaga sa tamang format. Tandaan ang hindi pagkakabago: nagbabalik ng bagong string ang method, at kailangan itong i-save. Ang mga string, numero, at f-string ay tinalakay nang praktikal sa lektyur ng kurso sa Python gamit ang tagasubaybay ng gastos.