6. Penanganan String Secara Praktis

Di Bab 5, Anda telah mempelajari dasar-dasar bekerja dengan string: cara membuatnya, mengakses karakter lewat indexing dan slicing, serta menggunakan method string dasar. Sekarang kita akan membangun di atas fondasi tersebut untuk mengeksplorasi operasi string yang lebih canggih yang akan Anda gunakan terus-menerus dalam program Python nyata.

Bab ini berfokus pada teknik manipulasi string praktis yang menyelesaikan masalah pemrograman sehari-hari: memecah teks dan menyatukannya kembali, membuat output terformat yang terlihat profesional. Keterampilan ini penting baik saat Anda memproses input pengguna, membuat laporan, membaca file data, atau membangun program apa pun yang bekerja dengan teks.

6.1) Memecah dan Menggabungkan String

Salah satu tugas paling umum dalam pemrosesan teks adalah memecah sebuah string menjadi potongan-potongan yang lebih kecil atau menggabungkan banyak potongan menjadi satu string. Python menyediakan method yang kuat untuk kedua operasi ini.

6.1.1) Memecah String dengan split()

Method split() memecah sebuah string menjadi list berisi string yang lebih kecil berdasarkan sebuah pemisah (separator, juga disebut delimiter). Ini sangat berguna untuk memproses teks terstruktur seperti data CSV, input pengguna dengan banyak nilai, atau kalimat menjadi kata-kata.

Pemecahan dasar berdasarkan whitespace:

Saat Anda memanggil split() tanpa argumen, method ini akan memecah berdasarkan whitespace apa pun (spasi, tab, newline) dan secara otomatis menghapus string kosong dari hasilnya:

python

# split_basic.py
sentence = "Python is a powerful programming language"
words = sentence.split()
print(words)  # Output: ['Python', 'is', 'a', 'powerful', 'programming', 'language']
print(len(words))  # Output: 6

Perhatikan bagaimana split() menangani banyak spasi dengan cerdas:

python

# split_whitespace.py
messy_text = "Python    is     awesome"
words = messy_text.split()
print(words)  # Output: ['Python', 'is', 'awesome']

Meskipun ada banyak spasi di antara kata-kata, split() menganggap jumlah whitespace berapa pun sebagai satu pemisah dan menghasilkan list yang rapi.

Memecah berdasarkan pemisah tertentu:

Anda dapat menentukan karakter atau string pemisah yang tepat dengan memberikannya sebagai argumen:

python

# split_separator.py
csv_data = "apple,banana,cherry,date"
fruits = csv_data.split(',')
print(fruits)  # Output: ['apple', 'banana', 'cherry', 'date']
 
date_string = "2024-03-15"
parts = date_string.split('-')
print(parts)  # Output: ['2024', '03', '15']
year = parts[0]
month = parts[1]
day = parts[2]
print(f"Year: {year}, Month: {month}, Day: {day}")  # Output: Year: 2024, Month: 03, Day: 15

Perbedaan penting: Saat Anda menentukan sebuah pemisah, split() memperlakukannya secara literal dan akan membuat string kosong jika pemisah muncul berurutan:

python

# split_empty_strings.py
data = "apple,,cherry"
result = data.split(',')
print(result)  # Output: ['apple', '', 'cherry']
print(len(result))  # Output: 3

String kosong '' di tengah merepresentasikan "ketiadaan" di antara dua koma berurutan. Perilaku ini berbeda dari pemecahan berdasarkan whitespace tanpa argumen.

Membatasi jumlah pemecahan:

Anda dapat mengontrol berapa banyak pemecahan yang terjadi dengan memberikan argumen kedua (maxsplit):

python

# split_maxsplit.py
text = "one:two:three:four:five"
parts = text.split(':', 2)  # Hanya memecah pada 2 titik dua pertama
print(parts)  # Output: ['one', 'two', 'three:four:five']

Ini membuat maksimal 3 bagian (maxsplit + 1) karena pemecahan berhenti setelah jumlah pemisahan yang ditentukan. Sisa string tetap utuh.

Contoh praktis: Memproses input pengguna

python

# process_input.py
user_input = input("Enter your full name: ")
# User enters: "Alice Marie Johnson"
 
name_parts = user_input.split()
if len(name_parts) >= 2:
    first_name = name_parts[0]
    last_name = name_parts[-1]  # Elemen terakhir
    print(f"First name: {first_name}")  # Output: First name: Alice
    print(f"Last name: {last_name}")    # Output: Last name: Johnson
else:
    print("Please enter at least a first and last name")

6.1.2) Menggabungkan String dengan join()

Method join() adalah kebalikan dari split(): method ini menggabungkan list (atau iterable apa pun) berisi string menjadi satu string, dengan sebuah pemisah di antara setiap elemen. Sintaksnya mungkin terlihat terbalik pada awalnya—string pemisah memanggil method, dan list diberikan sebagai argumen.

Penggabungan dasar:

python

# join_basic.py
words = ['Python', 'is', 'awesome']
sentence = ' '.join(words)
print(sentence)  # Output: Python is awesome
 
csv_line = ','.join(['apple', 'banana', 'cherry'])
print(csv_line)  # Output: apple,banana,cherry

String yang memanggil join() (seperti ' ' atau ',') menjadi pemisah di antara elemen.

Mengapa sintaksnya separator.join(list):

Sintaks ini masuk akal jika Anda melihatnya dari sudut pandang pemisah: "Saya ingin menggabungkan item-item ini, menyisipkan diri saya di antara setiap pasangan." Ini juga memungkinkan chaining yang elegan dan membuat pemisah sangat terlihat jelas di dalam kode.

Menggabungkan dengan berbagai pemisah:

python

# join_separators.py
items = ['eggs', 'milk', 'bread', 'butter']
 
# Dipisahkan koma
print(', '.join(items))  # Output: eggs, milk, bread, butter
 
# Dipisahkan newline (setiap item di barisnya sendiri)
print('\n'.join(items))
# Output:
# eggs
# milk
# bread
# butter
 
# Dipisahkan tanda hubung
print('-'.join(items))  # Output: eggs-milk-bread-butter
 
# Tanpa pemisah (penggabungan langsung)
print(''.join(items))  # Output: eggsmilkbreadbutter

Penting: join() hanya bekerja dengan string:

Semua elemen dalam iterable harus string. Jika Anda mencoba menggabungkan angka atau tipe lain, Anda akan mendapat error:

python

# join_error.py
numbers = [1, 2, 3, 4]
# result = ','.join(numbers)  # This would cause: TypeError: sequence item 0: expected str instance, int found

Untuk menggabungkan item yang bukan string, ubah dulu menjadi string. Kita akan mempelajari cara yang lebih elegan untuk melakukan ini di Bab 34, tapi untuk sekarang, Anda bisa mengonversi tiap item secara manual:

python

# join_numbers.py
numbers = [1, 2, 3, 4]
# Konversi setiap angka ke string secara manual
string_numbers = [str(numbers[0]), str(numbers[1]), str(numbers[2]), str(numbers[3])]
result = ','.join(string_numbers)
print(result)  # Output: 1,2,3,4

Contoh praktis: Membangun path file

python

# build_path.py
path_parts = ['home', 'user', 'documents', 'report.txt']
# Di sistem mirip Unix (Linux, macOS)
unix_path = '/'.join(path_parts)
print(unix_path)  # Output: home/user/documents/report.txt
 
# Di Windows
windows_path = '\\'.join(path_parts)
print(windows_path)  # Output: home\user\documents\report.txt

Catatan: Di Bab 26, kita akan mempelajari modul os.path yang menyediakan penanganan path lintas platform yang lebih baik, tetapi contoh ini menunjukkan konsep penggabungan.

6.1.3) Menggabungkan split() dan join() untuk Pemrosesan Teks

Dua method ini bekerja sangat baik bersama-sama untuk mentransformasi teks. Dengan menggabungkannya, Anda dapat membersihkan input yang berantakan, mengonversi antara format, atau mengekstrak dan menyusun ulang data:

python

# transform_text.py
# Ganti banyak spasi dengan satu spasi
messy = "Python    is     really    cool"
clean = ' '.join(messy.split())
print(clean)  # Output: Python is really cool
 
# Konversi teks dipisahkan koma menjadi dipisahkan spasi
csv_data = "apple,banana,cherry"
space_separated = ' '.join(csv_data.split(','))
print(space_separated)  # Output: apple banana cherry
 
# Hapus semua spasi
text_with_spaces = "H e l l o"
no_spaces = ''.join(text_with_spaces.split())
print(no_spaces)  # Output: Hello

6.1.4) Method Pemecahan Lainnya

Python menyediakan method pemecahan tambahan untuk kasus penggunaan tertentu:

rsplit() - Memecah dari kanan:

python

# rsplit_example.py
path = "folder/subfolder/file.txt"
 
# split biasa dengan maxsplit
parts = path.split('/', 1)
print(parts)  # Output: ['folder', 'subfolder/file.txt']
 
# rsplit memecah dari kanan
parts = path.rsplit('/', 1)
print(parts)  # Output: ['folder/subfolder', 'file.txt']

Ini berguna ketika Anda ingin memisahkan bagian terakhir string dari semua bagian sebelumnya.

splitlines() - Memecah berdasarkan pemisah baris:

python

# splitlines_example.py
multiline = "Line 1\nLine 2\nLine 3"
lines = multiline.splitlines()
print(lines)  # Output: ['Line 1', 'Line 2', 'Line 3']
 
# Bekerja dengan berbagai gaya akhir baris
mixed_lines = "Line 1\nLine 2\r\nLine 3\rLine 4"
all_lines = mixed_lines.splitlines()
print(all_lines)  # Output: ['Line 1', 'Line 2', 'Line 3', 'Line 4']

Method splitlines() mengenali semua konvensi pemisah baris standar (\n, \r\n, \r) dan memecah sesuai hal tersebut, sehingga lebih andal dibanding split('\n') untuk memproses teks dari berbagai sumber.

6.2) Memformat String dengan f-String

Membuat output terformat adalah salah satu tugas paling umum dalam pemrograman. Anda perlu menggabungkan teks dengan nilai variabel, meratakan kolom, memformat angka, dan membuat output yang mudah dibaca pengguna. f-string Python (formatted string literal) menyediakan cara yang paling modern, mudah dibaca, dan kuat untuk melakukan ini.

6.2.1) Sintaks Dasar f-String

f-string adalah literal string yang diawali dengan f atau F yang dapat berisi ekspresi di dalam kurung kurawal {}. Python mengevaluasi ekspresi ini dan mengonversi hasilnya menjadi string:

python

# fstring_basic.py
name = "Alice"
age = 30
greeting = f"Hello, {name}! You are {age} years old."
print(greeting)  # Output: Hello, Alice! You are 30 years old.

Ekspresi di dalam {} bisa berupa ekspresi Python apa pun yang valid:

python

# fstring_expressions.py
x = 10
y = 20
result = f"The sum of {x} and {y} is {x + y}"
print(result)  # Output: The sum of 10 and 20 is 30
 
price = 19.99
quantity = 3
total = f"Total cost: ${price * quantity}"
print(total)  # Output: Total cost: $59.97

6.2.2) Mengapa f-String Lebih Baik dari Pendekatan Lama

Sebelum f-string (diperkenalkan di Python 3.6), programmer menggunakan penggabungan string atau method format(). Mari bandingkan:

Penggabungan string (cara lama yang rawan error):

python

# concatenation_example.py
name = "Bob"
age = 25
# Mengharuskan konversi angka ke string dan banyak operator +
message = "Hello, " + name + "! You are " + str(age) + " years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

Pendekatan ini bertele-tele, rawan error (lupa str() akan menyebabkan error), dan sulit dibaca saat banyak variabel.

f-string (cara modern dan bersih):

python

# fstring_clean.py
name = "Bob"
age = 25
message = f"Hello, {name}! You are {age} years old."
print(message)  # Output: Hello, Bob! You are 25 years old.

f-string secara otomatis mengonversi nilai ke string, lebih mudah dibaca, dan bahkan lebih cepat daripada pendekatan lain.

6.2.3) Ekspresi dan Pemanggilan Method dalam f-String

Anda dapat menyertakan ekspresi kompleks, pemanggilan method, dan bahkan pemanggilan fungsi di dalam f-string:

python

# fstring_methods.py
name = "alice"
print(f"Capitalized: {name.capitalize()}")  # Output: Capitalized: Alice
print(f"Uppercase: {name.upper()}")  # Output: Uppercase: ALICE
print(f"Length: {len(name)}")  # Output: Length: 5
 
# Aritmetika dan perbandingan
x = 10
print(f"Is {x} even? {x % 2 == 0}")  # Output: Is 10 even? True
 
# Indexing dan slicing
text = "Python"
print(f"First letter: {text[0]}")  # Output: First letter: P
print(f"First three: {text[:3]}")  # Output: First three: Pyt

6.2.4) Memformat Angka dalam f-String

f-string mendukung format specifier yang mengontrol bagaimana nilai ditampilkan. Sintaksnya adalah {expression:format_spec}:

Mengontrol jumlah angka di belakang koma untuk float:

python

# fstring_decimals.py
pi = 3.14159265359
 
print(f"Default: {pi}")  # Output: Default: 3.14159265359
print(f"2 decimals: {pi:.2f}")  # Output: 2 decimals: 3.14
print(f"4 decimals: {pi:.4f}")  # Output: 4 decimals: 3.1416
print(f"No decimals: {pi:.0f}")  # Output: No decimals: 3

Format specifier .2f berarti "format sebagai float dengan 2 angka di belakang koma." Huruf f berarti "fixed-point notation."

Memformat dengan pemisah ribuan:

python

# fstring_thousands.py
large_number = 1234567890
 
print(f"No separator: {large_number}")  # Output: No separator: 1234567890
print(f"With commas: {large_number:,}")  # Output: With commas: 1,234,567,890
print(f"With underscores: {large_number:_}")  # Output: With underscores: 1_234_567_890
 
# Digabung dengan angka di belakang koma
price = 1234567.89
print(f"Price: ${price:,.2f}")  # Output: Price: $1,234,567.89

Pemformatan persentase:

python

# fstring_percentage.py
ratio = 0.847
print(f"Ratio: {ratio}")  # Output: Ratio: 0.847
print(f"Percentage: {ratio:.1%}")  # Output: Percentage: 84.7%
print(f"Percentage: {ratio:.2%}")  # Output: Percentage: 84.70%

Format specifier % mengalikan dengan 100 dan menambahkan tanda persen.

6.2.5) Contoh Praktis dengan f-String

Membuat laporan terformat:

python

# report_example.py
product = "Laptop"
price = 899.99
quantity = 5
tax_rate = 0.08
 
subtotal = price * quantity
tax = subtotal * tax_rate
total = subtotal + tax
 
print(f"Product: {product}")  # Output: Product: Laptop
print(f"Price: ${price:.2f}")  # Output: Price: $899.99
print(f"Quantity: {quantity}")  # Output: Quantity: 5
print(f"Subtotal: ${subtotal:.2f}")  # Output: Subtotal: $4499.95
print(f"Tax (8%): ${tax:.2f}")  # Output: Tax (8%): $360.00
print(f"Total: ${total:.2f}")  # Output: Total: $4859.95

Membuat pesan yang ramah pengguna:

python

# user_messages.py
username = "Alice"
login_count = 42
last_login = "2024-03-15"
 
welcome = f"Welcome back, {username}!"
stats = f"You've logged in {login_count} times. Last login: {last_login}"
 
print(welcome)  # Output: Welcome back, Alice!
print(stats)  # Output: You've logged in 42 times. Last login: 2024-03-15

6.2.6) Debugging dengan f-String

Python 3.8 memperkenalkan specifier = untuk debugging, yang menampilkan baik ekspresi maupun nilainya:

python

# fstring_debug.py
x = 10
y = 20
z = x + y
 
print(f"{x=}")  # Output: x=10
print(f"{y=}")  # Output: y=20
print(f"{z=}")  # Output: z=30
print(f"{x + y=}")  # Output: x + y=30

Ini sangat berguna untuk cepat mengecek nilai variabel saat pengembangan tanpa perlu mengetik nama variabel dua kali.

6.2.7) Escape Kurung Kurawal dalam f-String

Jika Anda membutuhkan kurung kurawal literal dalam f-string, gandakan:

python

# fstring_escape.py
value = 42
# Kurung kurawal tunggal adalah placeholder ekspresi
print(f"Value: {value}")  # Output: Value: 42
 
# Kurung kurawal ganda menghasilkan kurung kurawal literal
print(f"Use {{value}} as a placeholder")  # Output: Use {value} as a placeholder
print(f"The value is {value}, shown as {{value}}")  # Output: The value is 42, shown as {value}

6.3) Memformat dengan format() dan Format Specifier

Walaupun f-string adalah pendekatan modern yang lebih disukai, method format() masih banyak digunakan dan menawarkan beberapa kemampuan yang berguna untuk dipahami. Method ini juga menjadi dasar yang digunakan f-string, sehingga memahami format() membantu Anda lebih memahami f-string.

6.3.1) Sintaks Dasar format()

Method format() menggunakan kurung kurawal {} sebagai placeholder di dalam string, dan nilai yang akan disisipkan diberikan sebagai argumen:

python

# format_basic.py
template = "Hello, {}! You are {} years old."
message = template.format("Alice", 30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Penggunaan format() berkali-kali
greeting = "Hello, {}!".format("Bob")
print(greeting)  # Output: Hello, Bob!

6.3.2) Argumen Posisi dan Keyword

Anda dapat mengontrol argumen mana masuk ke placeholder mana dengan menggunakan nomor posisi atau nama:

Argumen posisi:

python

# format_positional.py
# Urutan default (0, 1, 2, ...)
template = "{} + {} = {}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Posisi eksplisit
template = "{0} + {1} = {2}"
result = template.format(5, 3, 8)
print(result)  # Output: 5 + 3 = 8
 
# Mengubah urutan dan menggunakan ulang
template = "{2} = {0} + {1}"
result = template.format(5, 3, 8)
print(result)  # Output: 8 = 5 + 3
 
# Menggunakan nilai yang sama berulang kali
template = "{0} times {0} equals {1}"
result = template.format(7, 49)
print(result)  # Output: 7 times 7 equals 49

Argumen keyword:

python

# format_keyword.py
template = "Hello, {name}! You are {age} years old."
message = template.format(name="Alice", age=30)
print(message)  # Output: Hello, Alice! You are 30 years old.
 
# Bisa dicampur dengan posisi (posisi harus lebih dulu)
template = "{0}, your score is {score} out of {1}"
result = template.format("Alice", 100, score=95)
print(result)  # Output: Alice, your score is 95 out of 100

6.3.3) Format Specifier dengan format()

Format specifier bekerja dengan cara yang sama di format() seperti di f-string, menggunakan pemisah ::

python

# format_specifiers.py
pi = 3.14159265359
 
print("{:.2f}".format(pi))  # Output: 3.14
print("{:.4f}".format(pi))  # Output: 3.1416
 
# Dengan nama
print("{value:.2f}".format(value=pi))  # Output: 3.14
 
# Banyak nilai dengan format berbeda
template = "{name}'s score is {score:.1f}%"
result = template.format(name="Bob", score=87.654)
print(result)  # Output: Bob's score is 87.7%

6.3.4) Kapan Menggunakan format() Alih-alih f-String

f-string umumnya lebih disukai, tetapi format() berguna dalam situasi tertentu:

1. String template didefinisikan terpisah dari data:

python

# format_templates.py
# Template didefinisikan sekali, digunakan berkali-kali dengan data berbeda
email_template = "Dear {name},\n\nYour order #{order_id} has shipped.\n\nThank you!"
 
# Gunakan template dengan pelanggan berbeda
message1 = email_template.format(name="Alice", order_id=12345)
message2 = email_template.format(name="Bob", order_id=12346)
 
print(message1)
# Output:
# Dear Alice,
#
# Your order #12345 has shipped.
#
# Thank you!
 
print(message2)
# Output:
# Dear Bob,
#
# Your order #12346 has shipped.
#
# Thank you!

2. Saat template berasal dari sumber eksternal:

python

# format_external.py
# Template mungkin berasal dari file konfigurasi atau database
# (Kita akan mempelajari cara membaca file di Bab 24)
user_template = input("Enter message template: ")
# User enters: "Hello, {name}! Welcome to {place}."
 
message = user_template.format(name="Charlie", place="Python")
print(message)  # Output: Hello, Charlie! Welcome to Python.

Dengan f-string, template harus ada di dalam kode karena ekspresi dievaluasi langsung. Dengan format(), template bisa berupa string biasa yang berasal dari mana saja.

6.3.5) Mengakses Atribut Objek dan Key Dictionary

Method format() dapat mengakses atribut dan key dictionary secara langsung:

python

# format_access.py
# Akses dictionary
person = {"name": "Alice", "age": 30, "city": "Boston"}
message = "Name: {0[name]}, Age: {0[age]}, City: {0[city]}".format(person)
print(message)  # Output: Name: Alice, Age: 30, City: Boston
 
# Dengan argumen keyword
message = "{p[name]} is {p[age]} years old".format(p=person)
print(message)  # Output: Alice is 30 years old

Catatan: Kita akan mempelajari atribut objek di Bab 30, tetapi contoh ini menunjukkan bahwa format() dapat mengakses struktur data bersarang.

6.4) Meratakan dan Membulatkan Angka dalam Output Terformat

Output yang terlihat profesional sering kali membutuhkan perataan dan pemformatan angka yang rapi. Baik f-string maupun format() menyediakan alat yang kuat untuk membuat tabel, laporan, dan tampilan yang terformat dengan baik.

6.4.1) Perataan Teks

Anda dapat mengontrol lebar dan perataan nilai menggunakan format specifier:

python

# alignment_basic.py
# Sintaks: {value:width}
# Default-nya rata kiri untuk string, rata kanan untuk angka
 
name = "Alice"
print(f"|{name}|")      # Output: |Alice|
print(f"|{name:10}|")   # Output: |Alice     |  (rata kiri, lebar 10)
print(f"|{name:>10}|")  # Output: |     Alice|  (rata kanan)
print(f"|{name:^10}|")  # Output: |  Alice   |  (rata tengah)

Specifier perataan adalah:

< : Rata kiri (default untuk string)
> : Rata kanan (default untuk angka)
^ : Rata tengah

Perataan dengan angka:

python

# alignment_numbers.py
value = 42
print(f"|{value}|")      # Output: |42|
print(f"|{value:5}|")    # Output: |   42|  (rata kanan secara default)
print(f"|{value:<5}|")   # Output: |42   |  (rata kiri)
print(f"|{value:^5}|")   # Output: | 42  |  (rata tengah)

6.4.2) Karakter Isian Kustom

Anda dapat menentukan karakter untuk mengisi ruang kosong:

python

# alignment_fill.py
name = "Bob"
print(f"|{name:*<10}|")  # Output: |Bob*******|
print(f"|{name:*>10}|")  # Output: |*******Bob|
print(f"|{name:*^10}|")  # Output: |***Bob****|
 
# Berguna untuk membuat pemisah visual
print(f"{name:=^20}")    # Output: ========Bob=========

Sintaksnya adalah {value:fill_char align width}.

6.4.3) Menggabungkan Perataan dengan Pemformatan Angka

Anda dapat menggabungkan lebar, perataan, dan pemformatan angka:

python

# alignment_combined.py
price = 19.99
quantity = 5
total = price * quantity
 
# Rata kanan dengan lebar 10, 2 angka di belakang koma
print(f"Price:    ${price:>10.2f}")     # Output: Price:    $     19.99
print(f"Quantity: {quantity:>10}")      # Output: Quantity:          5
print(f"Total:    ${total:>10.2f}")     # Output: Total:    $     99.95
 
# Dengan karakter isian untuk efek visual
print(f"Total:    ${total:>10.2f}".replace(' ', '.'))  # Output: Total:....$.....99.95

Di bab ini, Anda telah mempelajari teknik manipulasi string penting yang akan Anda gunakan di hampir setiap program Python: memecah dan menggabungkan string untuk pemrosesan teks, membuat output terformat dengan f-string dan format specifier, serta meratakan dan memformat angka untuk tampilan yang profesional.

Keterampilan ini membentuk fondasi untuk bekerja dengan data teks di Python. Sekarang Anda dapat memproses input pengguna, membuat laporan terformat, menangani data dari file (yang akan kita bahas di Bab 24). Seiring Anda terus belajar Python, Anda akan menggunakan teknik penanganan string ini terus-menerus, jadi latihlah sampai terasa alami.