5. Bekerja dengan Teks Menggunakan String

Teks ada di mana-mana dalam pemrograman. Dari menampilkan pesan ke pengguna, memproses file data, sampai membangun aplikasi web, bekerja dengan teks adalah salah satu keterampilan paling dasar yang akan kamu kembangkan sebagai programmer. Di Python, kita bekerja dengan teks menggunakan string — urutan karakter yang dapat merepresentasikan kata, kalimat, atau data tekstual apa pun.

Kamu sudah pernah bertemu string secara singkat di bab-bab sebelumnya saat menggunakan print() dan input(). Sekarang kita akan mengeksplorasi string secara mendalam, mempelajari cara membuatnya, memanipulasinya, dan menggunakan kemampuan string bawaan Python yang kuat untuk menyelesaikan masalah pemrosesan teks di dunia nyata.

Di bab ini, kamu akan belajar cara membuat string dengan karakter khusus, menggabungkan string, mengambil bagian tertentu dari string, mengubah huruf besar-kecil dan formatnya, mencari teks di dalam string, dan memahami mengapa string berperilaku berbeda dari angka dalam hal modifikasi. Di akhir bab, kamu akan memiliki fondasi yang kuat untuk bekerja dengan teks di Python.

5.1) String Literal dan Escape Sequence

5.1.1) Membuat String Literal

String literal adalah nilai string yang ditulis langsung di dalam kode. Kamu sudah melihat string yang dibuat dengan tanda petik tunggal (') atau tanda petik ganda ("):

python

# string_basics.py
greeting = 'Hello, World!'
message = "Python is great!"
 
print(greeting)  # Output: Hello, World!
print(message)   # Output: Python is great!

Tanda petik tunggal dan ganda bekerja sama persis di Python — pilihannya terserah kamu. Namun, memiliki kedua opsi ini berguna ketika string kamu sendiri berisi karakter tanda petik:

python

# quotes_in_strings.py
# Menggunakan tanda petik ganda ketika string berisi tanda petik tunggal
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Menggunakan tanda petik tunggal ketika string berisi tanda petik ganda
quote = 'She said, "Hello!"'
print(quote)  # Output: She said, "Hello!"

Jika kamu perlu menyertakan jenis tanda petik yang sama dengan pembatas string, kamu bisa meng-escape tanda petik itu dengan backslash (\):

python

# escaping_quotes.py
# Meng-escape tanda petik tunggal di dalam string ber-petik tunggal
sentence = 'It\'s a beautiful day!'
print(sentence)  # Output: It's a beautiful day!
 
# Meng-escape tanda petik ganda di dalam string ber-petik ganda
quote = "She said, \"Hello!\""
print(quote)  # Output: She said, "Hello!"

Backslash memberi tahu Python bahwa tanda petik berikutnya adalah bagian dari isi string, bukan akhir dari string.

5.1.2) String Multi-Baris dengan Triple Quotes

Untuk string yang membentang di beberapa baris, Python menyediakan triple quotes — tiga tanda petik tunggal (''') atau tiga tanda petik ganda ("""):

python

# multiline_strings.py
poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you!"""
 
print(poem)
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you!

String dengan triple quotes mempertahankan semua pemisah baris dan spasi persis seperti yang kamu ketik. Ini sangat berguna untuk blok teks yang panjang, documentation string (yang akan kita lihat di Bab 19), atau ketika kamu perlu menyertakan tanda petik tunggal dan ganda tanpa meng-escape:

python

# triple_quotes_convenience.py
dialogue = '''The teacher said, "Don't forget: it's important to practice!"'''
print(dialogue)  # Output: The teacher said, "Don't forget: it's important to practice!"

5.1.3) Escape Sequence yang Umum

Selain meng-escape tanda petik, backslash juga memperkenalkan escape sequence — kombinasi dua karakter khusus yang merepresentasikan karakter yang sulit atau tidak mungkin diketik secara langsung:

python

# escape_sequences.py
# Newline: pindah ke baris berikutnya
print("First line\nSecond line")
# Output:
# First line
# Second line
 
# Tab: menyisipkan spasi horizontal
print("Name:\tJohn\nAge:\t25")
# Output:
# Name:	John
# Age:	25
 
# Backslash: untuk menyertakan backslash literal
path = "C:\\Users\\Documents"
print(path)  # Output: C:\Users\Documents

Berikut escape sequence yang paling sering digunakan:

Escape Sequence	Arti	Contoh Output
`\n`	Newline (pemisah baris)	Dua baris
`\t`	Tab (spasi horizontal)	Teks menjorok
`\\`	Backslash	karakter `\`
`\'`	Tanda petik tunggal	karakter `'`
`\"`	Tanda petik ganda	karakter `"`

Memahami escape sequence sangat penting saat bekerja dengan path file (terutama di Windows, yang menggunakan backslash), output terformat, atau teks apa pun yang membutuhkan format khusus.

5.1.4) Raw String untuk Backslash Literal

Kadang kamu ingin backslash diperlakukan secara literal, tanpa memicu escape sequence. Ini umum ketika bekerja dengan path file atau regular expression (yang akan kita singgung di Bab 39). Python menyediakan raw string dengan menambahkan prefiks r pada string:

python

# raw_strings.py
# String biasa: backslash memicu escape sequence
regular = "C:\new\test"
print(regular)  # Output: C:
                #         ew   est
                # (\n menjadi newline, \t menjadi tab)
 
# Raw string: backslash bersifat literal
raw = r"C:\new\test"
print(raw)  # Output: C:\new\test

Dalam raw string, \n secara harfiah adalah dua karakter backslash dan n, bukan newline. Raw string sangat berguna untuk path file di Windows:

python

# windows_paths.py
# Tanpa raw string, kamu harus meng-escape setiap backslash
path1 = "C:\\Users\\John\\Documents\\file.txt"
 
# Dengan raw string, backslash bekerja secara alami
path2 = r"C:\Users\John\Documents\file.txt"
 
print(path1)  # Output: C:\Users\John\Documents\file.txt
print(path2)  # Output: C:\Users\John\Documents\file.txt

Kedua pendekatan menghasilkan hasil yang sama, tetapi raw string lebih mudah dibaca ketika kamu memiliki banyak backslash.

5.2) Konkatenasi dan Pengulangan String

5.2.1) Menggabungkan String dengan +

Kamu dapat menggabungkan string menggunakan operator +, yang disebut concatenation (konkatenasi):

python

# string_concatenation.py
first_name = "John"
last_name = "Smith"
 
# Menggabungkan string dengan +
full_name = first_name + " " + last_name
print(full_name)  # Output: John Smith
 
# Membangun string yang lebih panjang
greeting = "Hello, " + full_name + "!"
print(greeting)  # Output: Hello, John Smith!

Konkatenasi membuat string baru dengan menempatkan string-string tersebut berurutan dari ujung ke ujung. Perhatikan bahwa Python tidak otomatis menambahkan spasi — kamu harus menyertakannya secara eksplisit:

python

# concatenation_spacing.py
word1 = "Hello"
word2 = "World"
 
# Tanpa spasi
no_space = word1 + word2
print(no_space)  # Output: HelloWorld
 
# Dengan spasi
with_space = word1 + " " + word2
print(with_space)  # Output: Hello World

Kamu dapat menggabungkan sebanyak mungkin string dalam satu ekspresi:

python

# multiple_concatenation.py
address = "123" + " " + "Main" + " " + "Street"
print(address)  # Output: 123 Main Street

Batasan penting: Kamu hanya dapat menggabungkan string dengan string lainnya. Mencoba menggabungkan string dengan angka akan menyebabkan error:

python

# concatenation_error.py
age = 25
# Ini akan menyebabkan error:
# message = "I am " + age + " years old"  # TypeError!
 
# Kamu harus mengonversi angka ke string terlebih dahulu
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Kita akan mengeksplorasi konversi string-angka lebih lanjut di Bagian 5.6.

5.2.2) Mengulang String dengan *

Python menyediakan cara praktis untuk mengulang sebuah string beberapa kali menggunakan operator *:

python

# string_repetition.py
separator = "-" * 20
print(separator)  # Output: --------------------
 
# Membuat pola
pattern = "abc" * 3
print(pattern)  # Output: abcabcabc
 
# Berguna untuk format output
print("=" * 30)
print("Important Message")
print("=" * 30)
# Output:
# ==============================
# Important Message
# ==============================

Operator pengulangan bekerja dengan bilangan bulat positif apa pun:

python

# repetition_examples.py
# Mengulang nol kali menghasilkan string kosong
nothing = "Hello" * 0
print(nothing)      # Output: (string kosong)
print(len(nothing)) # Output: 0
 
# Mengulang sekali menghasilkan string asli
once = "Hello" * 1
print(once)  # Output: Hello
 
# Pengulangan lebih besar
many = "Go! " * 5
print(many)  # Output: Go! Go! Go! Go! Go!

Pengulangan string sangat berguna untuk membuat pemisah visual, padding, atau menghasilkan data uji:

python

# practical_repetition.py
# Membuat kotak teks sederhana
width = 40
border = "=" * width
title = "Welcome"
padding = " " * ((width - len(title)) // 2)
 
print(border)
print(padding + title)
print(border)
# Output:
# ========================================
#                 Welcome
# ========================================

5.2.3) Menggabungkan Konkatenasi dan Pengulangan

Kamu dapat menggabungkan kedua operator dalam satu ekspresi, mengikuti aturan prioritas operator Python (perkalian sebelum penjumlahan, sama seperti pada angka):

python

# combined_operations.py
# Pengulangan terjadi dulu, lalu konkatenasi
result = "=" * 10 + " Title " + "=" * 10
print(result)  # Output: ========== Title ==========
 
# Menggunakan tanda kurung untuk mengontrol urutan
repeated_phrase = ("Hello " + "World ") * 3
print(repeated_phrase)  # Output: Hello World Hello World Hello World

Operasi ini membentuk dasar manipulasi string, memungkinkan kamu membangun string kompleks dari potongan sederhana.

5.3) Indexing dan Slicing String

String di Python adalah sequence (urutan) karakter, yang berarti setiap karakter memiliki posisi tertentu. Kamu dapat mengakses karakter individual atau mengambil bagian dari string menggunakan indexing dan slicing.

5.3.1) Memahami Indeks String

Setiap karakter dalam string memiliki posisi numerik yang disebut index (indeks). Python menggunakan zero-based indexing (indeks mulai dari nol), artinya karakter pertama berada di indeks 0, yang kedua di indeks 1, dan seterusnya:

python

# string_indexing.py
text = "Python"
 
# Mengakses karakter individual berdasarkan indeks
print(text[0])  # Output: P (karakter pertama)
print(text[1])  # Output: y (karakter kedua)
print(text[5])  # Output: n (karakter keenam)

Berikut representasi visual bagaimana indeks dipetakan ke karakter:

String:  P  y  t  h  o  n
Index:   0  1  2  3  4  5

Python juga mendukung indeks negatif, yang menghitung dari akhir string. Indeks -1 merujuk ke karakter terakhir, -2 ke karakter kedua dari belakang, dan seterusnya:

python

# negative_indexing.py
text = "Python"
 
print(text[-1])  # Output: n (karakter terakhir)
print(text[-2])  # Output: o (karakter kedua dari belakang)
print(text[-6])  # Output: P (karakter pertama)

Indeks negatif sangat berguna ketika kamu ingin mengakses karakter di dekat akhir string tanpa mengetahui panjangnya secara tepat:

String:    P  y  t  h  o  n
Positive:  0  1  2  3  4  5
Negative: -6 -5 -4 -3 -2 -1

Penting: Mencoba mengakses indeks yang tidak ada akan menyebabkan IndexError:

python

# index_error.py
text = "Python"
 
# Ini baik-baik saja
print(text[5])  # Output: n
 
# Ini menyebabkan error karena indeks 6 tidak ada
# print(text[6])  # IndexError: string index out of range

5.3.2) Slicing String untuk Mengambil Substring

Indexing memberi satu karakter, sedangkan slicing memungkinkan kamu mengambil sebagian string (disebut substring). Sintaks dasarnya:

string[start:stop]

Ini mengambil karakter dari indeks start sampai (tetapi tidak termasuk) indeks stop:

python

# basic_slicing.py
text = "Python Programming"
 
# Mengambil karakter dari indeks 0 sampai (tidak termasuk) 6
print(text[0:6])  # Output: Python
 
# Mengambil karakter dari indeks 7 sampai 18
print(text[7:18])  # Output: Programming
 
# Mengambil bagian tengah
print(text[7:11])  # Output: Prog

Hal utama yang perlu diingat adalah bahwa indeks stop tidak termasuk dalam hasil. Bayangkan indeks sebagai posisi di antara karakter:

 P  y  t  h  o  n
 0  1  2  3  4  5  6

Jadi text[0:6] berarti "mulai di posisi 0 dan berhenti sebelum posisi 6", memberikan karakter di posisi 0, 1, 2, 3, 4, dan 5.

5.3.3) Menghilangkan Indeks Start atau Stop

Kamu dapat menghilangkan indeks start untuk melakukan slice dari awal, atau menghilangkan indeks stop untuk slice sampai akhir:

python

# omitting_indices.py
text = "Python Programming"
 
# Dari awal sampai indeks 6
print(text[:6])  # Output: Python
 
# Dari indeks 7 sampai akhir
print(text[7:])  # Output: Programming
 
# Seluruh string (dari awal sampai akhir)
print(text[:])  # Output: Python Programming

Shortcut ini sangat umum dalam kode Python karena membuat maksud lebih jelas dan menghindari hardcode panjang string.

5.3.4) Menggunakan Indeks Negatif dalam Slice

Indeks negatif juga bekerja dalam slice, memungkinkan kamu menghitung dari akhir:

python

# negative_slice_indices.py
text = "Python Programming"
 
# 11 karakter terakhir
print(text[-11:])  # Output: Programming
 
# Semua kecuali 11 karakter terakhir
print(text[:-11])  # Output: Python
 
# 7 karakter terakhir
print(text[-7:])  # Output: ramming
 
# Dari indeks 7 sampai karakter ketiga dari belakang
print(text[7:-3])  # Output: Programm (berhenti sebelum 'ing')

Indeks negatif sangat berguna ketika kamu ingin mengecualikan sejumlah karakter dari akhir:

python

# removing_suffix.py
filename = "document.txt"
 
# Mengambil semua kecuali 4 karakter terakhir (.txt)
name_without_extension = filename[:-4]
print(name_without_extension)  # Output: document

5.3.5) Slicing dengan Nilai Step

Slice dapat menyertakan nilai ketiga yang disebut step, yang menentukan berapa banyak karakter yang dilewati:

string[start:stop:step]

python

# slicing_with_step.py
text = "Python Programming"
 
# Setiap karakter kedua dari seluruh string
print(text[::2])  # Output: Pto rgamn
 
# Setiap karakter kedua dari indeks 0 sampai 6
print(text[0:6:2])  # Output: Pto
 
# Setiap karakter ketiga
print(text[::3])  # Output: Ph oai

Trik yang sangat berguna adalah menggunakan step -1 untuk membalik string:

python

# reversing_strings.py
text = "Python"
 
# Membalik seluruh string
reversed_text = text[::-1]
print(reversed_text)  # Output: nohtyP
 
# Contoh praktis: memeriksa palindrome
word = "radar"
if word == word[::-1]:
    print(f"{word} is a palindrome!")  # Output: radar is a palindrome!

5.3.6) Slicing Tidak Pernah Menyebabkan Error

Berbeda dengan indexing, slicing sangat toleran. Jika kamu memberikan indeks yang berada di luar jangkauan, Python akan menyesuaikannya agar sesuai:

python

# safe_slicing.py
text = "Python"
 
# Semua ini berjalan tanpa error
print(text[0:100])   # Output: Python (berhenti di akhir)
print(text[10:20])   # Output: (string kosong - start di luar akhir)
print(text[-100:3])  # Output: Pyt (start disesuaikan ke 0)

Perilaku ini membuat slicing aman digunakan bahkan ketika kamu tidak yakin dengan panjang string yang tepat.

5.3.7) Contoh Slicing Praktis

Berikut beberapa pola umum yang akan sering kamu gunakan:

python

# practical_slicing.py
text = "Hello, World!"
 
# 5 karakter pertama
print(text[:5])  # Output: Hello
 
# 6 karakter terakhir
print(text[-6:])  # Output: World!
 
# Semua kecuali karakter pertama dan terakhir
print(text[1:-1])  # Output: ello, World
 
# Setiap karakter lainnya
print(text[::2])  # Output: Hlo ol!
 
# Membalik string
print(text[::-1])  # Output: !dlroW ,olleH

Memahami indexing dan slicing adalah dasar pemrosesan teks di Python. Teknik ini akan sering muncul sepanjang perjalanan pemrogramanmu.

5.4) Method String Umum untuk Huruf Besar-Kecil dan Whitespace

String Python memiliki banyak method bawaan — fungsi yang menempel pada objek string dan melakukan operasi pada string tersebut. Di bagian ini, kita akan mengeksplorasi method untuk mengubah huruf besar-kecil dan mengelola whitespace, yang penting untuk membersihkan dan memformat teks.

5.4.1) Memahami Method String

Sebuah method dipanggil menggunakan notasi titik: string.method_name(). Method adalah fungsi yang dimiliki tipe objek tertentu. Untuk string, Python menyediakan banyak method yang berguna:

python

# method_basics.py
text = "hello"
 
# Memanggil method pada string
result = text.upper()
print(result)  # Output: HELLO
 
# String asli tidak berubah (kita akan bahas alasannya di Bagian 5.8)
print(text)  # Output: hello

Method dapat dirangkai (chaining) karena setiap method mengembalikan string baru:

python

# method_chaining.py
text = "  hello world  "
 
# Merangkai beberapa method
result = text.strip().upper().replace("WORLD", "PYTHON")
print(result)  # Output: HELLO PYTHON

5.4.2) Method Konversi Huruf Besar-Kecil

Python menyediakan beberapa method untuk mengubah huruf besar-kecil string:

python

# case_methods.py
text = "Python Programming"
 
# Mengubah ke huruf besar semua
print(text.upper())  # Output: PYTHON PROGRAMMING
 
# Mengubah ke huruf kecil semua
print(text.lower())  # Output: python programming
 
# Huruf pertama kapital, sisanya huruf kecil
print(text.capitalize())  # Output: Python programming
 
# Title case: huruf pertama tiap kata kapital
print(text.title())  # Output: Python Programming

Method ini sangat berguna untuk menstandarkan input pengguna:

python

# case_normalization.py
# Mensimulasikan input pengguna
user_input = "YES"
 
# Perbandingan yang tidak peka huruf besar-kecil
if user_input.lower() == "yes":
    print("User confirmed!")  # Output: User confirmed!
 
# Pendekatan lain menggunakan upper()
command = "start"
if command.upper() == "START":
    print("Starting process...")  # Output: Starting process...

Method title() membuat huruf pertama tiap kata menjadi kapital, yang berguna untuk memformat nama dan judul:

python

# title_case.py
name = "john smith"
print(name.title())  # Output: John Smith
 
book = "the great gatsby"
print(book.title())  # Output: The Great Gatsby

Namun, perlu diingat bahwa title() memiliki keterbatasan untuk apostrof dan kasus khusus:

python

# title_limitations.py
text = "it's a beautiful day"
print(text.title())  # Output: It'S A Beautiful Day (perhatikan huruf S besar)
 
# Untuk title case yang lebih canggih, kamu mungkin perlu logika kustom

Method capitalize() hanya mengkapitalisasi karakter paling pertama dari seluruh string:

python

# capitalize_examples.py
sentence = "python is great"
print(sentence.capitalize())  # Output: Python is great
 
# Catatan: hanya huruf pertama yang kapital
multi_word = "hello world"
print(multi_word.capitalize())  # Output: Hello world (bukan Hello World)

5.4.3) Method Pengecekan Huruf Besar-Kecil

Python juga menyediakan method untuk mengecek huruf besar-kecil string:

python

# case_checking.py
text1 = "HELLO"
text2 = "hello"
text3 = "Hello World"
 
# Mengecek apakah semua karakter huruf besar
print(text1.isupper())  # Output: True
print(text2.isupper())  # Output: False
 
# Mengecek apakah semua karakter huruf kecil
print(text1.islower())  # Output: False
print(text2.islower())  # Output: True
 
# Mengecek apakah string dalam bentuk title case
print(text3.istitle())  # Output: True
print(text2.istitle())  # Output: False

Method pengecekan ini mengembalikan True atau False (nilai Boolean yang telah kita pelajari di Bab 3), sehingga sangat cocok untuk kondisi:

python

# case_checking_conditions.py
password = "SECRET123"
 
if password.isupper():
    print("Password is all uppercase")  # Output: Password is all uppercase

5.4.4) Method Penghapusan Whitespace

Whitespace mencakup spasi, tab (\t), dan newline (\n). Python menyediakan method untuk menghapus whitespace dari tepi string:

python

# whitespace_removal.py
text = "   Hello, World!   "
 
# Menghapus whitespace dari kedua sisi
print(text.strip())  # Output: Hello, World!
 
# Menghapus whitespace dari kiri (awal)
print(text.lstrip())  # Output: Hello, World!   
 
# Menghapus whitespace dari kanan (akhir)
print(text.rstrip())  # Output:    Hello, World!

Method strip() sangat berguna untuk membersihkan input pengguna:

python

# cleaning_input.py
# Mensimulasikan input pengguna dengan spasi ekstra
user_name = "  John Smith  "
 
# Membersihkan input
clean_name = user_name.strip()
print(f"Welcome, {clean_name}!")  # Output: Welcome, John Smith!

Method ini juga menghapus tab dan newline:

python

# strip_all_whitespace.py
text = "\n\t  Hello  \t\n"
print(repr(text))  # Output: '\n\t  Hello  \t\n'
 
cleaned = text.strip()
print(repr(cleaned))  # Output: 'Hello'

Perhatikan bahwa strip(), lstrip(), dan rstrip() hanya menghapus whitespace dari tepi, bukan dari tengah:

python

# strip_edges_only.py
text = "  Hello   World  "
print(text.strip())  # Output: Hello   World (spasi di tengah tetap)

5.4.5) Menghapus Karakter Tertentu

Method strip juga dapat menghapus karakter tertentu (bukan hanya whitespace) dari tepi:

python

# Remove multiple different characters
text = "...Hello!!!"
cleaned = text.strip(".!")
print(cleaned)  # Output: Hello

Saat kamu memberikan sebuah string ke strip(), method ini akan menghapus kombinasi karakter apa pun dari himpunan tersebut di bagian tepi:

python

# strip_character_set.py
text = "xxxyyyHelloyyyxxx"
 
# Menghapus x atau y dari kedua sisi
result = text.strip("xy")
print(result)  # Output: Hello

5.4.6) Contoh Praktis Menggabungkan Method Huruf Besar-Kecil dan Whitespace

Berikut skenario dunia nyata di mana method ini sangat berguna:

python

# practical_text_cleaning.py
# Membersihkan dan menstandarkan input pengguna
user_email = "  JohnSmith@EXAMPLE.com  "
clean_email = user_email.strip().lower()
print(clean_email)  # Output: johnsmith@example.com
 
# Memformat nama dengan benar
raw_name = "  john smith  "
formatted_name = raw_name.strip().title()
print(formatted_name)  # Output: John Smith
 
# Memproses command (tidak peka huruf besar-kecil)
command = "  START  "
if command.strip().upper() == "START":
    print("Command recognized!")  # Output: Command recognized!

Method ini membentuk fondasi pembersihan dan normalisasi teks, yang akan sering kamu gunakan ketika memproses input pengguna, membaca file, atau menyiapkan data untuk analisis.

5.5) Mencari dan Mengganti Teks dalam String

Menemukan dan memodifikasi teks di dalam string adalah tugas umum dalam pemrograman. Python menyediakan method kuat untuk mencari substring dan mengganti teks.

5.5.1) Menemukan Substring dengan find() dan index()

Method find() mencari substring dan mengembalikan indeks di mana substring pertama kali muncul:

python

# find_method.py
text = "Python is great. Python is powerful."
 
# Menemukan kemunculan pertama "Python"
position = text.find("Python")
print(position)  # Output: 0 (ditemukan di awal)
 
# Menemukan "great"
position = text.find("great")
print(position)  # Output: 10
 
# Menemukan sesuatu yang tidak ada
position = text.find("Java")
print(position)  # Output: -1 (tidak ditemukan)

Method find() mengembalikan -1 jika substring tidak ditemukan, sehingga aman digunakan tanpa menyebabkan error:

python

# safe_searching.py
text = "Hello, World!"
 
# Mengecek apakah substring ada
if text.find("World") != -1:
    print("Found 'World'!")  # Output: Found 'World'!
 
if text.find("Python") == -1:
    print("'Python' not found")  # Output: 'Python' not found

Kamu juga dapat mencari substring mulai dari posisi tertentu:

python

# find_with_start.py
text = "Python is great. Python is powerful."
 
# Menemukan kemunculan pertama
first = text.find("Python")
print(first)  # Output: 0
 
# Menemukan kemunculan berikutnya setelah yang pertama
second = text.find("Python", first + 1)
print(second)  # Output: 17

Method index() bekerja mirip find(), tetapi akan melempar error jika substring tidak ditemukan:

python

# index_method.py
text = "Hello, World!"
 
# Ini baik-baik saja
position = text.index("World")
print(position)  # Output: 7
 
# Ini akan menyebabkan ValueError:
# position = text.index("Python")  # ValueError: substring not found

Kapan menggunakan yang mana:

Gunakan find() ketika kamu ingin mengecek apakah sesuatu ada (mengembalikan -1 jika tidak ditemukan)
Gunakan index() ketika kamu yakin substring tersebut ada (melempar error jika tidak ditemukan)

python

# choosing_find_vs_index.py
text = "Python Programming"
 
# Menggunakan find() untuk pengecekan aman
if text.find("Java") != -1:
    print("Found Java")
else:
    print("Java not found")  # Output: Java not found
 
# Menggunakan index() ketika kamu yakin substring-nya ada
position = text.index("Python")  # Kita tahu Python ada di sana
print(f"Found at position {position}")  # Output: Found at position 0

5.5.2) Mencari dari Akhir dengan rfind() dan rindex()

Method rfind() dan rindex() mencari dari kanan (akhir) string:

python

# rfind_method.py
text = "Python is great. Python is powerful."
 
# Menemukan kemunculan terakhir "Python"
last_position = text.rfind("Python")
print(last_position)  # Output: 17
 
# Dibandingkan dengan find() yang memberikan kemunculan pertama
first_position = text.find("Python")
print(first_position)  # Output: 0

Ini berguna ketika kamu ingin kemunculan terakhir dari sesuatu:

python

# last_occurrence.py
filename = "document.backup.txt"
 
# Menemukan titik terakhir (untuk mendapatkan ekstensi file)
last_dot = filename.rfind(".")
if last_dot != -1:
    extension = filename[last_dot:]
    print(extension)  # Output: .txt

5.5.3) Menghitung Kemunculan dengan count()

Method count() memberi tahu berapa kali sebuah substring muncul:

python

# count_method.py
text = "Python is great. Python is powerful. Python is fun."
 
# Menghitung berapa kali "Python" muncul
count = text.count("Python")
print(count)  # Output: 3
 
# Menghitung karakter
letter_count = text.count("o")
print(f"Letter 'o' appears {letter_count} times")  # Output: Letter 'o' appears 4 times

Kamu juga dapat menghitung dalam rentang tertentu:

python

# count_in_range.py
text = "abcabcabc"
 
# Menghitung "abc" di seluruh string
total = text.count("abc")
print(total)  # Output: 3
 
# Menghitung "abc" hanya di 6 karakter pertama
partial = text.count("abc", 0, 6)
print(partial)  # Output: 2

5.5.4) Mengganti Teks dengan replace()

Method replace() membuat string baru dengan semua kemunculan substring diganti:

python

# replace_method.py
text = "I love Java. Java is great."
 
# Mengganti semua kemunculan "Java" dengan "Python"
new_text = text.replace("Java", "Python")
print(new_text)  # Output: I love Python. Python is great.
 
# String asli tidak berubah
print(text)  # Output: I love Java. Java is great.

Kamu dapat membatasi jumlah penggantian dengan argumen ketiga:

python

# limited_replace.py
text = "one one one one"
 
# Mengganti hanya 2 kemunculan pertama
result = text.replace("one", "two", 2)
print(result)  # Output: two two one one

Method replace() peka huruf besar-kecil:

python

# case_sensitive_replace.py
text = "Python is great. python is powerful."
 
# Ini hanya mengganti "Python" (P kapital)
result = text.replace("Python", "Java")
print(result)  # Output: Java is great. python is powerful.

Untuk penggantian yang tidak peka huruf besar-kecil, kamu perlu menanganinya secara manual:

python

# case_insensitive_approach.py
text = "Python is great. python is powerful."
 
# Mengonversi ke huruf kecil, mengganti, tetapi ini menghilangkan bentuk huruf asli
result = text.lower().replace("python", "java")
print(result)  # Output: java is great. java is powerful.

5.5.5) Contoh Praktis Pencarian dan Penggantian

Berikut skenario dunia nyata di mana method ini sangat berguna:

python

# practical_search_replace.py
# Membersihkan data: menghapus karakter yang tidak diinginkan
phone = "123-456-7890"
clean_phone = phone.replace("-", "")
print(clean_phone)  # Output: 1234567890
 
# Menyensor kata
message = "This is a bad word and another bad word."
censored = message.replace("bad", "***")
print(censored)  # Output: This is a *** word and another *** word.
 
# Mengambil ekstensi file
filename = "document.txt"
dot_position = filename.rfind(".")
if dot_position != -1:
    extension = filename[dot_position + 1:]
    print(f"File type: {extension}")  # Output: File type: txt
 
# Menghitung kemunculan kata (pendekatan sederhana)
text = "Python is fun. I love Python. Python rocks!"
word = "Python"
occurrences = text.count(word)
print(f"'{word}' appears {occurrences} times")  # Output: 'Python' appears 3 times

Method pencarian dan penggantian ini adalah alat dasar untuk pemrosesan teks, pembersihan data, dan manipulasi string dalam program Python.

5.6) Konversi antara String dan Angka

Salah satu tugas paling umum dalam pemrograman adalah konversi antara representasi teks dan numerik. Saat kamu membaca input pengguna dengan input(), kamu mendapatkan string — bahkan jika pengguna mengetik angka. Demikian juga, saat kamu ingin menampilkan angka di dalam teks, kamu perlu mengonversinya menjadi string.

5.6.1) Mengonversi String ke Angka

Kita sudah melihat fungsi int() dan float() di Bab 3, tetapi mari kita jelajahi lebih dalam:

python

# string_to_number.py
# Mengonversi string ke integer
age_text = "25"
age = int(age_text)
print(age)        # Output: 25
print(type(age))  # Output: <class 'int'>
 
# Mengonversi string ke float
price_text = "19.99"
price = float(price_text)
print(price)        # Output: 19.99
print(type(price))  # Output: <class 'float'>

Konversi ini penting ketika memproses input pengguna:

python

# user_input_conversion.py
# Mensimulasikan input pengguna (di kode nyata, kamu akan menggunakan input())
user_age = "30"
user_height = "5.9"
 
# Mengonversi ke angka agar kita bisa melakukan operasi matematika
age = int(user_age)
height = float(user_height)
 
# Sekarang kita bisa melakukan perhitungan
print(f"In 10 years, you'll be {age + 10}")  # Output: In 10 years, you'll be 40
print(f"Your height in meters: {height * 0.3048:.2f}")  # Output: Your height in meters: 1.80

Penting: String harus merepresentasikan angka yang valid, atau akan terjadi error:

python

# conversion_errors.py
# Ini baik-baik saja
print(int("123"))      # Output: 123
print(float("3.14"))   # Output: 3.14
 
# Ini menyebabkan ValueError:
# print(int("hello"))     # ValueError: invalid literal for int()
# print(int("12.5"))      # ValueError: invalid literal for int() with base 10
# print(float("12.5.3"))  # ValueError: could not convert string to float

Kita akan belajar bagaimana menangani error ini dengan baik di Bab 28. Untuk saat ini, sadari bahwa konversi bisa gagal jika string tidak merepresentasikan angka yang valid.

5.6.2) Menangani Whitespace dalam String Numerik

Fungsi konversi Python secara otomatis menangani whitespace di awal dan akhir:

python

# whitespace_handling.py
# Semua ini baik-baik saja meskipun ada spasi
print(int("  42  "))      # Output: 42
print(float("  3.14  "))  # Output: 3.14
 
# Menggabungkan strip() dengan konversi untuk keamanan
user_input = "  100  "
number = int(user_input.strip())
print(number)  # Output: 100

Ini membantu saat memproses input pengguna, yang sering mengandung spasi ekstra.

5.6.3) Mengonversi Angka ke String

Fungsi str() mengonversi nilai apa pun ke representasi string-nya:

python

# number_to_string.py
age = 25
height = 5.9
 
# Mengonversi angka ke string
age_text = str(age)
height_text = str(height)
 
print(type(age_text))     # Output: <class 'str'>
print(type(height_text))  # Output: <class 'str'>
 
# Sekarang kita bisa menggabungkannya dengan string lain
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Ini perlu setiap kali kamu ingin menggabungkan angka dengan string:

python

# concatenation_with_numbers.py
score = 95
total = 100
 
# Harus mengonversi angka ke string untuk konkatenasi
result = "Score: " + str(score) + "/" + str(total)
print(result)  # Output: Score: 95/100
 
# Alternatif: gunakan f-string (dibahas detail di Bab 6)
result = f"Score: {score}/{total}"
print(result)  # Output: Score: 95/100

5.6.4) Konversi antara Integer dan Float

Kamu juga bisa mengonversi antara tipe integer dan float:

python

# int_float_conversion.py
# Float ke int (memotong bagian desimal)
price = 19.99
price_int = int(price)
print(price_int)  # Output: 19 (bagian desimal dihapus, tidak dibulatkan)
 
# Int ke float
age = 25
age_float = float(age)
print(age_float)  # Output: 25.0

Penting: Mengonversi float ke int akan memotong (menghilangkan) bagian desimal — bukan membulatkan:

python

# truncation_not_rounding.py
print(int(3.9))   # Output: 3 (bukan 4!)
print(int(3.1))   # Output: 3
print(int(-3.9))  # Output: -3 (dipotong ke arah nol)
 
# Untuk membulatkan, gunakan fungsi round() terlebih dahulu (dibahas di Bab 4)
print(int(round(3.9)))  # Output: 4

5.6.5) Contoh Konversi Praktis

Berikut skenario dunia nyata di mana konversi tipe sangat penting:

python

# practical_conversions.py
# Membaca dan memproses input pengguna
# (Mensimulasikan input() - di kode nyata, kamu akan menggunakan input())
user_input = "42"
 
# Mengonversi ke angka untuk perhitungan
number = int(user_input)
doubled = number * 2
print(f"Double of {number} is {doubled}")  # Output: Double of 42 is 84
 
# Membangun output terformat
name = "John"
age = 30
height = 5.9
 
# Metode 1: Mengonversi angka ke string
info = name + " is " + str(age) + " years old and " + str(height) + " feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Metode 2: Menggunakan f-string (lebih mudah dibaca - dibahas di Bab 6)
info = f"{name} is {age} years old and {height} feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# Memproses data dari file (sekilas)
data_line = "100,200,300"  # Mensimulasikan satu baris dari file CSV
numbers = data_line.split(",")  # Memecah menjadi list string
total = int(numbers[0]) + int(numbers[1]) + int(numbers[2])
print(f"Total: {total}")  # Output: Total: 600

5.6.6) Kesalahan Umum dalam Konversi

Perhatikan beberapa kesalahan umum berikut:

python

# conversion_pitfalls.py
# Kekeliruan 1: Mencoba mengonversi string non-numerik
# text = "hello"
# number = int(text)  # ValueError!
 
# Kekeliruan 2: Lupa mengonversi sebelum operasi aritmetika
age_text = "25"
# next_year = age_text + 1  # TypeError: can only concatenate str to str
 
# Pendekatan yang benar:
age = int(age_text)
next_year = age + 1
print(next_year)  # Output: 26
 
# Kekeliruan 3: Kehilangan presisi dengan int()
price = 19.99
price_int = int(price)  # Menjadi 19, bukan 20!
print(price_int)  # Output: 19
 
# Kekeliruan 4: Mencoba mengonversi string dengan koma atau simbol mata uang
# price_text = "$1,234.56"
# price = float(price_text)  # ValueError!
 
# Kamu harus membersihkan string terlebih dahulu:
price_text = "$1,234.56"
clean_price = price_text.replace("$", "").replace(",", "")
price = float(clean_price)
print(price)  # Output: 1234.56

Memahami konversi tipe sangat penting untuk membangun program yang berinteraksi dengan pengguna dan memproses data dunia nyata. Kamu akan menggunakan konversi ini terus-menerus sepanjang perjalanan pemrograman Python-mu.

5.7) Mengecek Substring dengan in dan not in

Python menyediakan cara sederhana dan mudah dibaca untuk mengecek apakah sebuah string mengandung string lainnya menggunakan operator in dan not in. Ini sangat berguna untuk validasi, pemfilteran, dan pengambilan keputusan dalam programmu.

5.7.1) Menggunakan in untuk Mengecek Substring

Operator in mengembalikan True jika satu string ditemukan di dalam string lain, dan False jika tidak:

python

# in_operator.py
text = "Python is a powerful programming language"
 
# Mengecek apakah substring ada
print("Python" in text)      # Output: True
print("powerful" in text)    # Output: True
print("Java" in text)        # Output: False

Ini jauh lebih mudah dibaca daripada menggunakan find() atau index():

python

# in_vs_find.py
text = "Hello, World!"
 
# Menggunakan in (jelas dan mudah dibaca)
if "World" in text:
    print("Found World!")  # Output: Found World!
 
# Menggunakan find (kurang mudah dibaca)
if text.find("World") != -1:
    print("Found World!")  # Output: Found World!

Operator in peka huruf besar-kecil:

python

# case_sensitivity.py
text = "Python Programming"
 
print("python" in text)   # Output: False (p huruf kecil)
print("Python" in text)   # Output: True (P huruf besar)
 
# Untuk pengecekan tidak peka huruf besar-kecil, ubah ke huruf kecil dulu
print("python" in text.lower())  # Output: True

5.7.2) Menggunakan not in untuk Mengecek Ketidakhadiran

Operator not in mengecek apakah substring TIDAK ada:

python

# not_in_operator.py
text = "Python is great"
 
print("Java" not in text)     # Output: True (Java tidak ada)
print("Python" not in text)   # Output: False (Python ada)

Ini sangat berguna untuk validasi:

python

# validation_examples.py
# Mengecek karakter tidak valid dalam username
username = "john_smith"
 
if " " not in username:
    print("Username is valid (no spaces)")  # Output: Username is valid (no spaces)

5.7.3) Method Pengecekan String Tambahan

Python menyediakan beberapa method lain yang berguna untuk mengecek properti string:

python

# string_checking_methods.py
text = "Python"
 
# Mengecek apakah string dimulai dengan substring
print(text.startswith("Py"))   # Output: True
print(text.startswith("Ja"))   # Output: False
 
# Mengecek apakah string diakhiri dengan substring
print(text.endswith("on"))     # Output: True
print(text.endswith("ing"))    # Output: False
 
# Ini lebih tepat dibanding menggunakan in
filename = "report.txt"
print(filename.endswith(".txt"))  # Output: True
print(".txt" in filename)         # Output: True (tapi kurang tepat)
 
# startswith/endswith dapat mengecek beberapa opsi
filename = "document.pdf"
print(filename.endswith((".pdf", ".doc", ".txt")))  # Output: True

Method pengecekan ini adalah alat penting untuk validasi input, pemfilteran data, dan logika kondisi di programmu. Mereka membuat kode lebih mudah dibaca dan dirawat dibanding pencarian string manual.

5.8) String Bersifat Immutable: Apa Artinya dalam Praktik

Salah satu karakteristik paling penting dari string Python adalah bahwa string bersifat immutable — setelah dibuat, string tidak dapat diubah. Ini mungkin terdengar seperti keterbatasan pada awalnya, tetapi memahami immutability sangat penting untuk menulis kode Python yang benar dan menghindari bug yang sulit dilacak.

5.8.1) Apa Arti Immutability

Ketika kita mengatakan string immutable, maksudnya kamu tidak dapat memodifikasi karakter di dalam string yang sudah ada. Operasi apa pun yang tampak "mengubah" string sebenarnya membuat string baru:

python

# immutability_basics.py
text = "Hello"
 
# Ini terlihat seperti mengubah string, tapi sebenarnya tidak
text = text + " World"
print(text)  # Output: Hello World
 
# Yang sebenarnya terjadi:
# 1. Python membuat string baru "Hello World"
# 2. Variabel 'text' sekarang mengacu ke string baru ini
# 3. String "Hello" yang asli masih ada (sampai dibersihkan garbage collector)

Kamu tidak dapat mengubah karakter individual dalam string:

python

# cannot_modify_characters.py
text = "Hello"
 
# Ini menyebabkan error:
# text[0] = "J"  # TypeError: 'str' object does not support item assignment
 
# Kamu harus membuat string baru sebagai gantinya
text = "J" + text[1:]
print(text)  # Output: Jello

Ini secara fundamental berbeda dengan cara kerja list (yang akan kita pelajari di Bab 13). List bersifat mutable — kamu bisa mengubah elemennya:

python

# lists_are_mutable.py
# Sekilas tentang list (dibahas di Bab 13)
numbers = [1, 2, 3]
numbers[0] = 10  # Ini baik-baik saja untuk list
print(numbers)   # Output: [10, 2, 3]
 
# Tapi string tidak mengizinkan ini:
text = "Hello"
# text[0] = "J"  # TypeError pada string!

5.8.2) Mengapa Method String Mengembalikan String Baru

Semua method string yang tampak memodifikasi string sebenarnya mengembalikan string baru, dan string asli dibiarkan apa adanya:

python

# methods_return_new_strings.py
original = "hello world"
 
# Method-method ini mengembalikan string baru
uppercase = original.upper()
capitalized = original.capitalize()
replaced = original.replace("world", "Python")
 
# String asli tidak berubah
print(original)      # Output: hello world
print(uppercase)     # Output: HELLO WORLD
print(capitalized)   # Output: Hello world
print(replaced)      # Output: hello Python

Inilah mengapa kamu perlu menetapkan hasilnya ke variabel (atau menggunakan variabel yang sama) untuk menyimpan perubahan:

python

# keeping_changes.py
text = "  hello  "
 
# Salah: hasilnya hilang
text.strip()
print(text)  # Output:   hello   (masih ada spasi!)
 
# Benar: simpan hasilnya
text = text.strip()
print(text)  # Output: hello (spasi dihapus)

Ini adalah kesalahan umum bagi pemula:

python

# common_mistake.py
message = "python programming"
 
# Kesalahan: memanggil method tapi tidak menggunakan hasilnya
message.upper()
message.replace("python", "Python")
print(message)  # Output: python programming (tidak berubah!)
 
# Benar: simpan hasilnya
message = message.upper()
message = message.replace("PYTHON", "Python")
print(message)  # Output: Python PROGRAMMING

5.8.3) Implikasi Immutability

Memahami immutability membantu kamu menulis kode yang lebih baik:

1. String aman untuk dibagi-pakai:

python

# safe_sharing.py
original = "Hello"
copy = original  # Kedua variabel menunjuk ke string yang sama
 
# Karena string immutable, ini aman
copy = copy + " World"
 
print(original)  # Output: Hello (tidak berubah)
print(copy)      # Output: Hello World (string baru)

2. Operasi string membuat objek baru:

python

# new_objects.py
text = "Python"
 
# Setiap operasi membuat objek string baru
result1 = text.upper()
result2 = text.lower()
result3 = text.replace("P", "J")
 
# Semua objek yang berbeda
print(id(text))     # Alamat memori tertentu
print(id(result1))  # Alamat memori berbeda
print(id(result2))  # Alamat memori berbeda
print(id(result3))  # Alamat memori berbeda

3. Membangun string di dalam loop bisa tidak efisien:

python

# inefficient_string_building.py
# Ini membuat banyak objek string sementara
result = ""
for i in range(5):
    result = result + str(i)  # Membuat string baru setiap kali
print(result)  # Output: 01234
 
# Pendekatan yang lebih efisien (untuk banyak konkatenasi):
# Gunakan list dan join (kita akan mempelajarinya di Bab 6)
parts = []
for i in range(5):
    parts.append(str(i))
result = "".join(parts)
print(result)  # Output: 01234

5.8.4) Immutability dan Argumen Fungsi

Saat kamu mengoper string ke fungsi, kamu tidak perlu khawatir string itu akan berubah tanpa sengaja:

python

# safe_function_arguments.py
def process_text(text):
    # Operasi apa pun akan membuat string baru
    text = text.upper()
    text = text.replace("A", "X")
    return text
 
original = "banana"
result = process_text(original)
 
print(original)  # Output: banana (tidak berubah)
print(result)    # Output: BXNXNX (versi yang dimodifikasi)

Ini berbeda dengan tipe mutable (seperti list, yang akan kita pelajari di Bab 13), di mana modifikasi di dalam fungsi memengaruhi objek asli.

5.8.5) Memvisualisasikan Immutability

Berikut representasi visual tentang apa yang terjadi ketika kamu "memodifikasi" string:

Memahami bahwa string immutable membantu kamu:

Menghindari kesalahan ketika lupa menyimpan hasil method
Memahami mengapa operasi string membuat objek baru
Menulis kode yang lebih efisien saat membangun string besar
Dengan aman membagi-pakai string antar bagian program

Immutability adalah karakteristik mendasar yang membedakan string dari tipe mutable seperti list, yang akan kita eksplorasi secara detail di Bagian IV buku ini.

Ringkasan Bab:

Di bab ini, kamu telah mempelajari dasar-dasar bekerja dengan teks di Python menggunakan string. Kamu sekarang memahami cara:

Membuat string literal menggunakan tanda petik dan escape sequence
Menggabungkan string dengan konkatenasi dan pengulangan
Mengakses karakter individual dan mengambil substring dengan indexing dan slicing
Mentransformasi string menggunakan method untuk konversi huruf besar-kecil dan penghapusan whitespace
Mencari dan mengganti teks di dalam string
Mengonversi antara string dan angka untuk pemrosesan input dan format output
Mengecek substring menggunakan operator in dan not in
Mengenali bahwa string bersifat immutable dan apa artinya bagi kode kamu

Keterampilan manipulasi string ini membentuk fondasi untuk pemrosesan teks di Python. Kamu akan menggunakan teknik-teknik ini terus-menerus saat membangun antarmuka pengguna, memproses file data, memvalidasi input, dan memformat output.

Di bab berikutnya, kita akan membangun di atas dasar ini dengan mengeksplorasi teknik penanganan string yang lebih lanjut, termasuk memecah (split) dan menggabung (join) string, formatting yang kuat dengan f-string dan method format(), serta memahami encoding teks untuk bekerja dengan karakter internasional.