Indexing dan Slicing

Mengakses Elemen dengan Indeks

Indexing mengambil satu elemen berdasarkan posisinya dari string atau list. Misalnya, jika huruf = ["a", "b", "c"], maka huruf[1] menghasilkan "b".

Python memulai nomor indeks dari $0$. Elemen pertama memiliki indeks $0$, elemen kedua memiliki indeks $1$, dan seterusnya. Python juga mendukung indeks negatif yang menghitung mundur dari akhir.

Indeks Positif dan Negatif

Dalam string atau list, setiap karakter atau elemen memiliki dua jenis indeks. Indeks positif dimulai dari $0$ di awal, sedangkan indeks negatif dimulai dari $-1$ di akhir.

Tabel ini menempatkan dua indeks pada elemen yang sama. Indeks 1 dan -4 sama-sama memilih e. Contoh kode memakai repr() agar tanda kutip dan string kosong terlihat pada keluaran.

# Contoh indexing pada string
s = "Hello"

# Mengakses karakter dengan indeks positif
print(repr(s[0]))    # Output: 'H'
print(repr(s[4]))    # Output: 'o'

# Mengakses karakter dengan indeks negatif
print(repr(s[-1]))   # Output: 'o'
print(repr(s[-5]))   # Output: 'H'

# Mencoba mengakses indeks yang tidak ada
try:
  print(repr(s[5]))
except IndexError:
  print("IndexError: indeks di luar jangkauan")

Indeks di luar rentang yang valid menghasilkan IndexError. Python memeriksa batas string dan list sebelum mengambil elemennya.

Mengambil Beberapa Elemen

Slicing memilih sebagian elemen dari string atau list melalui batas awal, batas akhir, dan step. Indeks akhir tidak disertakan. Panjang hasil bergantung pada batas yang sudah disesuaikan dengan panjang data dan pada step.

Slicing dengan Dua Batas

Sintaks [i:j] memakai i sebagai indeks awal dan j sebagai indeks akhir. Elemen pada indeks i masuk ke hasil, sedangkan elemen pada indeks j tidak.

# Contoh slicing pada string
s = "Hello"

# Mengambil indeks 1 sampai sebelum indeks 3
print(repr(s[1:3]))    # Output: 'el'

# Mengambil indeks 3 sampai akhir
print(repr(s[3:]))     # Output: 'lo'

# Mengambil awal string sampai sebelum indeks 3
print(repr(s[:3]))     # Output: 'Hel'

# Menggunakan indeks negatif
print(repr(s[-4:-2]))  # Output: 'el'
print(repr(s[-2:-4]))  # Output: ''

Jika indeks awal lebih besar daripada indeks akhir dan step bernilai positif, slicing menghasilkan string atau list kosong. Step negatif memilih elemen ke arah sebaliknya.

Mengatur Jarak Antar Elemen

Parameter ketiga dalam [start:stop:step] menentukan jarak antarelemen yang dipilih. Nilai step sebesar 2, misalnya, mengambil satu elemen lalu melewati satu elemen berikutnya.

# Contoh slicing dengan step tertentu
s = "Hello World!"

# Mengambil setiap karakter kedua
print(repr(s[::2]))      # Output: 'HloWrd'

# Mengambil setiap karakter kedua dari indeks 1
print(repr(s[1::2]))     # Output: 'el ol!'

# Membalik string dengan step negatif
print(repr(s[::-1]))     # Output: '!dlroW olleH'

# Memilih mundur dari indeks tertentu
print(repr(s[-1:4:-1]))  # Output: '!dlroW '

Step negatif membalik arah pemilihan. Bentuk s[::-1] mengosongkan kedua batas dan memilih semua elemen dari akhir ke awal. step tidak boleh nol karena Python tidak dapat maju ke indeks berikutnya.

Aturan Slicing

Indeks awal, indeks akhir, dan step menentukan elemen yang masuk ke hasil. Aturan utamanya: indeks awal ikut diambil, indeks akhir tidak, dan step negatif membalik arah pembacaan dari kanan ke kiri.

Menghitung Panjang Hasil

Misalkan $n$ adalah panjang s. Untuk kasus $0 \le i \le j \le n$ dengan step positif bawaan, panjang s[i:j] adalah $j-i$. Bentuk lain dapat mengosongkan batas, memakai indeks negatif, melewati rentang, atau menentukan step berbeda. Python menyesuaikan batas tersebut terhadap panjang data. Jumlah elemen hasil slicing dapat dihitung dengan len(range(*slice(i, j, step).indices(len(s)))).

# Menghitung panjang hasil slicing
s = "Hello"

# Mengiris s[1:4]
result = s[1:4]
print(f"Hasil: '{result}', Panjang: {len(result)}")  # Output: Hasil: 'ell', Panjang: 3

# Membuktikan bahwa s[:i] + s[i:] == s
i = 2
left_part = s[:i]
right_part = s[i:]
print(f"'{left_part}' + '{right_part}' = '{left_part + right_part}'")

# Batas di luar rentang akan disesuaikan
print(repr(s[3:10]))   # Output: 'lo'
print(repr(s[10:]))    # Output: ''

Saat melakukan slicing, Python menyesuaikan batas yang berada di luar rentang dengan panjang string atau list. Karena itu, s[3:10] tetap valid meskipun indeks akhir melewati panjang s.

Indeks yang Dipilih

Fungsi range() dapat menunjukkan indeks mana saja yang dipilih oleh slicing. Perbandingan ini menjelaskan indeks hasil slicing pada contoh ini.

# Membandingkan slicing dengan loop
s = "Hello World!"

# s[1:8:2] memilih indeks yang sama dengan loop berikut
result_manual = ""
for index in range(1, 8, 2):
  result_manual += s[index]

result_slicing = s[1:8:2]

print(f"Loop manual: '{result_manual}'")  # Output: 'el o'
print(f"Hasil slicing: '{result_slicing}'")  # Output: 'el o'
print(f"Sama? {result_manual == result_slicing}")  # Output: True

# Contoh dengan step negatif
print("\nStep negatif:")
print(f"s[::-2] = '{s[::-2]}'")            # Output: '!lo le'

# Loop yang memilih indeks yang sama
result_negative = ""
for index in range(len(s)-1, -1, -2):
  result_negative += s[index]
print(f"Manual: '{result_negative}'")

Perbandingan dengan range() menunjukkan bagaimana batas awal, batas akhir, dan step bekerja bersama, terutama ketika step bernilai negatif.

Bentuk Singkat Slicing

Batas yang dikosongkan mengikuti arah step. Untuk step positif, awal bawaan adalah awal data dan akhir bawaan melewati elemen terakhir. Untuk step negatif, awal bawaan adalah elemen terakhir dan akhir bawaan melewati elemen pertama.

Mengambil dari Awal atau Sampai Akhir

Dengan step positif bawaan, s[:3] mengambil bagian awal dan s[3:] mengambil bagian akhir. Pada s[::-1], kedua batas mengikuti arah negatif sehingga urutannya terbalik.

# Beberapa bentuk singkat slicing
s = "Hello"

# Mengambil 3 karakter pertama
print(repr(s[:3]))     # Output: 'Hel'

# Mengambil karakter dari indeks 3 sampai akhir
print(repr(s[3:]))     # Output: 'lo'

# Mengambil semua karakter
print(repr(s[:]))      # Output: 'Hello'

# Contoh praktis dengan list
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Mengambil 5 elemen pertama
first_five = numbers[:5]
print(f"Lima pertama: {first_five}")

# Mengambil 5 elemen terakhir
last_five = numbers[-5:]
print(f"Lima terakhir: {last_five}")

# Mengambil elemen tengah setelah melewati 2 elemen di setiap ujung
middle = numbers[2:-2]
print(f"Bagian tengah: {middle}")

Bentuk-bentuk tersebut dapat mengambil bagian tertentu atau elemen dengan selang tetap dari dataset tanpa menulis loop terpisah.

Mengolah Bagian String dan List

Contoh berikut memakai indexing dan slicing untuk membalik string, memformat nomor telepon, membuat inisial, dan memeriksa palindrom. Contoh ekstensi file menunjukkan alasan memakai Path.suffix ketika panjang ekstensi tidak tetap.

# Contoh penggunaan indexing dan slicing

# 1. Membalik nama
nama_depan = "Ahmad"
nama_belakang = "Wijaya"
nama_terbalik = (nama_depan + " " + nama_belakang)[::-1]
print(f"Nama terbalik: {nama_terbalik}")

# 2. Mengambil ekstensi file dengan aman
from pathlib import Path

nama_file = "dokumen_penting.pdf"
ekstensi = Path(nama_file).suffix
print(f"Ekstensi: {ekstensi}")

# 3. Memformat nomor telepon
nomor = "081234567890"
formatted = f"{nomor[:4]}-{nomor[4:8]}-{nomor[8:]}"
print(f"Nomor terformat: {formatted}")

# 4. Mengambil inisial nama
nama_lengkap = "Siti Nurhaliza Binti Ahmad"
kata_kata = nama_lengkap.split()
inisial = ""
for kata in kata_kata:
  inisial += kata[0]
print(f"Inisial: {inisial}")

# 5. Palindrome checker
def is_palindrome(text):
  cleaned = "".join(character for character in text.casefold() if character.isalnum())
  return cleaned == cleaned[::-1]

print(f"'katak' palindrome? {is_palindrome('katak')}")
print(f"'kasur rusak' palindrome? {is_palindrome('kasur rusak')}")

Gunakan indexing untuk mengambil satu elemen pada posisi yang diketahui. Gunakan slicing untuk mengambil beberapa elemen yang berurutan atau berjarak tetap. Bentuk [::-1] membalik urutan elemen. Untuk ekstensi file, jangan mengandalkan jumlah karakter tetap karena panjang ekstensi dapat berbeda. Path.suffix membaca ekstensi sesuai struktur path.

Batas slicing disesuaikan dengan panjang data, sehingga s[10:] pada string yang lebih pendek menghasilkan "". Akses langsung seperti s[10] tetap menghasilkan IndexError. Gunakan slicing hanya jika hasil kosong memang dapat diterima.

Indeks negatif menghitung posisi dari akhir data. Gunakan s[-1] untuk elemen terakhir atau s[-3:] untuk tiga elemen terakhir. Bentuk ini dapat dipakai saat memproses file, parsing teks, atau mengolah dataset yang elemennya perlu dihitung dari akhir.