Metode String

String Python bersifat immutable: nilai di dalam objek string tidak dapat diedit di tempat. Sebuah operasi dapat membuat string baru dan variabel dapat diarahkan ke objek baru itu, tetapi objek string asal tetap tidak berubah.

Karena itu, assignment ke posisi karakter menghasilkan TypeError. List berbeda karena elemennya dapat diganti di tempat.

immutable_string.py

# Demonstrasi sifat immutable string
s = "hello"
print(f"String awal: {s}")

# Mencoba mengubah karakter secara langsung
try:
  s[1] = "a"  # Ini akan menyebabkan error
except TypeError as e:
  print(f"Error: {e}")

# Cara yang benar: membuat string baru
s_new = s[:1] + "a" + s[2:]
print(f"String baru: {s_new}")

# String asli tetap tidak berubah
print(f"String asli masih: {s}")

Slicing dan concatenation adalah dua cara untuk membangun string baru dari string lama. Operator + tidak menambahkan isi ke objek asal.

Pada string Python, len() menghitung jumlah Unicode code point. Huruf Latin biasa, spasi, atau tanda baca umumnya menyumbang satu, tetapi satu grafem yang terlihat dapat terdiri dari beberapa code point, seperti pada sebagian emoji dan tanda gabung.

panjang_string.py

# Mengukur panjang berbagai jenis string
strings = [
  "hello",
  "Hello World!",
  "Python programming",
  "",  # string kosong
  "   ",  # string berisi spasi
  "123456"
]

for s in strings:
  print(f"'{s}' memiliki panjang: {len(s)}")

# Panjang string dengan karakter khusus
special = "Hello\nWorld\t!"
print(f"String dengan escape sequence: {len(special)} karakter")
print(f"Tampilan string: {repr(special)}")

raw_newline = r"\n"
print(f"Penulisan raw \n: {len(raw_newline)} code point")

Dalam string literal biasa, penulisan \n dan \t pada kode sumber masing-masing menjadi satu code point newline atau tab. Dalam raw string seperti r"\n", backslash dan n tetap menjadi dua code point terpisah.

transformasi_case.py

# Contoh transformasi case pada string
text = "Python Programming Language"

# Mengubah ke huruf besar semua
upper_text = text.upper()
print(f"Upper: {upper_text}")

# Mengubah ke huruf kecil semua
lower_text = text.lower()
print(f"Lower: {lower_text}")

# Title case: huruf pertama setiap kata besar
title_text = text.title()
print(f"Title: {title_text}")

# Contoh dengan string campuran
mixed = "hELLo WoRLd PyThOn"
print(f"Original: {mixed}")
print(f"Title case: {mixed.title()}")

# Title case pada string dengan angka dan simbol
complex_text = "python3.9 is-awesome!"
print(f"Complex title: {complex_text.title()}")

Metode title() mengikuti aturan kapitalisasi mekanis. Metode ini cocok untuk label tampilan sederhana, tetapi tidak dapat diandalkan untuk nama orang atau judul editorial. Pertahankan ejaan resmi atau gunakan aturan khusus domain untuk nilai tersebut.

Tanpa argumen, strip(), lstrip(), dan rstrip() menghapus whitespace di tepi string. Argumen chars diperlakukan sebagai kumpulan karakter individual yang dihapus berulang kali dari tepi terkait, bukan sebagai satu prefix atau suffix utuh.

strip_methods.py

# Demonstrasi berbagai metode strip
text = "   Hello World   "
print(f"Original: '{text}'")

# Menghapus spasi di kedua sisi
stripped = text.strip()
print(f"Strip: '{stripped}'")

# Menghapus spasi hanya di kiri
left_stripped = text.lstrip()
print(f"Left strip: '{left_stripped}'")

# Menghapus spasi hanya di kanan
right_stripped = text.rstrip()
print(f"Right strip: '{right_stripped}'")

# Strip dengan karakter khusus
special_text = "+++Hello World+++"
custom_stripped = special_text.strip("+")
print(f"Custom strip: '{custom_stripped}'")

# Strip multiple characters
messy_text = "---+++Hello World+++---"
clean_text = messy_text.strip("-+")
print(f"Multiple char strip: '{clean_text}'")

# Menghapus satu suffix secara persis
filename = "report.txt"
print(f"Hasil menghapus suffix: '{filename.removesuffix('.txt')}'")

Gunakan removeprefix() atau removesuffix() jika kamu perlu menghapus satu token yang persis. Perbedaan ini mencegah sekumpulan karakter menghapus lebih banyak dari yang dimaksud.

Metode index() dan find() digunakan untuk mencari posisi substring dalam string. Perbedaannya terletak pada cara menangani kasus ketika substring tidak ditemukan.

pencarian_substring.py

# Pencarian substring dengan berbagai metode
text = "Python is a powerful programming language"

# Menggunakan index() - akan error jika tidak ditemukan
try:
  pos = text.index("powerful")
  print(f"'powerful' ditemukan di posisi: {pos}")

  # Mencari yang tidak ada
  pos_not_found = text.index("Java")
except ValueError as e:
  print(f"Error dengan index(): {e}")

# Menggunakan find() - mengembalikan -1 jika tidak ditemukan
pos_find = text.find("powerful")
print(f"find('powerful'): {pos_find}")

pos_not_found = text.find("Java")
print(f"find('Java'): {pos_not_found}")

# Gunakan membership jika hanya perlu memeriksa keberadaan
print(f"Mengandung 'Python': {'Python' in text}")

# Pencarian dengan parameter start dan end
substring = "programming"
start_pos = text.find(substring, 20)  # mulai dari posisi 20
print(f"'{substring}' setelah posisi 20: {start_pos}")

# Menghitung kemunculan substring
count = text.count("a")
print(f"Huruf 'a' muncul {count} kali")

Pilih metode berdasarkan kontrak kegagalannya: find() mengembalikan -1, sedangkan index() menghasilkan ValueError. Jika kamu hanya membutuhkan jawaban ya atau tidak, operator in lebih jelas daripada kedua metode posisi tersebut.

validasi_karakter.py

# Contoh validasi berbagai jenis karakter
test_strings = [
  "Python",
  "Python3",
  "12345",
  "Hello World",
  "hello123",
  "UPPERCASE",
  "lowercase",
  "",
  "   "
]

print("String\t\tAlpha\tDigit\tAlnum\tUpper\tLower")
print("-" * 60)

for s in test_strings:
  alpha = s.isalpha()
  digit = s.isdigit()
  alnum = s.isalnum()
  upper = s.isupper()
  lower = s.islower()

  print(f"'{s:<10}'\t{alpha}\t{digit}\t{alnum}\t{upper}\t{lower}")

# Contoh penggunaan praktis untuk validasi input
def validate_username(username):
  if not username:
      return "Username tidak boleh kosong"
  if not username.isascii() or not username.isalnum():
      return "Username hanya boleh berisi huruf dan angka ASCII"
  if len(username) < 3:
      return "Username minimal 3 karakter"
  return "Username valid"

# Test validasi
usernames = ["user123", "user@123", "ab", "ValidUser"]
for username in usernames:
  result = validate_username(username)
  print(f"'{username}': {result}")

Metode seperti isdigit() dan isalnum() mengikuti Unicode, sedangkan string kosong membuat keduanya mengembalikan False. Nomor telepon, kode pos, atau username tetap memerlukan aturan eksplisit tentang alfabet, panjang, pemisah, prefix, dan batasan domain lainnya.

Metode startswith() dan endswith() memungkinkan kamu memeriksa apakah string dimulai atau diakhiri dengan substring tertentu.

awalan_akhiran.py

# Contoh penggunaan startswith dan endswith
files = [
  "document.pdf",
  "image.jpg",
  "script.py",
  "data.csv",
  "README.md",
  "backup.zip"
]

# Memeriksa ekstensi file
print("File dengan ekstensi tertentu:")
for file in files:
  if file.endswith(".py"):
      print(f"Python file: {file}")
  elif file.endswith((".jpg", ".png", ".gif")):
      print(f"Image file: {file}")
  elif file.endswith(".pdf"):
      print(f"PDF file: {file}")

# Memeriksa awalan
urls = [
  "https://www.google.com",
  "http://example.com",
  "ftp://files.example.com",
  "mailto:user@example.com"
]

print("\nAnalisis URL:")
for url in urls:
  if url.startswith("https://"):
      print(f"Secure web: {url}")
  elif url.startswith("http://"):
      print(f"Web: {url}")
  elif url.startswith("ftp://"):
      print(f"FTP: {url}")
  elif url.startswith("mailto:"):
      print(f"Email: {url}")

# Penggunaan dengan tuple untuk multiple prefix/suffix
text = "Hello World"
print(f"\nStarts with greeting: {text.startswith(('Hi', 'Hello', 'Hey'))}")

replace_method.py

# Contoh penggunaan metode replace
text = "Python sangat berguna. Python sangat kuat. Python mudah dipelajari."
print(f"Original: {text}")

# Replace semua kemunculan
replaced = text.replace("Python", "Java")
print(f"Replace all: {replaced}")

# Replace dengan batasan jumlah
limited_replace = text.replace("Python", "Java", 2)
print(f"Replace 2 first: {limited_replace}")

# Replace dengan string kosong (menghapus)
no_dots = text.replace(".", "")
print(f"Remove dots: {no_dots}")

# Chaining replace untuk multiple replacements
sentence = "I love cats and dogs"
animal_replace = sentence.replace("cats", "birds").replace("dogs", "fish")
print(f"Chain replace: {animal_replace}")

# Replace case-sensitive
case_text = "Hello hello HELLO"
case_replace = case_text.replace("hello", "hi")
print(f"Case sensitive: {case_replace}")

# Contoh praktis: membersihkan nomor telepon
phone = "+62-812-3456-7890"
clean_phone = phone.replace("-", "").replace("+", "")
print(f"Clean phone: {clean_phone}")

Metode replace() bersifat case-sensitive dan mengganti semua kemunculan kecuali jika dibatasi dengan parameter ketiga.

Metode split() memecah string menjadi list di sekitar delimiter tertentu. Tanpa delimiter, metode ini memperlakukan whitespace berurutan sebagai satu pemisah dan membuang field kosong di awal atau akhir.

split_method.py

# Berbagai cara menggunakan split
text = "apple,banana,orange,grape"
print(f"Original: {text}")

# Split dengan delimiter koma
fruits = text.split(",")
print(f"Split by comma: {fruits}")

# Split tanpa parameter (default whitespace)
sentence = "Python is a great language"
words = sentence.split()
print(f"Split by space: {words}")

# Split dengan batasan
limited_split = text.split(",", 2)
print(f"Split max 2: {limited_split}")

# Split dengan multiple whitespace
messy_text = "word1    word2\t\tword3\n\nword4"
clean_split = messy_text.split()
print(f"Clean split: {clean_split}")

# Field sederhana berpemisah koma tanpa kutip
csv_line = "John,25,Engineer,New York"
data = csv_line.split(",")
name, age, job, city = data
print(f"Name: {name}, Age: {age}, Job: {job}, City: {city}")

# Split dengan karakter yang tidak ada
no_delimiter = "no-delimiter-here"
result = no_delimiter.split(",")
print(f"No delimiter found: {result}")

# Menggabungkan kembali dengan join
joined = " | ".join(fruits)
print(f"Joined with pipe: {joined}")

Gunakan split() hanya jika aturan delimiter memang sederhana. Metode ini tidak memahami field CSV yang dikutip, escaping, atau path lintas platform. Gunakan modul csv untuk CSV dan pathlib untuk path filesystem.

Karena metode string mengembalikan string baru, beberapa transformasi dapat dirangkai dalam satu ekspresi. Pertahankan rantainya cukup pendek agar setiap langkah tetap jelas; beri nama nilai antara jika ada validasi atau penjelasan di tengah proses.

method_chaining.py

# Contoh method chaining pada string
messy_input = "   +++ Python Programming for Beginners ---   "
print(f"Input: '{messy_input}'")

# Chaining multiple methods
clean_result = (messy_input
              .strip()  # hapus spasi di awal/akhir
              .strip("+-")  # hapus karakter + dan -
              .lower()  # ubah ke lowercase
              .replace("beginners", "experts"))  # ganti kata

print(f"Clean result: '{clean_result}'")

# Contoh chaining untuk format label tampilan
labels = ["  MULAI DI SINI  ", "  dasar ARRAY  ", "  pembersihan DATA  "]
formatted_labels = []

for label in labels:
  formatted = label.strip().title()
  formatted_labels.append(formatted)

print("Label yang sudah diformat:")
for label in formatted_labels:
  print(f"- {label}")

# Chaining dalam list comprehension
sentences = [
  "  hello WORLD  ",
  "  PYTHON programming  ",
  "  DATA science  "
]

processed = [s.strip().title() for s in sentences]
print(f"Processed sentences: {processed}")

# Normalisasi domain tanpa diam-diam menghapus whitespace yang tidak valid
def normalize_email(email):
  cleaned = email.strip()
  if any(char.isspace() for char in cleaned) or cleaned.count("@") != 1:
      raise ValueError("Email harus memiliki satu @ dan tanpa whitespace")

  local, domain = cleaned.split("@", 1)
  if not local or not domain:
      raise ValueError("Email memerlukan bagian lokal dan domain")

  return f"{local}@{domain.lower()}"

emails = ["  USER@EXAMPLE.COM  ", "Test.User@Gmail.com", "admin@site.org"]
for email in emails:
  processed = normalize_email(email)
  print(f"'{email}' -> '{processed}'")

aplikasi_praktis.py

# Aplikasi praktis metode string dalam berbagai skenario

# 1. Validasi dan format nomor telepon
def format_phone_number(phone):
  # Hanya menerima digit ASCII dan pemisah yang didukung contoh ini
  allowed_separators = {" ", "-", "(", ")", "+"}
  if any(char not in "0123456789" and char not in allowed_separators for char in phone):
      return "Nomor telepon mengandung karakter yang tidak valid"

  digits_only = "".join(char for char in phone if char in "0123456789")

  # Format sesuai standar Indonesia
  if len(digits_only) == 13 and digits_only.startswith("62"):
      return f"+{digits_only[:2]}-{digits_only[2:5]}-{digits_only[5:9]}-{digits_only[9:]}"
  elif len(digits_only) == 12 and digits_only.startswith("08"):
      return f"{digits_only[:4]}-{digits_only[4:8]}-{digits_only[8:]}"
  else:
      return "Format nomor tidak valid"

phone_numbers = ["081234567890", "+6281234567890", "0812-3456-7890"]
for phone in phone_numbers:
  formatted = format_phone_number(phone)
  print(f"'{phone}' -> '{formatted}'")

# 2. Ekstrak informasi dari nama file
def analyze_filename(filename):
  # Pisahkan nama dan ekstensi
  if "." in filename:
      name, ext = filename.rsplit(".", 1)
      ext = ext.lower()
  else:
      name, ext = filename, ""

  # Analisis jenis file
  image_exts = ["jpg", "jpeg", "png", "gif", "bmp"]
  doc_exts = ["pdf", "doc", "docx", "txt"]
  code_exts = ["py", "js", "html", "css", "java"]

  if ext in image_exts:
      file_type = "Image"
  elif ext in doc_exts:
      file_type = "Document"
  elif ext in code_exts:
      file_type = "Code"
  else:
      file_type = "Unknown"

  return {
      "name": name,
      "extension": ext,
      "type": file_type,
      "length": len(filename)
  }

files = ["photo.jpg", "report.pdf", "script.py", "data", "image.PNG"]
for file in files:
  info = analyze_filename(file)
  print(f"{file}: {info}")

# 3. Parser sederhana untuk log file
def parse_log_entry(log_line):
  # Format: [TIMESTAMP] LEVEL: MESSAGE
  if not log_line.strip():
      return None

  # Ekstrak timestamp
  if log_line.startswith("[") and "]" in log_line:
      end_bracket = log_line.index("]")
      timestamp = log_line[1:end_bracket]
      rest = log_line[end_bracket + 1:].strip()
  else:
      timestamp = "Unknown"
      rest = log_line.strip()

  # Ekstrak level
  if ":" in rest:
      level, message = rest.split(":", 1)
      level = level.strip()
      message = message.strip()
  else:
      level = "INFO"
      message = rest

  return {
      "timestamp": timestamp,
      "level": level,
      "message": message
  }

log_entries = [
  "[2023-09-17 10:30:15] ERROR: Database connection failed",
  "[2023-09-17 10:30:16] INFO: Retrying connection",
  "WARNING: Low disk space",
  ""
]

print("\nLog parsing results:")
for entry in log_entries:
  parsed = parse_log_entry(entry)
  if parsed:
      print(f"Time: {parsed['timestamp']}, Level: {parsed['level']}, Message: {parsed['message']}")

# 4. Pembuat slug URL dari judul
def create_slug(title):
  # Konversi ke lowercase dan ganti spasi dengan dash
  slug = title.lower()

  # Ganti karakter non-alphanumeric dengan dash
  clean_slug = ""
  for char in slug:
      if char.isalnum():
          clean_slug += char
      else:
          if clean_slug and clean_slug[-1] != "-":
              clean_slug += "-"

  # Hapus dash di awal dan akhir
  return clean_slug.strip("-")

titles = [
  "Belajar Python untuk Pemula",
  "Tips & Trik Programming",
  "Data Science: Panduan Lengkap",
  "Machine Learning 101"
]

print("\nSlug generation:")
for title in titles:
  slug = create_slug(title)
  print(f"'{title}' -> '{slug}'")

Keempat contoh ini menggabungkan klasifikasi, pencarian, pemisahan, dan penggantian di bawah format kecil yang dinyatakan jelas. Parser telepon, nama file, log, atau pembuat slug untuk produksi juga membutuhkan kontrak domain, kebijakan error, dan pengujian input ambigu.

Metode String

String Bersifat Immutable

Metode String

String Bersifat Immutable

Mengukur Panjang String

Metode Transformasi String

Mengubah Case Huruf

Menghapus Karakter di Awal dan Akhir

Metode Pencarian dan Validasi

Mencari Posisi Substring

Validasi Karakter String

Metode Pencarian Awalan dan Akhiran

Metode Replace dan Split

Mengganti Substring

Memisahkan String

Chaining Metode String

Aplikasi Praktis Metode String