Belajar Python - Tipe Data Lanjutan & Koleksi

#Pendahuluan

List, dict, set, dan tuple sudah kita kenal. Namun Python memiliki modul collections yang menyediakan versi-versi khusus dengan perilaku dan performa lebih baik untuk kasus tertentu. Episode 5 membahasnya satu per satu.

Selain itu kita mulai menyentuh typing — anotasi tipe yang menjadi semakin penting di Python modern dan akan kita perdalam di episode 17. Terakhir, kita bahas pertimbangan memory dan performa agar kalian bisa memilih struktur data yang tepat.

#Modul collections

#deque: Antrian Dua Arah

deque adalah antrian dua arah dengan operasi append dan pop di kedua ujung dalam waktu O(1):

Menggunakan deque

from collections import deque
 
antrian = deque(["a", "b", "c"])
antrian.append("d")
antrian.appendleft("z")
print(antrian)
 
item = antrian.popleft()
print(item)
print(antrian)

deque(["a", "b", "c"]) membuat antrian dua arah. Berbeda dengan list yang insert(0, ...)-nya lambat, deque.appendleft dan popleft selalu cepat. deque sangat cocok untuk queue, buffer, dan sliding window.

#defaultdict: Default Otomatis

defaultdict memberikan nilai default otomatis saat kunci belum ada, menghilangkan boilerplate pengecekan:

Menggunakan defaultdict

from collections import defaultdict
 
jumlah = defaultdict(int)
kata = ["a", "b", "a", "c", "a"]
 
for k in kata:
    jumlah[k] += 1
 
print(dict(jumlah))
print(jumlah["tidak_ada"])

defaultdict(int) membuat dict yang memanggil int() saat kunci tidak ditemukan, sehingga jumlah[k] += 1 langsung bekerja tanpa pengecekan. Variasi lain bisa memakai list, set, atau fungsi kustom.

#Counter: Menghitung Kemunculan

Counter adalah dict khusus untuk menghitung kemunculan elemen:

Menggunakan Counter

from collections import Counter
 
kata = ["apel", "jeruk", "apel", "mangga", "apel"]
hitung = Counter(kata)
 
print(hitung)
print(hitung.most_common(2))

Counter(kata) menghitung frekuensi setiap elemen. hitung.most_common(2) mengembalikan dua elemen paling sering muncul. Counter mendukung operasi aritmetika seperti penjumlahan dan pengurangan antar Counter.

#namedtuple: Tuple Bernama

namedtuple membuat tuple yang field-nya bisa diakses dengan nama:

Menggunakan namedtuple

from collections import namedtuple
 
Titik = namedtuple("Titik", ["x", "y"])
t = Titik(3, 4)
 
print(t.x)
print(t.y)
print(t[0])

namedtuple("Titik", ["x", "y"]) membuat kelas tuple dengan field bernama. t.x dan t[0] mengembalikan nilai yang sama. namedtuple memberi kode yang lebih deskriptif dengan tetap hemat memory seperti tuple.

#Dasar-dasar typing

#Anotasi Tipe Sederhana

Modul typing menyediakan tipe generik untuk anotasi. Anotasi membuat kode lebih jelas dan bisa diperiksa oleh mypy:

Anotasi tipe dasar

from typing import List, Dict, Optional
 
def rata_rata(angka: List[float]) -> float:
    return sum(angka) / len(angka)
 
def cari_nama(data: Dict[str, str], kunci: str) -> Optional[str]:
    return data.get(kunci)
 
print(rata_rata([1.0, 2.0, 3.0]))
print(cari_nama({"a": "Arman"}, "a"))

List[float] menyatakan list berisi float, Dict[str, str] memetakan string ke string, dan Optional[str] bisa berisi string atau None. Anotasi tidak memengaruhi runtime, tapi menjadi dokumentasi dan bahan validasi mypy di episode 17.

#Union dan Tipe Lebih Kompleks

Untuk kasus yang lebih kompleks, Python 3.10 ke atas menyediakan sintaks X | Y:

Union dengan pipe

from typing import Union
 
def tampilkan(nilai: Union[int, str]) -> str:
    return str(nilai)
 
def tampilkan_py310(nilai: int | str) -> str:
    return str(nilai)
 
print(tampilkan(10))
print(tampilkan_py310("halo"))

int | str di Python 3.10 adalah pengganti Union[int, str]. Sintaks pipe ini lebih ringkas dan menjadi standar di kode modern. Kita akan membahas Annotated, TypedDict, Protocol, dan ParamSpec di episode 17.

#Memory dan Performa Struktur Data

#Membandingkan Koleksi

Setiap struktur data punya trade-off memory dan kecepatan:

• list: urutan dinamis, akses indeks cepat, pencarian linear lambat.
• tuple: seperti list tapi immutable dan lebih hemat memory.
• dict: pencarian kunci cepat O(1), tapi boros memory.
• set: keanggotaan cepat O(1), elemen unik tanpa urutan.
• deque: operasi kedua ujung cepat, ideal untuk antrian.

#Contoh Perbandingan Praktis

Mari bandingkan kecepatan pencarian list dan set dengan data yang besar:

Perbandingan list vs set

import time
 
data = list(range(100_000))
target = 99_999
 
mulai = time.perf_counter()
ada_list = target in data
lama_list = time.perf_counter() - mulai
 
himpunan = set(data)
mulai = time.perf_counter()
ada_set = target in himpunan
lama_set = time.perf_counter() - mulai
 
print(ada_list, lama_list)
print(ada_set, lama_set)

target in himpunan memakai hash table sehingga pencarian hampir instan, sedangkan target in data pada list memindai linear. Untuk pengecekan keanggotaan berulang, set selalu lebih unggul.

#Penutup

Inti yang harus dibawa pulang:

• deque menyediakan operasi O(1) di kedua ujung untuk antrian.
• defaultdict memberikan nilai default otomatis saat kunci kosong.
• Counter menghitung kemunculan elemen dengan mudah.
• namedtuple memberi nama pada field tuple tanpa kehilangan efisiensi.
• typing memberi anotasi tipe yang diperiksa mypy.
• Pilih struktur data berdasarkan trade-off memory dan kecepatan.

Di episode 6 selanjutnya kita akan membahas exception handling dan resource management — try, except, else, dan finally, pembuatan exception custom, context manager dengan kata kunci with, dan contextlib untuk membuat context manager sendiri. Ini keterampilan penting agar program kalian tangguh menghadapi error!