List comprehension di Python: sintaks, filter, dan dict comprehension

Satu baris, satu ide

Kamu sudah beberapa kali menulis pola ini: mulai dengan list kosong, lakukan perulangan pada sesuatu, mungkin disaring, lalu append ke hasilnya.

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

List comprehension menyatakan hal yang sama dalam satu baris:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

Baca dari kiri ke kanan: "list baru yang berisi n * 2, untuk setiap n di numbers." Strukturnya adalah [expression for item in iterable].

Ini bukan trik khusus Python. Namanya comprehension karena kamu menjelaskan apa yang masuk ke list baru itu secara deklaratif, bukan menuliskan mekanisme cara membangunnya.

Menambahkan filter

Taruh klausa if setelah bagian perulangan untuk menyaring:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = [n for n in numbers if n % 2 == 0]
print(evens)

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

Baca yang kedua sebagai: "n * n untuk setiap n di numbers, tapi hanya kalau n ganjil."

Perulangan yang setara:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

Keduanya tidak masalah. Comprehension lebih pendek, dan begitu kamu sudah membaca beberapa, justru lebih mudah ditelusuri karena maksudnya langsung terlihat dalam satu baris.

Map dan filter sekaligus

Kamu bisa mengolah nilai lewat sebuah fungsi dan menyaringnya di saat yang sama:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

Untuk setiap kata yang lebih dari 3 huruf, masukkan versi huruf besarnya.

Perulangan bersarang dalam comprehension

Dua for menghasilkan pasangan bergaya cartesian product:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

Urutannya sama seperti kalau kamu menulis perulangan bersarang: for pertama adalah yang luar, yang kedua adalah yang dalam. Bacanya dari kiri ke kanan seperti perulangan berindentasi yang setara.

Dua level kira-kira batasnya sebelum perulangan biasa lebih enak dibaca. Kalau sudah sampai tiga, kembali ke perulangan biasa.

Dictionary comprehension dan set comprehension

Idenya sama, kurungnya berbeda:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension - produces a dict
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension - produces a set
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

Sekilas set comprehension terlihat sama dengan dict comprehension; bedanya ada pada key: value vs satu ekspresi saja. Kurung kurawal ditambah : berarti dict; kurung kurawal tanpa : berarti set.

Generator expression

Hampir kembar dengan list comprehension, tapi memakai kurung biasa, bukan kurung siku, dan yang terpenting, tidak membangun list:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

Perhatikan bahwa kita memberikan generator itu langsung ke sum() dan any(), tanpa tanda kurung tambahan. Generator expression adalah alat yang tepat saat pemanggilnya hanya perlu melakukan iterasi sekali. Untuk koleksi besar, generator expression lebih hemat memori daripada list lengkap.

Kapan memakai perulangan biasa saja

Comprehension itu menggoda. Secara teknis kamu bisa menjejalkan banyak hal ke dalamnya. Jangan lakukan itu.

Pakai perulangan biasa kalau:

• Transformasinya lebih dari satu langkah. Kalau kamu butuh variabel perantara, tuliskan secara lengkap.
• Ada penanganan error atau percabangan yang rumit.
• Siapa pun yang membaca baris itu harus berhenti lebih dari sekali untuk memahaminya.

Aturan yang aku pakai: kalau aku bisa membaca comprehension itu dalam satu tarikan napas dan paham apa yang dilakukannya, biarkan. Kalau aku tersandung, tulis ulang sebagai perulangan.

Beberapa comprehension terlihat cerdas tapi menyusahkan:

# Clever but exhausting:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# Clearer as a loop:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

Hasilnya sama. Versi perulangan lima baris, bukan satu, tapi "lebih panjang" tidak sama dengan "lebih buruk."

Beberapa pola yang akan kamu pakai berulang kali

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# Grab one attribute from each element.
names = [u["name"] for u in users]
print(names)

# Filter and project in one go.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# Build a lookup dict keyed by a field.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# Count how many pass a test.
active_count = sum(1 for u in users if u["active"])
print(active_count)

Kelima pola itu mencakup cukup banyak pekerjaan data sehari-hari, lebih dari yang kamu kira.

Berikutnya

Sekarang kamu sudah melihat tipe-tipe koleksi utama dan comprehension yang menyatukannya. Bab berikutnya: fungsi, yaitu mengemas perilaku menjadi unit bernama yang bisa dipakai ulang.