Tutorial regex Python: module re, pola, group, dan replace

Kapan memakai regex

Regular expression adalah bahasa kecil untuk menggambarkan pola teks. Regex sangat kuat, dan mudah dipakai berlebihan.

Sebelum memakai re, tanyakan apakah method string biasa sudah cukup. .split(), .replace(), .startswith(), "target" in text: semuanya lebih cepat, lebih mudah dibaca, dan lebih jarang salah daripada regex yang setara. Simpan regex untuk saat pola yang kamu cari memang terstruktur tapi terlalu fleksibel untuk operasi string yang tetap: alamat email, nomor telepon, baris log dengan bentuk yang sudah diketahui, potongan HTML atau Markdown, dan pencarian "temukan hal semacam ini" lainnya.

Kosakata dasar

Sebuah pola regex adalah string yang menggambarkan apa yang kamu cari. Beberapa komponen dasarnya:

• .: satu karakter apa saja
• \d: digit apa saja (0 sampai 9)
• \w: karakter "kata" apa saja (huruf, digit, garis bawah)
• \s: karakter spasi apa saja
• ^: awal string
• $: akhir string
• [abc]: salah satu dari a, b, atau c
• [^abc]: karakter apa saja kecuali a, b, c
• a|b: a atau b
• *: nol atau lebih dari hal sebelumnya
• +: satu atau lebih
• ?: nol atau satu
• {3}: tepat 3
• {2,5}: antara 2 dan 5
• ( ... ): group (menangkap hasil yang cocok di dalamnya)

Itu sudah cukup untuk kebanyakan regex di dunia nyata.

Fungsi-fungsi utama

re.search(pattern, text) menemukan kecocokan pertama di mana saja dalam string. Fungsi ini mengembalikan objek match atau None:

import re

text = "Order 12345 shipped on 2026-04-20"
match = re.search(r"\d{5}", text)

if match:
    print("Found:", match.group())
    print("Position:", match.start(), "-", match.end())
else:
    print("No match")

Selalu pakai raw string (r"...") untuk pola regex. Kalau tidak, Python mencoba menafsirkan garis miring terbaliknya sebagai escape string, dan kamu mendapat pola yang berbeda dari yang kamu ketik.

re.match(pattern, text) mirip search, tapi hanya mencocokkan di awal:

import re

print(re.search(r"hello", "say hello"))   # match
print(re.match(r"hello", "say hello"))    # None - didn't start with hello

Hampir selalu yang kamu butuhkan adalah search.

re.findall(pattern, text) mengembalikan semua kecocokan yang tidak saling tumpang tindih sebagai list:

import re

text = "Apples 3, oranges 12, pears 7"
numbers = re.findall(r"\d+", text)
print(numbers)   # ['3', '12', '7']

Perhatikan bahwa findall mengembalikan string, bukan objek match. Kalau polamu punya satu group, kamu mendapat isi group itu. Kalau ada beberapa group, kamu mendapat list berisi tuple.

Capturing group

Tanda kurung di dalam pola menangkap apa pun yang cocok di dalamnya:

import re

line = "2026-04-20: server started"
match = re.search(r"(\d{4})-(\d{2})-(\d{2}): (.+)", line)

if match:
    print(match.group(0))  # the whole match
    print(match.group(1))  # '2026' - first group
    print(match.group(2))  # '04'
    print(match.group(3))  # '20'
    print(match.group(4))  # 'server started'
    print(match.groups())  # tuple of all groups

Group yang diberi nama biasanya lebih jelas:

import re

line = "2026-04-20: server started"
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2}): (?P<msg>.+)"
match = re.search(pattern, line)

if match:
    print(match["year"], match["month"], match["day"])
    print(match.groupdict())

Begitu regex-nya punya lebih dari satu group, memberi nama membuat kode pengambilannya jauh lebih mudah diikuti.

Mengganti dengan re.sub

re.sub(pattern, replacement, text) mengganti setiap kecocokan:

import re

text = "Call me at (415) 555-1234 or 212.555.5678"
cleaned = re.sub(r"[^\d]", "", text)
print(cleaned)

Kode itu membuang semua yang bukan digit. Teks pengganti bisa merujuk ke group yang ditangkap dengan \1, \2, dan seterusnya, atau di raw string, \g<1> lebih jelas:

import re

text = "Alice Johnson, Bob Smith, Carol Tran"
swapped = re.sub(r"(\w+) (\w+)", r"\2, \1", text)
print(swapped)

Kamu juga bisa memberikan fungsi sebagai pengganti. Itu berguna untuk transformasi yang bukan sekadar tukar posisi:

import re

text = "Prices: 10, 20, 30"
doubled = re.sub(r"\d+", lambda m: str(int(m.group()) * 2), text)
print(doubled)

Meng-compile pola untuk dipakai ulang

Kalau kamu memakai pola yang sama berkali-kali, terutama di dalam loop, compile pola itu sekali:

import re

DATE = re.compile(r"\d{4}-\d{2}-\d{2}")

lines = [
    "started at 2026-04-20",
    "no timestamp here",
    "finished 2026-04-21",
]

for line in lines:
    match = DATE.search(line)
    if match:
        print(match.group())

Pola yang sudah di-compile menyediakan method yang sama (search, match, findall, sub) tanpa pola sebagai argumen pertama. Sedikit lebih efisien, dan sering lebih mudah dibaca.

Flag

Pengubah yang umum, diberikan sebagai argumen flags= atau digabung dengan OR:

• re.IGNORECASE (re.I): pencocokan tanpa membedakan huruf besar kecil.
• re.MULTILINE (re.M): ^ dan $ cocok di setiap baris, bukan hanya di batas string.
• re.DOTALL (re.S): . juga cocok dengan baris baru (secara bawaan tidak).
• re.VERBOSE (re.X): mengizinkan spasi dan komentar # di dalam pola, supaya mudah dibaca.

import re

text = "HELLO world"
print(re.search(r"hello", text))
print(re.search(r"hello", text, re.IGNORECASE))

re.VERBOSE sangat berguna untuk pola yang rumit:

import re

pattern = re.compile(r"""
    (?P<user>[\w.]+)    # username part
    @                    # literal at sign
    (?P<domain>[\w.-]+)  # domain
""", re.VERBOSE)

match = pattern.search("Contact me at rosa@example.com")
if match:
    print(match.groupdict())

Regex banyak baris yang diberi komentar jauh lebih mudah dirawat daripada satu baris yang sulit dipahami.

Greedy vs lazy

Quantifier (*, +, ?, {n,}) secara bawaan bersifat greedy: mencocokkan sebanyak mungkin. Tambahkan ? untuk membuatnya lazy:

import re

html = "<b>bold</b> and <i>italic</i>"

# Greedy - matches from the first < to the last >
print(re.findall(r"<.+>", html))

# Lazy - matches each tag separately
print(re.findall(r"<.+?>", html))

Versi greedy menangkap seluruh substring dari <b> sampai </i>, mungkin bukan yang kamu mau. .+? yang lazy berhenti di > pertama.

(Catatan: jangan benar-benar mem-parse HTML dengan regex di produksi. Pakai html.parser atau BeautifulSoup. Contoh di atas hanya untuk menunjukkan sifat greedy.)

Contoh yang realistis

Mem-parse baris-baris dari format log sederhana:

import re

log = """
2026-04-20 09:00:12 INFO  Server started
2026-04-20 09:01:45 WARN  Slow query detected
2026-04-20 09:03:01 ERROR Database connection lost
"""

pattern = re.compile(r"""
    (?P<date>\d{4}-\d{2}-\d{2})\s+
    (?P<time>\d{2}:\d{2}:\d{2})\s+
    (?P<level>INFO|WARN|ERROR)\s+
    (?P<message>.+)
""", re.VERBOSE)

for line in log.strip().splitlines():
    match = pattern.match(line)
    if match:
        print(match.groupdict())

Banyak sekali kemampuan dalam baris yang tidak seberapa.

Beberapa kebiasaan

• Selalu pakai raw string untuk pola.
• Mulai dari pola paling sederhana yang berhasil; perketat nanti.
• Pakai named group begitu kamu punya lebih dari satu group.
• Compile pola yang akan kamu pakai ulang.
• Regex lebih lambat daripada method string biasa. Kalau .split() sudah cukup, pakai .split().

Berikutnya: error dan debugging

Itu menutup tur data sungguhan: file, JSON, CSV, HTTP, tanggal, dan regex. Tapi semua yang ada di program sungguhan cepat atau lambat akan bertemu error, dan membaca traceback Python dengan baik adalah keterampilan debugging terbesar yang bisa kamu kuasai. Bab terakhir membahas exception dan error spesifik yang paling sering akan kamu temui.