# String di Python: metode split, replace, strip, join, slice dan f-string

URL: https://skillaria.top/id/guides/python/string-python

String di Python (tipe str) adalah urutan karakter Unicode yang tidak bisa diubah. Metode split() memecah string menjadi list, join() menggabungkannya kembali, replace() mengganti potongan teks, dan strip() membuang spasi di ujung; setiap metode mengembalikan string baru. Untuk menyisipkan nilai, f-string paling praktis: f"{name}: {price:.2f}".

String ada di hampir setiap program Python: input pengguna, nama berkas, baris CSV, jawaban API. Tipe `str` menyimpan teks dalam Unicode, sehingga huruf Cyrillic dan emoji bisa dipakai tanpa pengaturan tambahan. Metode yang paling sering dipakai adalah `split`, `replace`, `strip` dan `join`, dan untuk menampilkan nilai, f-string paling nyaman. Semuanya dibahas dengan contoh berikut.

## Bagaimana string bekerja di Python

String ditulis dengan tanda kutip tunggal atau ganda — tidak ada perbedaan: `'kopi'` dan `"kopi"` sama saja. Tanda kutip tiga membuat string multibaris, dengan pindah baris yang tersimpan apa adanya.

```
name = "Kopi"
note = """Baris pertama
Baris kedua"""
print(len(name))  # 4 — panjang string dalam karakter
```

Sifat utama string adalah tidak bisa diubah. Metode tidak mengubah string, melainkan mengembalikan string baru. Karena itu, `s.replace("a", "b")` tanpa penugasan tidak menghasilkan apa-apa — harus ditulis `s = s.replace("a", "b")`. Ini kesalahan paling sering dilakukan pemula.

### Karakter khusus, pindah baris, dan raw string

Pindah baris ditulis `\n`, tab `\t`, dan garis miring terbalik `\\`. Awalan `r` membuat string «mentah»: garis miring terbalik di dalamnya tidak diproses. Ini berguna untuk path Windows dan ekspresi reguler.

```
print("Total:\n350 Rp")
path = r"C:\new\table.csv"   # \n dan \t tidak berubah menjadi karakter khusus
```

Ekspresi panjang bisa dipecah ke baris berikutnya dengan membungkusnya dalam tanda kurung: literal string yang berdampingan di dalam kurung akan digabung otomatis oleh Python.

## split: memecah string menjadi list

Metode `split()` membagi string menurut pemisah dan mengembalikan list. Tanpa argumen, ia memotong pada karakter spasi apa pun dan mengabaikan spasi yang berulang — cocok untuk mengurai perintah.

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

Perhatikan perbedaannya: dengan pemisah eksplisit, potongan kosong tetap disimpan. Argumen kedua `maxsplit` membatasi jumlah pemotongan, dan `rsplit()` memotong dari kanan. Untuk memecah teks menjadi baris, gunakan `splitlines()`: ia mengenali `\n` maupun `\r\n` dan tidak meninggalkan elemen kosong di akhir.

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

## join: menggabungkan list menjadi string

`join()` adalah kebalikannya. Metode ini dipanggil pada string pemisah, dan argumennya adalah list string:

```
items = ["kopi", "taksi", "makan siang"]
print(", ".join(items))   # kopi, taksi, makan siang
print("\n".join(items))   # setiap item di baris baru
```

Semua elemen harus berupa string, kalau tidak Anda akan mendapat `TypeError: sequence item 0: expected str instance, int found`. Ubah angka lebih dulu: `", ".join(str(x) for x in amounts)`.

### Penyambungan dan penggabungan string

Dua string bisa disambung dengan `+`, dan diulang dengan `*`: `"-" * 20`. Namun menyambung ratusan potongan dalam perulangan dengan `+=` itu lambat, karena setiap kali tercipta string baru. Kumpulkan potongan ke dalam list lalu gabungkan dengan satu `join()`. Angka tidak bisa langsung disambung dengan string: `"Total: " + 5` menghasilkan `TypeError`, gunakan `str()` atau f-string.

## replace: mengganti potongan string

`replace(old, new)` mengganti semua kemunculan potongan teks. Argumen ketiga membatasi jumlah penggantian.

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

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

Metode ini sensitif terhadap huruf besar-kecil dan mencari kecocokan persis. Untuk penggantian berdasarkan pola (misalnya «semua angka») diperlukan modul `re` dan fungsi `re.sub()`.

## strip, lstrip, rstrip: memangkas string

`strip()` membuang spasi, tab dan pindah baris di kedua ujung. `lstrip()` hanya membersihkan kiri, `rstrip()` hanya kanan. Ini biasanya langkah pertama untuk input pengguna dan baris dari berkas.

```
raw = "  Kopi \n"
raw.strip()       # 'Kopi'
raw.rstrip()      # '  Kopi'
"xxKopixx".strip("x")   # 'Kopi'
```

Argumennya adalah kumpulan karakter, bukan substring: `"abcTekscba".strip("abc")` akan membuang semua a, b dan c di ujung dalam urutan apa pun. Untuk memotong awalan atau akhiran secara tepat, gunakan `removeprefix()` dan `removesuffix()` (sejak Python 3.9).

## Metode string lain yang berguna

| Metode | Fungsi | Contoh → hasil |
| --- | --- | --- |

| `lower()`, `upper()` | huruf kecil dan besar | `"Kopi".lower()` → `'kopi'` |

| `startswith()`, `endswith()` | cek awal dan akhir | `"a.csv".endswith(".csv")` → `True` |

| `find()` | posisi substring atau -1 | `"kopi".find("p")` → `2` |

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

| `isdigit()` | hanya angka? | `"250".isdigit()` → `True` |

| `zfill()` | melengkapi dengan nol | `"7".zfill(3)` → `'007'` |

Untuk mengecek apakah string memuat substring, cara paling mudah adalah operator `in`: `if "kopi" in text.lower():`. Perbandingan string dengan `==` dilakukan karakter demi karakter dan peka huruf besar-kecil; untuk perbandingan tanpa memperhatikan huruf, ubah keduanya dengan `casefold()`.

## Slice string

String adalah urutan, jadi karakternya bisa diakses lewat indeks mulai dari nol, dan indeks negatif menghitung dari belakang. Slice `s[start:stop:step]` mengembalikan potongan string; batas kanan tidak ikut.

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

Slice tidak pernah menimbulkan error ketika melewati batas: `s[0:100]` mengembalikan seluruh string. Tetapi `s[100]` menghasilkan `IndexError`. Karakter pada indeks tertentu tidak bisa diubah (`s[0] = "J"` menghasilkan `TypeError`), jadi buat string baru: `"J" + s[1:]`.

## f-string di Python

Huruf `f` di depan string berarti ekspresi di dalam kurung kurawal akan dihitung dan disisipkan ke dalam teks. Ini cara utama memformat string sejak Python 3.6: lebih ringkas daripada `format()` dan lebih cepat daripada operator `%` yang lama.

```
item = "Kopi"
price = 250
print(f"{item}: {price} Rp")               # Kopi: 250 Rp
print(f"Dengan diskon: {price * 0.9} Rp")  # Dengan diskon: 225.0 Rp
print(f"{item=}")                           # item='Kopi' — praktis untuk debugging
```

### Format angka dan perataan

Setelah titik dua di dalam kurung, ditulis spesifikasi format. Ia mengatur pembulatan, pemisah ribuan, lebar, dan perataan:

| Penulisan | Hasil | Arti |
| --- | --- | --- |

| `f"{3.14159:.2f}"` | `3.14` | dibulatkan 2 desimal |

| `f"{1250000:,}"` | `1,250,000` | pemisah ribuan |

| `f"{1250000:_}"` | `1_250_000` | garis bawah sebagai pemisah |

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

| `f"{'kopi':<10}|"` | `kopi |` | rata kiri, lebar 10 |

| `f"{250:>8}"` | ` 250` | rata kanan |

| `f"{7:03d}"` | `007` | diisi nol di depan |

Perataan berguna untuk tabel di terminal: `f"{name:<12}{amount:>10.2f}"` membuat kolom rapi. Perlu diingat, format hanya dipakai saat menampilkan. Simpan uang dalam satuan terkecil (`int`) atau dalam `Decimal`, bukan `float`: `0.1 + 0.2` menghasilkan `0.30000000000000004`.

### Tanda kutip dan pindah baris di dalam f-string

Sejak Python 3.12 (PEP 701) f-string punya tata bahasa formal: di dalam kurung kurawal boleh memakai tanda kutip yang sama dengan luarnya, garis miring terbalik, dan pindah baris, serta kedalaman bersarang tidak lagi dibatasi. Error di dalam kurung juga menunjukkan posisi yang tepat. Di versi lama, gunakan jenis tanda kutip yang berbeda di dalam: `f"{d['key']}"`, dan pindah baris lewat variabel terpisah atau `chr(10)`.

Untuk teks multibaris cocok f-string dengan tanda kutip tiga: `f"""Total: {total}\nJumlah posisi: {count}"""`.

### format() dan %: cara lama

Di kode lama Anda akan menemui `"{}: {}".format(item, price)` dan `"%s: %d" % (item, price)`. Spesifikasi di `format()` sama dengan di f-string. Metode `format()` masih berguna ketika templat disimpan terpisah dari data, misalnya di berkas konfigurasi.

## Mengurai string: contoh praktis

Mari gabungkan metode-metode tadi. Misalkan dari berkas datang baris seperti `"  2026-10-16; Kopi ; 250,50 \n"`, dan kita ingin mendapatkan tanggal, nama, serta jumlah dalam sen. Urutannya lazim: bersihkan ujungnya, potong menurut pemisah, bersihkan setiap bagian, lalu ubah tipenya.

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

Jika bagiannya bukan tiga, pembongkaran akan gagal dengan `ValueError: not enough values to unpack` atau `too many values to unpack`. Dalam kode nyata, baris seperti ini sebaiknya diperiksa lebih dulu atau error-nya ditangkap. Untuk berkas CSV sungguhan dengan tanda kutip dan karakter escape, lebih baik gunakan modul standar `csv` daripada `split`.

### Kesalahan umum dengan string

- **Hasil metode tidak disimpan**: `s.strip()` tanpa penugasan tidak mengubah apa pun.
- **join pada list angka** — `TypeError`; ubah dulu dengan `map(str, ...)`.
- **strip dengan substring**: argumennya adalah kumpulan karakter; untuk awalan gunakan `removeprefix()`.
- **Perbandingan peka huruf besar-kecil**: `"Kopi" == "kopi"` bernilai `False`.
- **Garis miring di path Windows** tanpa awalan `r` berubah menjadi karakter khusus.

## t-string: templat alih-alih teks jadi

Python 3.14 memperkenalkan t-string. Penulisannya mirip f-string, hanya dengan awalan `t`, tetapi hasilnya berbeda: bukan string jadi, melainkan objek `string.templatelib.Template`. Di dalamnya, potongan teks (`.strings`) dan nilai yang disisipkan (`.values`) disimpan terpisah.

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

Manfaatnya: pustaka menerima nilai sebelum digabung, lalu dapat memprosesnya — misalnya meng-escape tanda kurung sudut untuk HTML atau mengirim parameter dengan benar ke query SQL. F-string tidak memberi kesempatan itu, karena semuanya sudah langsung digabung. Untuk keluaran biasa tetap gunakan f-string.

## Ringkasan

Untuk pekerjaan sehari-hari dengan string, Python cukup dengan sedikit metode: `split()` dan `join()` untuk mengurai dan menyusun teks, `strip()` untuk membersihkan input, `replace()` untuk mengganti potongan, slice untuk memotong, dan f-string untuk menampilkan nilai dengan format yang diinginkan. Ingat sifat tidak bisa diubah: metode mengembalikan string baru, dan hasilnya harus disimpan. String, angka, dan f-string dipraktikkan dengan contoh pencatat pengeluaran dalam pelajaran tentang string di kursus Python.

## FAQ

**Bagaimana cara mengetahui panjang string di Python?**

Fungsi len(s) mengembalikan jumlah karakter. Untuk huruf Cyrillic dan emoji yang dihitung adalah karakter Unicode, bukan byte; ukuran dalam byte didapat dengan len(s.encode("utf-8")).

**Bagaimana mengubah angka menjadi string dan sebaliknya?**

str(250) menghasilkan '250', sedangkan int("250") dan float("2.5") melakukan kebalikannya. Jika string bukan angka, int() akan menimbulkan ValueError, jadi input sebaiknya diperiksa.

**Mengapa replace tidak mengubah string saya?**

String tidak bisa diubah, dan replace mengembalikan string baru. Simpan hasilnya: s = s.replace("a", "b").

**Bagaimana mengecek apakah string kosong?**

String kosong dianggap salah, jadi cukup if not s:. Jika string bisa berisi spasi saja, cek dengan if not s.strip():.

**Apa bedanya t-string dan f-string?**

f-string langsung menghasilkan str jadi, sedangkan t-string (Python 3.14+) adalah objek Template yang menyimpan potongan teks dan nilai secara terpisah. Ini memungkinkan data di-escape dengan aman untuk HTML dan SQL.


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