Tutorial Ekspresi Reguler Python

Regular Expressions, sering disingkat regex, adalah rangkaian karakter yang digunakan untuk memeriksa apakah suatu pola ada dalam teks (string) tertentu atau tidak. Jika Anda pernah menggunakan mesin pencari, alat cari dan ganti pada pengolah kata dan editor teks — Anda sudah melihat ekspresi reguler digunakan. Regex digunakan di sisi server untuk memvalidasi format alamat email atau kata sandi saat pendaftaran, digunakan untuk mengurai berkas data teks untuk menemukan, mengganti, atau menghapus string tertentu, dan sebagainya. Regex membantu memanipulasi data tekstual, yang sering menjadi prasyarat untuk proyek data science yang melibatkan penambangan teks.

Tutorial ini akan memandu Anda melalui konsep-konsep penting ekspresi reguler dengan Python. Anda akan mulai dengan mengimpor re — pustaka Python yang mendukung ekspresi reguler. Lalu Anda akan melihat bagaimana karakter dasar/biasa digunakan untuk melakukan pencocokan, diikuti oleh karakter wildcard atau karakter khusus. Berikutnya, Anda akan mempelajari penggunaan pengulangan dalam ekspresi reguler. Anda juga akan belajar cara membuat grup dan grup bernama dalam pencarian Anda agar hasil cocok lebih mudah diakses. Setelah itu, Anda akan mengenal konsep pencocokan greedy vs. non-greedy.

Ini memang terdengar banyak, oleh karena itu ada tabel ringkasan yang praktis untuk membantu Anda mengingat yang sudah dibahas sejauh ini dengan definisi singkat. Jangan lupa dilihat!

Tutorial ini juga membahas beberapa fungsi berguna yang disediakan pustaka re, seperti: compile(), search(), findall(), sub() untuk cari dan ganti, split(), dan lainnya. Anda juga akan belajar tentang flag kompilasi yang dapat Anda gunakan untuk membuat regex Anda lebih baik.

Pada akhirnya, ada sebuah studi kasus — tempat Anda bisa mempraktikkan pengetahuan Anda! Jadi mari kita ber-regex...

Ekspresi Reguler di Python

Di Python, ekspresi reguler didukung oleh modul re. Artinya, jika Anda ingin mulai menggunakannya dalam skrip Python Anda, Anda harus mengimpor modul ini dengan bantuan import:

import re

Pustaka re di Python menyediakan beberapa fungsi yang menjadikannya keterampilan yang layak untuk dikuasai. Anda akan melihat beberapa di antaranya lebih dekat dalam tutorial ini.

Pola Dasar: Karakter Biasa

Anda dapat dengan mudah menangani banyak pola dasar di Python menggunakan karakter biasa. Karakter biasa adalah ekspresi reguler yang paling sederhana. Mereka mencocokkan dirinya sendiri secara persis dan tidak memiliki makna khusus dalam sintaks ekspresi reguler.

Contohnya adalah 'A', 'a', 'X', '5'.

Karakter biasa dapat digunakan untuk melakukan pencocokan eksak yang sederhana:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

Sebagian besar alfabet dan karakter akan mencocokkan dirinya sendiri, seperti yang Anda lihat pada contoh.

Fungsi match() mengembalikan objek match jika teks cocok dengan pola. Jika tidak, ia mengembalikan None. Modul re juga berisi beberapa fungsi lain, dan Anda akan mempelajari beberapa di antaranya nanti dalam tutorial.

Sekarang, mari fokus pada karakter biasa!

Apakah Anda memperhatikan huruf r di awal pola Cookie?
Ini disebut raw string literal. Ini mengubah bagaimana literal string ditafsirkan. Literal seperti ini disimpan apa adanya.

Misalnya, \ hanyalah sebuah backslash ketika diberi prefiks r daripada ditafsirkan sebagai urutan escape. Anda akan melihat artinya saat membahas karakter khusus. Terkadang, sintaks melibatkan karakter yang di-escape dengan backslash, dan untuk mencegah karakter-karakter ini ditafsirkan sebagai urutan escape, Anda menggunakan prefiks mentah r.

TIP: Anda sebenarnya tidak membutuhkannya untuk contoh ini; namun, sebaiknya gunakan demi konsistensi.

Karakter Wildcard: Karakter Khusus

Karakter khusus adalah karakter yang tidak mencocokkan dirinya sendiri seperti terlihat, melainkan memiliki makna khusus saat digunakan dalam ekspresi reguler. Untuk pemahaman sederhana, anggap saja sebagai metakarakter yang dicadangkan yang menandakan sesuatu yang lain dan bukan seperti tampaknya.

Mari lihat beberapa contoh untuk melihat karakter khusus beraksi...

Sebelum itu, contoh di bawah menggunakan dua fungsi yaitu: search() dan group().
Dengan fungsi search, Anda memindai string/urutan yang diberikan, mencari lokasi pertama tempat ekspresi reguler menghasilkan kecocokan.
Fungsi group mengembalikan string yang cocok oleh regex. Anda akan melihat kedua fungsi ini lebih detail nanti.

Kembali ke karakter khusus sekarang.

. - Titik. Mencocokkan satu karakter apa pun kecuali karakter baris baru.

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ - Tanda sisipan. Mencocokkan awal string.

Ini berguna jika Anda ingin memastikan sebuah dokumen/kalimat dimulai dengan karakter tertentu.

re.search(r'^Eat', "Eat cake!").group()

## Namun, kode di bawah tidak akan memberi hasil yang sama. Coba sendiri:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ - Mencocokkan akhir string.

Ini berguna jika Anda ingin memastikan sebuah dokumen/kalimat berakhir dengan karakter tertentu.

re.search(r'cake$', "Cake! Let's eat cake").group()

## Pencarian berikut akan mengembalikan nilai NONE, coba:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] - Mencocokkan a atau b atau c.
[a-zA-Z0-9] - Mencocokkan huruf apa pun dari (a sampai z) atau (A sampai Z) atau (0 sampai 9).

TIP: Karakter yang tidak berada dalam suatu rentang dapat dicocokkan dengan melengkapi himpunan. Jika karakter pertama himpunan adalah ^, semua karakter yang tidak ada dalam himpunan akan dicocokkan.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## Mencocokkan karakter apa pun kecuali 5
re.search(r'Number: [^5]', 'Number: 0').group()

## Ini tidak akan cocok sehingga nilai NONE akan dikembalikan
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ - Backslash.
Barangkali, metakarakter paling beragam!!

• Jika karakter setelah backslash adalah karakter escape yang dikenali, maka makna khusus istilah tersebut diambil (Skenario 1)
• Jika tidak, bila karakter setelah \ bukan karakter escape yang dikenali, maka \ diperlakukan seperti karakter biasa dan diteruskan (Skenario 2).
• \ dapat digunakan di depan semua metakarakter untuk menghapus makna khususnya (Skenario 3).

## (Skenario 1) Ini memperlakukan '\s' sebagai karakter escape, '\s' mendefinisikan spasi
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Skenario 2) '\' diperlakukan sebagai karakter biasa, karena '\r' bukan karakter escape yang dikenali
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Skenario 3) '\s' di-escape menggunakan `\` ekstra sehingga ditafsirkan sebagai string literal '\s'
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

Ada himpunan urutan khusus yang telah ditentukan yang diawali dengan '\' dan juga sangat membantu saat melakukan pencarian dan pencocokan. Mari lihat beberapa di antaranya lebih dekat...

\w - Huruf kecil 'w'. Mencocokkan satu huruf, digit, atau garis bawah.
\W - Huruf besar 'W'. Mencocokkan karakter apa pun yang bukan bagian dari \w (w kecil).

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Mencocokkan karakter apa pun kecuali huruf tunggal, digit, atau garis bawah
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## Huruf besar W tidak akan mencocokkan huruf tunggal, digit
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - Huruf kecil 's'. Mencocokkan satu karakter spasi putih seperti: spasi, baris baru, tab, return.
\S - Huruf besar 'S'. Mencocokkan karakter apa pun yang bukan bagian dari \s (s kecil).

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d - Huruf kecil d. Mencocokkan digit desimal 0-9.
\D - Huruf besar d. Mencocokkan karakter apa pun yang bukan digit desimal.

# Contoh untuk \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

Simbol + yang digunakan setelah \d pada contoh di atas digunakan untuk pengulangan. Anda akan melihat ini lebih detail di bagian pengulangan nanti...

\t - Huruf kecil t. Mencocokkan tab.
\n - Huruf kecil n. Mencocokkan baris baru.
\r - Huruf kecil r. Mencocokkan return.
\A - Huruf besar a. Mencocokkan hanya di awal string. Bekerja di banyak baris juga.
\Z - Huruf besar z. Mencocokkan hanya di akhir string.
TIP: ^ dan \A pada dasarnya sama, begitu juga $ dan \Z. Kecuali saat menggunakan mode MULTILINE. Pelajari lebih lanjut di bagian flag.

\b - Huruf kecil b. Mencocokkan hanya awal atau akhir kata.

# Contoh untuk \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Contoh untuk \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Pengulangan

Akan menjadi cukup melelahkan jika Anda ingin menemukan pola panjang dalam suatu urutan. Untungnya, modul re menangani pengulangan menggunakan karakter khusus berikut:

+ - Memeriksa apakah karakter sebelumnya muncul satu kali atau lebih mulai dari posisi itu.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* - Memeriksa apakah karakter sebelumnya muncul nol kali atau lebih mulai dari posisi itu.

# Memeriksa kemunculan a atau o atau keduanya dalam urutan yang diberikan
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? - Memeriksa apakah karakter sebelumnya muncul tepat nol atau satu kali mulai dari posisi itu.

# Memeriksa tepat nol atau satu kemunculan a atau o atau keduanya dalam urutan yang diberikan
re.search(r'Colou?r', 'Color').group()

'Color'

Tetapi bagaimana jika Anda ingin memeriksa jumlah pengulangan urutan yang tepat?

Misalnya, memeriksa validitas nomor telepon dalam sebuah aplikasi. Modul re juga menangani ini dengan baik menggunakan ekspresi reguler berikut:

{x} - Ulangi tepat x kali.
{x,} - Ulangi setidaknya x kali atau lebih.
{x, y} - Ulangi setidaknya x kali tetapi tidak lebih dari y kali.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

Kualifikasi + dan * disebut greedy. Anda akan melihat artinya nanti.

Pengelompokan dalam Ekspresi Reguler

Fitur group pada ekspresi reguler memungkinkan Anda mengambil bagian dari teks yang cocok. Bagian dari pola ekspresi reguler yang dibatasi oleh tanda kurung () disebut grup. Tanda kurung tidak mengubah apa yang dicocokkan oleh ekspresi, tetapi membentuk grup dalam urutan yang cocok. Anda telah menggunakan fungsi group() sepanjang contoh dalam tutorial ini. match.group() polos tanpa argumen tetap merupakan seluruh teks yang cocok seperti biasa.

Mari pahami konsep ini dengan contoh sederhana. Bayangkan Anda sedang memvalidasi alamat email dan ingin memeriksa nama pengguna dan host. Di sinilah Anda ingin membuat grup terpisah dalam teks yang cocok Anda.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # Teks cocok seluruhnya
  print("Username:", match.group(1)) # Username (grup 1)
  print("Host:", match.group(2)) # Host (grup 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Cara lain untuk melakukan hal yang sama adalah dengan menggunakan tanda kurung <>. Ini memungkinkan Anda membuat grup bernama. Grup bernama akan membuat kode Anda lebih mudah dibaca. Sintaks untuk membuat grup bernama adalah: (?P<name>...). Ganti bagian name dengan nama yang ingin Anda berikan pada grup Anda. ... mewakili sisa sintaks pencocokan. Lihat ini beraksi menggunakan contoh yang sama seperti sebelumnya...

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

TIP: Anda selalu dapat mengakses grup bernama menggunakan angka alih-alih nama. Namun saat jumlah grup bertambah, akan semakin sulit menanganinya hanya dengan angka. Jadi, biasakan menggunakan grup bernama.

Pencocokan Greedy vs. Non-Greedy

Ketika karakter khusus mencocokkan sebanyak mungkin bagian dari urutan pencarian (string), itu disebut "Greedy Match". Ini adalah perilaku normal ekspresi reguler, tetapi terkadang perilaku ini tidak diinginkan:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

Pola <.*> mencocokkan seluruh string, hingga kemunculan kedua >.

Namun, jika Anda hanya ingin mencocokkan tag <h1> pertama, Anda dapat menggunakan pengubah greedy *? yang mencocokkan sesedikit mungkin teks.

Menambahkan ? setelah pengubah membuatnya melakukan pencocokan secara non-greedy atau minimal; Artinya, sesedikit mungkin karakter yang akan dicocokkan. Saat Anda menjalankan <.*>, Anda hanya akan mendapatkan kecocokan dengan <h1>.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Tabel Ringkasan

Anda sudah menempuh perjalanan panjang dengan ekspresi reguler. Banyak informasi dan konsep yang harus dipahami! Tabel berikut merangkum semua yang telah Anda lihat sejauh ini dalam tutorial ini. Jangan khawatir jika Anda belum bisa memahami semua metakarakter saat ini. Dengan waktu dan latihan, Anda akan mampu melihat keunikan karakter-karakter ini dan belajar kapan menggunakan yang mana...

Tutorial ini tidak membahas semua urutan khusus yang disediakan di Python. Lihat referensi Pustaka Standar untuk daftar lengkap.

Anda telah menaklukkan dasar-dasar regex! Namun, masih ada beberapa konsep lagi yang dapat membantu Anda dalam membuat ekspresi reguler yang andal untuk pencarian dan pencocokan.

TIP: Walaupun ekspresi reguler sangat kuat dan membantu, berhati-hatilah terhadap ekspresi yang panjang dan membingungkan yang sulit dipahami dan dipelihara oleh orang lain, maupun oleh Anda sendiri, seiring waktu.

Fungsi yang Disediakan oleh 're'

Pustaka re di Python menyediakan beberapa fungsi untuk mempermudah tugas Anda. Anda sudah melihat beberapa di antaranya, seperti re.search(), re.match(). Mari kita lihat lebih lanjut...

compile(pattern, flags=0)

Ekspresi reguler ditangani sebagai string oleh Python. Namun, dengan compile(), Anda dapat mengompilasi pola ekspresi reguler menjadi objek ekspresi reguler. Saat Anda perlu menggunakan sebuah ekspresi beberapa kali dalam satu program, menggunakan compile() untuk menyimpan objek ekspresi reguler yang dihasilkan agar digunakan kembali lebih efisien daripada menyimpannya sebagai string. Ini karena versi terkompilasi dari pola terbaru yang dilewatkan ke compile() dan fungsi pencocokan tingkat modul di-cache.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# Ini setara dengan:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Dengan fungsi ini, Anda memindai string/urutan yang diberikan, mencari lokasi pertama tempat ekspresi reguler menghasilkan kecocokan. Ia mengembalikan objek match yang sesuai jika ditemukan, jika tidak mengembalikan None jika tidak ada posisi dalam string yang cocok dengan pola. Perhatikan bahwa None berbeda dari menemukan kecocokan berdurasi nol di suatu titik dalam string.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Mengembalikan objek match yang sesuai jika nol atau lebih karakter di awal string cocok dengan pola. Jika tidak, mengembalikan None, jika string tidak cocok dengan pola yang diberikan.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# Tidak cocok karena "C" tidak berada di awal "IceCream"
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() versus match()

Fungsi match() memeriksa kecocokan hanya di awal string (secara default), sedangkan fungsi search() memeriksa kecocokan di mana saja dalam string.

findall(pattern, string, flags=0)

Menemukan semua kecocokan yang mungkin dalam seluruh urutan dan mengembalikannya sebagai daftar string. Setiap string yang dikembalikan mewakili satu kecocokan.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' adalah daftar yang menyimpan semua kecocokan yang mungkin
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Mirip dengan findall() — menemukan semua kecocokan yang mungkin dalam seluruh urutan tetapi mengembalikan objek match regex sebagai iterator.

TIP: finditer() bisa menjadi pilihan yang sangat baik ketika Anda ingin lebih banyak informasi dikembalikan tentang pencarian Anda. Objek match regex yang dikembalikan tidak hanya menyimpan urutan yang cocok tetapi juga posisinya dalam teks asli.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' adalah daftar yang menyimpan semua kecocokan yang mungkin
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() adalah fungsi substitute. Ia mengembalikan string yang diperoleh dengan mengganti atau mensubstitusi kemunculan paling kiri yang tidak tumpang tindih dari pola dalam string dengan pengganti repl. Jika pola tidak ditemukan, maka string dikembalikan tanpa perubahan.

subn() mirip dengan sub(). Namun, ia mengembalikan tuple yang berisi nilai string baru dan jumlah penggantian yang dilakukan dalam pernyataan.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Ini membagi string di mana pun pola cocok dan mengembalikan daftar. Jika argumen opsional maxsplit tidak nol, maka pembagian maksimal sejumlah 'maxsplit' dilakukan.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Mengembalikan indeks awal kecocokan.
end() - Mengembalikan indeks tempat kecocokan berakhir.
span() - Mengembalikan tuple yang berisi posisi (awal, akhir) kecocokan.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Flag Kompilasi

Apakah Anda memperhatikan istilah re.IGNORECASE pada contoh terakhir? Apakah Anda memahami pentingnya?

Perilaku sebuah ekspresi dapat diubah dengan menentukan nilai flag. Anda dapat menambahkan flag sebagai argumen tambahan ke berbagai fungsi yang telah Anda lihat dalam tutorial ini. Beberapa yang lebih berguna adalah:

IGNORECASE (I) - Memungkinkan pencocokan tidak peka huruf besar-kecil.
DOTALL (S) - Memungkinkan . mencocokkan karakter apa pun, termasuk baris baru.
MULTILINE (M) - Memungkinkan jangkar awal string (^) dan akhir string ($) juga mencocokkan baris baru.
VERBOSE (X) - Memungkinkan Anda menulis spasi putih dan komentar di dalam ekspresi reguler untuk membuatnya lebih mudah dibaca.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Menggunakan flag VERBOSE membantu memahami ekspresi reguler yang kompleks
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

TIP: Anda juga dapat menggabungkan beberapa flag menggunakan bitwise OR |.

Studi Kasus: Bekerja dengan Ekspresi Reguler

Sekarang setelah Anda melihat bagaimana ekspresi reguler bekerja di Python melalui beberapa contoh, saatnya untuk praktik langsung! Dalam studi kasus ini, Anda akan mempraktikkan semua pengetahuan Anda.

Anda akan bekerja dengan bagian pertama dari e-book gratis berjudul "The Idiot", ditulis oleh Fyodor Dostoyevsky dari Project Gutenberg. Novel ini tentang Pangeran (Knyaz) Lev Nikolayevich Myshkin, seorang pria polos yang sifatnya baik, ramah, dan sederhana secara keliru membuat banyak orang percaya bahwa ia kurang kecerdasan dan wawasan. Judulnya adalah referensi ironis terhadap pemuda ini.

Anda akan menulis beberapa ekspresi reguler untuk mengurai teks dan menyelesaikan beberapa latihan.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Latihan: Temukan jumlah kata ganti "the" dalam korpus. Petunjuk: Gunakan fungsi len().

len(re.findall(r'the', processed_book))

302

• Latihan: Cobalah mengonversi setiap kemunculan tunggal 'i' yang berdiri sendiri menjadi 'I' dalam korpus. Pastikan tidak mengubah 'i' yang muncul di dalam sebuah kata:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Latihan: Temukan berapa kali seseorang dikutip ("") dalam korpus.

len(re.findall(r'\”', book))

0

• Latihan: Apa kata-kata yang dihubungkan oleh '--' dalam korpus?
  Coba sendiri! Jangan ragu untuk berbagi jawaban Anda di kolom komentar di bawah.

Selamat!

Anda telah mencapai akhir tutorial ekspresi reguler Python ini! Masih banyak yang bisa dipelajari dalam perjalanan data science Anda dengan Python.

Regex dapat berperan penting pada fase pra-pemrosesan data. Lihat kursus Cleaning Data in Python dari DataCamp. Kursus ini mengajarkan cara mengeksplorasi data Anda dengan lebih baik dengan merapikan dan membersihkannya untuk keperluan analisis data. Kursus ini juga mencakup studi kasus di akhir di mana Anda dapat mempraktikkan pengetahuan baru Anda.

Lihat juga Tutorial Penggantian String Python kami.