34. Comprehensions: Cara Ringkas Membuat List, Dictionary, dan Set

Comprehension adalah salah satu fitur Python yang paling elegan, memungkinkan kamu membuat dan mentransformasi koleksi dalam satu baris kode yang mudah dibaca. Alih-alih menulis banyak baris dengan loop dan operasi append, comprehension memungkinkan kamu mengekspresikan logika yang sama dengan lebih ringkas dan sering kali lebih jelas.

Di bab ini, kita akan membahas cara menggunakan list comprehension, dictionary comprehension, dan set comprehension untuk menulis kode yang lebih Pythonic. Kita akan melihat cara memasukkan logika kondisional, kapan memilih comprehension dibanding loop tradisional, serta cara menangani skenario yang lebih kompleks dengan iterasi bertingkat.

34.1) List Comprehensions untuk Membuat dan Mentransformasi List

34.1.1) Sintaks Dasar List Comprehension

Sebuah list comprehension menyediakan cara ringkas untuk membuat list baru dengan menerapkan sebuah ekspresi pada setiap item dalam sebuah urutan yang sudah ada. Sintaks dasarnya adalah:

python

[expression for item in iterable]

Ini membuat list baru di mana setiap elemennya adalah hasil evaluasi expression untuk setiap item di dalam iterable (urutan apa pun yang bisa kamu loop, seperti list, range, atau string).

Mari mulai dengan contoh sederhana. Misalnya kita ingin membuat list kuadrat untuk angka 0 sampai 4:

python

# Traditional approach with a loop
squares = []
for number in range(5):
    squares.append(number ** 2)
print(squares)  # Output: [0, 1, 4, 9, 16]

Dengan list comprehension, kita bisa menuliskannya lebih ringkas:

python

# Using a list comprehension
squares = [number ** 2 for number in range(5)]
print(squares)  # Output: [0, 1, 4, 9, 16]

Kedua pendekatan menghasilkan output yang sama, tetapi comprehension lebih ringkas dan, setelah kamu familiar dengan sintaksnya, sering kali lebih mudah dibaca. Comprehension dengan jelas menunjukkan bahwa kita sedang membuat list berisi nilai kuadrat.

34.1.2) Mentransformasi Data yang Sudah Ada

List comprehension sangat bagus untuk mentransformasi data dari satu bentuk ke bentuk lain. Mari lihat beberapa contoh praktis.

Mengonversi suhu dari Celsius ke Fahrenheit:

python

# Temperature data in Celsius
celsius_temps = [0, 10, 20, 30, 40]
 
# Convert to Fahrenheit using the formula: F = C * 9/5 + 32
fahrenheit_temps = [temp * 9/5 + 32 for temp in celsius_temps]
print(fahrenheit_temps)  # Output: [32.0, 50.0, 68.0, 86.0, 104.0]

Mengonversi string menjadi huruf besar:

python

# Product codes in mixed case
product_codes = ["abc123", "def456", "ghi789"]
 
# Standardize to uppercase
uppercase_codes = [code.upper() for code in product_codes]
print(uppercase_codes)  # Output: ['ABC123', 'DEF456', 'GHI789']

34.1.3) Membuat List dari Objek Range

List comprehension bekerja secara alami dengan range(), yang sudah kita pelajari di Bab 12. Ini berguna untuk menghasilkan urutan dengan pola tertentu:

python

# Generate even numbers from 0 to 10
evens = [n * 2 for n in range(6)]  # n goes from 0 to 5, so n*2 gives 0, 2, 4, 6, 8, 10
print(evens)  # Output: [0, 2, 4, 6, 8, 10]
 
# Generate multiples of 5
multiples_of_five = [n * 5 for n in range(1, 6)]
print(multiples_of_five)  # Output: [5, 10, 15, 20, 25]

34.1.4) Comprehension vs Membangun List dengan Append

Penting untuk memahami bahwa list comprehension membuat seluruh list dalam satu operasi, sedangkan pendekatan loop tradisional membangun list secara bertahap. Keduanya menghasilkan output yang sama, tetapi comprehension umumnya lebih cepat untuk membuat list baru dan dianggap lebih Pythonic.

Berikut perbandingan berdampingan:

python

# Traditional loop approach
result = []
for i in range(5):
    result.append(i * 3)
print(result)  # Output: [0, 3, 6, 9, 12]
 
# List comprehension approach
result = [i * 3 for i in range(5)]
print(result)  # Output: [0, 3, 6, 9, 12]

Kedua pendekatan valid, tetapi comprehension lebih ringkas dan mengekspresikan maksudnya dengan jelas: "buat sebuah list nilai di mana setiap nilainya adalah i * 3."

34.2) Logika Kondisional di Dalam List Comprehension

34.2.1) Memfilter dengan Kondisi if

Salah satu fitur paling kuat dari list comprehension adalah kemampuan untuk memfilter item berdasarkan sebuah kondisi. Kamu bisa menambahkan klausa if di akhir comprehension untuk memasukkan hanya item yang memenuhi kriteria tertentu:

python

[expression for item in iterable if condition]

Klausa if bertindak sebagai filter: Python mengevaluasi kondisi untuk setiap item, dan hanya item yang kondisinya True yang akan dimasukkan ke list hasil. Item yang tidak memenuhi kondisi akan dilewati sepenuhnya.

Mari lihat ini dalam contoh sederhana:

python

# Get only even numbers from 0 to 9
numbers = range(10)
evens = [n for n in numbers if n % 2 == 0]
print(evens)  # Output: [0, 2, 4, 6, 8]

Di sini, n % 2 == 0 mengecek apakah sebuah angka genap. Hanya angka yang lolos tes ini yang dimasukkan ke list baru.

Memfilter nilai ujian siswa:

python

# Student test scores
scores = [45, 78, 92, 65, 88, 55, 73, 95]
 
# Get only passing scores (>= 70)
passing_scores = [score for score in scores if score >= 70]
print(passing_scores)  # Output: [78, 92, 88, 73, 95]

34.2.2) Mentransformasi Item yang Sudah Difilter

Kamu bisa menggabungkan filter dengan transformasi dengan menerapkan sebuah ekspresi pada item yang sudah difilter:

python

# Student scores
scores = [45, 78, 92, 65, 88, 55, 73, 95]
 
# Get passing scores and scale them to 0-10 range
scaled_passing = [score / 10 for score in scores if score >= 70]
print(scaled_passing)  # Output: [7.8, 9.2, 8.8, 7.3, 9.5]
# Pertama memfilter (hanya menyimpan yang >= 70), lalu mentransformasi (membagi dengan 10)

Mengonversi dan memfilter string:

python

# Product names with mixed quality
products = ["apple", "BANANA", "cherry", "DATE", "elderberry"]
 
# Get uppercase versions of products with names longer than 5 characters
long_products_upper = [product.upper() for product in products if len(product) > 5]
print(long_products_upper)  # Output: ['BANANA', 'CHERRY', 'ELDERBERRY']

34.2.3) Menggunakan Conditional Expression (if-else) dalam Comprehension

Terkadang kamu ingin mentransformasi item secara berbeda berdasarkan sebuah kondisi, bukan memfilternya. Untuk ini, kamu menggunakan conditional expression (yang kita pelajari di Bab 10) pada bagian ekspresi dari comprehension:

python

[expression_if_true if condition else expression_if_false for item in iterable]

Ini berbeda dari filter. Di sini, setiap item dimasukkan ke hasil—if-else menentukan ekspresi mana yang diterapkan untuk tiap item. Conditional expression (dari Bab 10) muncul di bagian ekspresi, sebelum klausa for.

Perhatikan perbedaan sintaksnya:

Filtering: [expr for item in seq if condition] - if di akhir, tanpa else
Conditional expression: [expr_if if cond else expr_else for item in seq] - if-else di ekspresi, sebelum for

python

# Classify numbers as even or odd
numbers = range(6)
classifications = ["even" if n % 2 == 0 else "odd" for n in numbers]
print(classifications)  # Output: ['even', 'odd', 'even', 'odd', 'even', 'odd']

Menerapkan transformasi yang berbeda berdasarkan kondisi:

python

# Student scores
scores = [45, 78, 92, 65, 88, 55, 73, 95]
 
# Add bonus points to failing scores, keep passing scores as-is
adjusted_scores = [score + 10 if score < 70 else score for score in scores]
print(adjusted_scores)  # Output: [55, 78, 92, 75, 88, 65, 73, 95]

Pada kedua contoh, perhatikan:

Setiap item dari list asli muncul di hasil
if-else menentukan nilai apa yang menjadi hasil untuk tiap item
Tidak ada item yang difilter keluar

34.2.4) Memahami Perbedaan: Filtering vs Conditional Expression

Sangat penting untuk memahami perbedaan antara dua pola ini:

Filtering (if di akhir) - Beberapa item dikecualikan:

python

# Only include positive numbers
numbers = [-2, 5, -1, 8, 0, 3]
positives = [n for n in numbers if n > 0]
print(positives)  # Output: [5, 8, 3]
print(len(positives))  # Output: 3 (only 3 items)
# Proses: Cek kondisi → Jika True, masukkan item → Jika False, lewati item

Conditional expression (if-else di ekspresi) - Semua item dimasukkan tetapi ditransformasi secara berbeda:

python

# Convert negative numbers to zero, keep positive numbers
numbers = [-2, 5, -1, 8, 0, 3]
non_negatives = [n if n > 0 else 0 for n in numbers]
print(non_negatives)  # Output: [0, 5, 0, 8, 0, 3]
print(len(non_negatives))  # Output: 6 (all 6 items)
# Proses: Cek kondisi → Jika True, pakai expr pertama → Jika False, pakai expr kedua → Selalu masukkan hasil

34.3) Dictionary Comprehension

34.3.1) Sintaks Dasar Dictionary Comprehension

Seperti list comprehension membuat list, dictionary comprehension membuat dictionary. Sintaksnya mirip, tetapi kamu menentukan key dan value:

python

{key_expression: value_expression for item in iterable}

Ini membuat dictionary baru di mana setiap pasangan key-value dihasilkan dari iterable.

Mari mulai dengan contoh sederhana yang membuat dictionary yang memetakan angka ke kuadratnya:

python

# Create a dictionary of numbers and their squares
squares_dict = {n: n ** 2 for n in range(5)}
print(squares_dict)  # Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Membuat dictionary dari dua list:

python

# Student names and their scores
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
 
# Create a dictionary mapping names to scores
student_scores = {names[i]: scores[i] for i in range(len(names))}
print(student_scores)  # Output: {'Alice': 85, 'Bob': 92, 'Charlie': 78}

Cara yang lebih elegan untuk menggabungkan dua urutan adalah menggunakan zip(), yang akan kita pelajari di Bab 37. Untuk saat ini, pendekatan berbasis indeks sudah bekerja dengan baik.

34.3.2) Mentransformasi Dictionary yang Sudah Ada

Dictionary comprehension sangat bagus untuk mentransformasi dictionary yang sudah ada. Kamu bisa memodifikasi key, value, atau keduanya.

Saat melakukan iterasi pada dictionary di dalam comprehension, gunakan .items() untuk mengakses key dan value. Method .items() mengembalikan pasangan key-value yang bisa kamu unpack di klausa for:

python

# Original prices in dollars
prices = {"apple": 1.50, "banana": 0.75, "cherry": 2.00}
 
# Convert to cents (multiply by 100)
prices_in_cents = {fruit: price * 100 for fruit, price in prices.items()}
print(prices_in_cents)  # Output: {'apple': 150.0, 'banana': 75.0, 'cherry': 200.0}

Mentransformasi key:

python

# Product codes in lowercase
codes = {"abc": 100, "def": 200, "ghi": 300}
 
# Convert keys to uppercase
uppercase_codes = {code.upper(): quantity for code, quantity in codes.items()}
print(uppercase_codes)  # Output: {'ABC': 100, 'DEF': 200, 'GHI': 300}

Mentransformasi key dan value sekaligus:

python

# Student names and scores
scores = {"alice": 85, "bob": 92, "charlie": 78}
 
# Capitalize names and scale scores to 0-10 range
formatted_scores = {name.capitalize(): score / 10 for name, score in scores.items()}
print(formatted_scores)  # Output: {'Alice': 8.5, 'Bob': 9.2, 'Charlie': 7.8}

34.3.3) Memfilter Item Dictionary

Seperti list comprehension, dictionary comprehension bisa menyertakan kondisi untuk memfilter item:

python

# Student scores
scores = {"Alice": 85, "Bob": 65, "Charlie": 92, "David": 55, "Eve": 78}
 
# Get only passing scores (>= 70)
passing_scores = {name: score for name, score in scores.items() if score >= 70}
print(passing_scores)  # Output: {'Alice': 85, 'Charlie': 92, 'Eve': 78}

Memfilter berdasarkan karakteristik key:

python

# Product inventory
inventory = {"apple": 50, "banana": 30, "apricot": 20, "cherry": 40}
 
# Get only products starting with 'a'
a_products = {product: quantity for product, quantity in inventory.items() 
              if product.startswith('a')}
print(a_products)  # Output: {'apple': 50, 'apricot': 20}

34.3.4) Membuat Dictionary dari Sequence

Dictionary comprehension berguna untuk membuat dictionary lookup dari sequence:

python

# List of words
words = ["python", "java", "ruby", "javascript"]
 
# Create a dictionary mapping each word to its length
word_lengths = {word: len(word) for word in words}
print(word_lengths)  # Output: {'python': 6, 'java': 4, 'ruby': 4, 'javascript': 10}

34.3.5) Menggunakan Conditional Expression dalam Dictionary Comprehension

Kamu bisa menggunakan conditional expression untuk menghitung value secara berbeda berdasarkan kondisi:

python

# Student scores
scores = {"Alice": 85, "Bob": 65, "Charlie": 92, "David": 55}
 
# Add "Pass" or "Fail" status
scores_with_status = {name: "Pass" if score >= 70 else "Fail" 
                      for name, score in scores.items()}
print(scores_with_status)  # Output: {'Alice': 'Pass', 'Bob': 'Fail', 'Charlie': 'Pass', 'David': 'Fail'}

Menerapkan transformasi yang berbeda:

python

# Product prices
prices = {"apple": 1.50, "banana": 0.75, "cherry": 2.50}
 
# Apply discount to expensive items (> $2.00)
discounted_prices = {product: price * 0.9 if price > 2.00 else price 
                     for product, price in prices.items()}
print(discounted_prices)  # Output: {'apple': 1.5, 'banana': 0.75, 'cherry': 2.25}

34.4) Set Comprehension

34.4.1) Sintaks Dasar Set Comprehension

Set comprehension membuat set menggunakan sintaks yang mirip dengan list comprehension, tetapi dengan kurung kurawal:

python

{expression for item in iterable}

Hasilnya adalah set, yang berarti nilai duplikat otomatis dihapus dan urutannya tidak dijamin.

python

# Create a set of squares
squares_set = {n ** 2 for n in range(6)}
print(squares_set)  # Output: {0, 1, 4, 9, 16, 25}

Perbedaan utama dari list comprehension adalah bahwa set otomatis menghilangkan duplikasi:

python

# List comprehension - keeps duplicates
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
squared_list = [n ** 2 for n in numbers]
print(squared_list)  # Output: [1, 4, 4, 9, 9, 9, 16, 16, 16, 16]
 
# Set comprehension - removes duplicates
squared_set = {n ** 2 for n in numbers}
print(squared_set)  # Output: {16, 1, 4, 9} (order may vary)

Perhatikan bahwa urutan output set bisa berbeda dari yang kamu lihat di sini. Set adalah koleksi yang tidak berurutan, jadi Python bisa menampilkan elemennya dalam urutan apa pun.

34.4.2) Mengambil Nilai Unik

Set comprehension sangat cocok saat kamu perlu mengambil nilai unik dari sebuah koleksi:

python

# Student responses (with duplicates)
responses = ["yes", "no", "yes", "maybe", "no", "yes", "maybe"]
 
# Get unique responses
unique_responses = {response for response in responses}
print(unique_responses)  # Output: {'maybe', 'yes', 'no'}

Mengambil karakter unik dari string:

python

# Text with repeated characters
text = "mississippi"
 
# Get unique characters
unique_chars = {char for char in text}
print(unique_chars)  # Output: {'m', 'i', 's', 'p'}

34.4.3) Mentransformasi dan Memfilter dengan Set Comprehension

Seperti comprehension lainnya, set comprehension bisa menyertakan transformasi dan kondisi:

python

# Student names
names = ["Alice", "bob", "CHARLIE", "david", "EVE"]
 
# Get unique first letters in uppercase
first_letters = {name[0].upper() for name in names}
print(first_letters)  # Output: {'A', 'B', 'C', 'D', 'E'}

Memfilter dengan kondisi:

python

# Numbers with duplicates
numbers = [1, -2, 3, -4, 5, -2, 3, 6, -4]
 
# Get unique positive numbers
positive_numbers = {n for n in numbers if n > 0}
print(positive_numbers)  # Output: {1, 3, 5, 6}

34.4.4) Kapan Set Comprehension Paling Berguna

Set comprehension sangat bernilai terutama ketika:

Kamu butuh nilai unik: Otomatis menghapus duplikasi
Urutan tidak penting: Set tidak berurutan, jadi gunakan saat urutan tidak penting
Kamu akan melakukan operasi set: Hasilnya bisa dipakai dengan union, intersection, dll. (seperti yang kita pelajari di Bab 17)

python

# Student enrollments in two courses
course_a = ["Alice", "Bob", "Charlie", "David"]
course_b = ["Charlie", "David", "Eve", "Frank"]
 
# Get unique students across both courses using set comprehension
all_students = {student for course in [course_a, course_b] for student in course}
print(all_students)  # Output: {'Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'}

34.5) Memilih Comprehension vs Loop

34.5.1) Kapan Comprehension Lebih Baik

Comprehension umumnya lebih disukai saat kamu membuat koleksi baru dengan mentransformasi atau memfilter koleksi yang sudah ada. Mereka lebih ringkas, sering kali lebih mudah dibaca, dan biasanya lebih cepat dibanding loop yang setara.

Comprehension unggul ketika:

Membuat koleksi baru dari koleksi yang sudah ada:

python

# Good use of comprehension
prices = [10.99, 25.50, 8.75, 15.00]
discounted = [price * 0.9 for price in prices]

Transformasinya sederhana:

python

# Clear and concise
names = ["alice", "bob", "charlie"]
uppercase_names = [name.upper() for name in names]

Memfilter berdasarkan kondisi sederhana:

python

# Easy to understand
scores = [85, 92, 78, 65, 88, 55, 73, 95]
passing = [score for score in scores if score >= 70]

34.5.2) Kapan Loop Tradisional Lebih Baik

Namun, ada situasi di mana loop tradisional lebih tepat dan lebih mudah dibaca:

Gunakan loop ketika:

Logikanya kompleks atau melibatkan banyak langkah:

python

# Too complex for a comprehension
results = []
for score in scores:
    if score >= 90:
        grade = "A"
    elif score >= 80:
        grade = "B"
    elif score >= 70:
        grade = "C"
    else:
        grade = "F"
    results.append({"score": score, "grade": grade})

Walaupun kamu bisa menulis ini sebagai comprehension, hasilnya akan jauh lebih sulit dibaca.

Kamu perlu melakukan aksi di luar pembuatan koleksi:

python

# Loop is clearer when performing I/O or side effects
for filename in files:
    with open(filename) as f:
        content = f.read()
        print(f"Processing {filename}")
        # ... more processing

Kamu perlu memodifikasi koleksi yang sudah ada secara in place:

python

# Modifying a list in place - can't use comprehension
numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers)):
    numbers[i] *= 2
print(numbers)  # Output: [2, 4, 6, 8, 10]

Kamu perlu menggunakan break atau continue dengan logika kompleks:

python

# Finding first occurrence with additional processing
found = None
for item in items:
    if item.startswith("target"):
        found = item
        print(f"Found: {found}")
        break

34.5.3) Pertimbangan Keterbacaan

Faktor yang paling penting adalah keterbacaan. Jika sebuah comprehension menjadi terlalu panjang atau kompleks, pecah menjadi loop tradisional:

python

# Hard to read - too much happening in one line
result = [item.upper().strip() for item in items if len(item) > 5 and item.startswith('a')]
 
# Better - use a loop when logic is complex
result = []
for item in items:
    if len(item) > 5 and item.startswith('a'):
        cleaned = item.strip().upper()
        result.append(cleaned)

Aturan praktis yang bagus: Jika comprehension kamu tidak muat dengan nyaman dalam satu baris (atau maksimal dua baris dengan format yang jelas), pertimbangkan untuk memakai loop saja.

34.5.4) Pertimbangan Performa

Comprehension umumnya lebih cepat daripada loop yang setara karena dioptimalkan pada level interpreter. Namun, perbedaan performa ini biasanya tidak signifikan untuk koleksi kecil hingga menengah.

python

# Both produce the same result
# Comprehension is slightly faster
squares_comp = [n ** 2 for n in range(1000)]
 
# Loop is slightly slower but more flexible
squares_loop = []
for n in range(1000):
    squares_loop.append(n ** 2)

Untuk sebagian besar kebutuhan praktis, pilih berdasarkan keterbacaan, bukan performa. Optimalkan untuk kecepatan hanya jika profiling menunjukkan bahwa operasi tertentu menjadi bottleneck.

34.5.5) Menggabungkan Pendekatan

Terkadang solusi terbaik menggabungkan kedua pendekatan:

python

# Use comprehension for simple transformation
student_data = [
    {"name": "Alice", "score": 85},
    {"name": "Bob", "score": 92},
    {"name": "Charlie", "score": 78}
]
 
# Extract scores with comprehension
scores = [student["score"] for student in student_data]
 
# Use loop for complex processing
for student in student_data:
    score = student["score"]
    if score >= 90:
        print(f"{student['name']}: Excellent!")
    elif score >= 80:
        print(f"{student['name']}: Good job!")
    else:
        print(f"{student['name']}: Keep working!")

34.6) Loop Bertingkat dan Banyak Klausa for

34.6.1) Memahami Banyak Klausa for

Comprehension bisa menyertakan banyak klausa for, yang setara dengan loop bertingkat. Sintaksnya adalah:

python

[expression for item1 in iterable1 for item2 in iterable2]

Ini setara dengan:

python

result = []
for item1 in iterable1:
    for item2 in iterable2:
        result.append(expression)

Poin kuncinya adalah klausa for dibaca dari kiri ke kanan, sama seperti loop bertingkat ditulis dari atas ke bawah.

Mari mulai dengan contoh sederhana yang membuat semua kombinasi dari dua list:

python

# Two lists of values
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
 
# Create all combinations
combinations = [(color, size) for color in colors for size in sizes]
print(combinations)
# Output: [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

Ini membuat setiap pasangan yang mungkin antara sebuah warna dan sebuah ukuran.

34.6.2) Membuat Pasangan Koordinat

Kasus penggunaan yang umum adalah menghasilkan pasangan koordinat:

python

# Create a 3x3 grid of coordinates
coordinates = [(x, y) for x in range(3) for y in range(3)]
print(coordinates)
# Output: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

Membuat tabel perkalian:

python

# Generate multiplication pairs
products = [(x, y, x * y) for x in range(1, 4) for y in range(1, 4)]
for x, y, product in products:
    print(f"{x} × {y} = {product}")
# Output:
# 1 × 1 = 1
# 1 × 2 = 2
# 1 × 3 = 3
# 2 × 1 = 2
# 2 × 2 = 4
# 2 × 3 = 6
# 3 × 1 = 3
# 3 × 2 = 6
# 3 × 3 = 9

34.6.3) Meratakan List Bertingkat

Banyak klausa for berguna untuk meratakan struktur bertingkat:

python

# Nested list of numbers
nested_numbers = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
# Flatten into a single list
flat = [num for sublist in nested_numbers for num in sublist]
print(flat)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Ini setara dengan:

python

flat = []
for sublist in nested_numbers:
    for num in sublist:
        flat.append(num)

Meratakan list kata menjadi karakter:

python

# List of words
words = ["cat", "dog", "bird"]
 
# Get all characters from all words
all_chars = [char for word in words for char in word]
print(all_chars)  # Output: ['c', 'a', 't', 'd', 'o', 'g', 'b', 'i', 'r', 'd']

34.6.4) Menambahkan Kondisi pada Comprehension Bertingkat

Kamu bisa menambahkan kondisi untuk memfilter hasil:

python

# Create pairs where the sum is even
pairs = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0]
print(pairs)
# Output: [(0, 0), (0, 2), (0, 4), (1, 1), (1, 3), (2, 0), (2, 2), (2, 4), (3, 1), (3, 3), (4, 0), (4, 2), (4, 4)]

Mencari elemen yang sama antar list:

python

# Two lists of numbers
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
 
# Find pairs where values are equal (common elements)
common = [x for x in list1 for y in list2 if x == y]
print(common)  # Output: [4, 5]

Catatan: Untuk mencari elemen yang sama, menggunakan intersection set lebih efisien: set(list1) & set(list2), yang kita pelajari di Bab 17.

34.6.5) Dictionary Comprehension Bertingkat

Kamu juga bisa menggunakan banyak klausa for dalam dictionary comprehension:

python

# Create a dictionary of coordinate sums
coord_sums = {(x, y): x + y for x in range(3) for y in range(3)}
print(coord_sums)
# Output: {(0, 0): 0, (0, 1): 1, (0, 2): 2, (1, 0): 1, (1, 1): 2, (1, 2): 3, (2, 0): 2, (2, 1): 3, (2, 2): 4}

34.6.6) Kapan Sebaiknya Menghindari Comprehension Bertingkat

Walaupun comprehension bertingkat itu kuat, mereka bisa cepat menjadi sulit dibaca. Pertimbangkan panduan berikut:

Masih dapat diterima - relatif sederhana:

python

# Two levels of nesting, simple expression
matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)  # Output: [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

Mulai kompleks - pertimbangkan loop:

python

# Three levels of nesting - hard to read
result = [[[i + j + k for k in range(2)] for j in range(2)] for i in range(2)]
# Lebih baik sebagai loop bertingkat agar lebih jelas

Aturan praktis: Jika kamu punya lebih dari dua klausa for, atau jika ekspresinya kompleks, gunakan loop bertingkat tradisional saja:

python

# Lebih jelas dengan loop eksplisit
result = []
for i in range(2):
    middle = []
    for j in range(2):
        inner = []
        for k in range(2):
            inner.append(i + j + k)
        middle.append(inner)
    result.append(middle)

Comprehension dengan banyak klausa for adalah alat yang kuat, tetapi ingat: kejelasan lebih penting daripada keringkasan. Jika sebuah nested comprehension menjadi sulit dipahami, lebih baik menggunakan loop eksplisit.