Python List Comprehension: Panduan Lengkap

# === Loop Tradisional ===
kuadrat_tradisional = []
for x in range(1, 6):
    kuadrat_tradisional.append(x ** 2)
print(kuadrat_tradisional)  # [1, 4, 9, 16, 25]

# === List Comprehension (1 baris!) ===
kuadrat = [x ** 2 for x in range(1, 6)]
print(kuadrat)  # [1, 4, 9, 16, 25]

# Keduanya menghasilkan output yang sama persis!

# Contoh sederhana lainnya
angka = [1, 2, 3, 4, 5]
ganda = [x * 2 for x in angka]
print(ganda)  # [2, 4, 6, 8, 10]

# Mengubah tipe data
teks = ["1", "2", "3", "4", "5"]
angka = [int(x) for x in teks]
print(angka)  # [1, 2, 3, 4, 5]

# Manipulasi string
kata = ["hello", "world", "python"]
huruf_besar = [k.upper() for k in kata]
print(huruf_besar)  # ['HELLO', 'WORLD', 'PYTHON']

# Sintaks lengkap:
# [ekspresi for item in iterable if kondisi]
#
# ┌──────────────────────────────────────────┐
# │  [ekspresi] [for item in iterable] [if kondisi]
# │      │            │                  │
# │  Apa yang     Dari mana           Syarat
# │  dihasilkan   datanya             filter
# └──────────────────────────────────────────┘

# Ekspresi bisa berupa operasi apapun
data = [1, 2, 3, 4, 5]

# Operasi aritmatika
hasil = [x * 10 + 5 for x in data]
print(hasil)  # [15, 25, 35, 45, 55]

# Pemanggilan method
kalimat = ["  halo  ", "  dunia  ", "  python  "]
bersih = [s.strip() for s in kalimat]
print(bersih)  # ['halo', 'dunia', 'python']

# Conditional expression (ternary)
data = [1, -2, 3, -4, 5]
positif = [x if x > 0 else 0 for x in data]
print(positif)  # [1, 0, 3, 0, 5]

# Fungsi dalam ekspresi
def kuadrat(x):
    return x ** 2

hasil = [kuadrat(x) for x in range(1, 6)]
print(hasil)  # [1, 4, 9, 16, 25]

# Iterable bisa berupa list, tuple, string, range, dll
dari_string = [c for c in "Python"]
print(dari_string)  # ['P', 'y', 't', 'h', 'o', 'n']

dari_tuple = [x * 3 for x in (10, 20, 30)]
print(dari_tuple)  # [30, 60, 90]

# List comprehension dengan beberapa for loop
# Menghasilkan semua kombinasi pasangan

warna = ["merah", "hijau", "biru"]
ukuran = ["S", "M", "L"]

kombinasi = [(w, u) for w in warna for u in ukuran]
print(kombinasi)
# [('merah', 'S'), ('merah', 'M'), ('merah', 'L'),
#  ('hijau', 'S'), ('hijau', 'M'), ('hijau', 'L'),
#  ('biru', 'S'), ('biru', 'M'), ('biru', 'L')]

# Flatten nested list
nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [item for sublist in nested for item in sublist]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Membuat pasangan angka
pasangan = [(x, y) for x in range(3) for y in range(3) if x != y]
print(pasangan)
# [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

# Cartesian product
huruf = ['a', 'b']
angka = [1, 2, 3]
cartesian = [(h, a) for h in huruf for a in angka]
print(cartesian)
# [('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3)]

# Filter genap
angka = range(1, 21)
genap = [x for x in angka if x % 2 == 0]
print(genap)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# Filter ganjil
ganjil = [x for x in angka if x % 2 != 0]
print(ganjil)  # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

# Filter string berdasarkan panjang
kata = ["aku", "kamu", "mereka", "kami", "dia", "python"]
panjang = [k for k in kata if len(k) > 3]
print(panjang)  # ['kamu', 'mereka', 'kami', 'python']

# Filter None dan nilai kosong
data = [1, None, 3, "", 5, 0, 7, False, 9]
valid = [x for x in data if x]
print(valid)  # [1, 3, 5, 7, 9]

# Filter dengan isinstance
campur = [1, "dua", 3, "empat", 5.0, True]
hanya_int = [x for x in campur if isinstance(x, int) and not isinstance(x, bool)]
print(hanya_int)  # [1, 3]

# Filter dan transformasi sekaligus
nilai = [45, 78, 92, 33, 67, 88, 55, 71]
lulus_dan_format = [f"Nilai {n}: Lulus" for n in nilai if n >= 60]
print(lulus_dan_format)
# ['Nilai 78: Lulus', 'Nilai 92: Lulus', 'Nilai 67: Lulus',
#  'Nilai 88: Lulus', 'Nilai 71: Lulus']

# Ternary expression dalam list comprehension
# Posisi if-else ada DI SEBELUM 'for', bukan di akhir!
# [nilai_true if kondisi else nilai_false for item in iterable]

angka = range(1, 11)
label = ["genap" if x % 2 == 0 else "ganjil" for x in angka]
print(label)
# ['ganjil', 'genap', 'ganjil', 'genap', 'ganjil', 'genap',
#  'ganjil', 'genap', 'ganjil', 'genap']

# Grading siswa
nilai = [85, 42, 73, 91, 56, 68, 95]
huruf = [
    "A" if n >= 85 else
    "B" if n >= 70 else
    "C" if n >= 60 else
    "D"
    for n in nilai
]
print(huruf)  # ['A', 'D', 'B', 'A', 'D', 'C', 'A']

# Klasifikasi angka
angka = [-5, 3, 0, -1, 7, 0, 2]
klasifikasi = [
    "positif" if x > 0 else
    "negatif" if x < 0 else
    "nol"
    for x in angka
]
print(klasifikasi)
# ['negatif', 'positif', 'nol', 'negatif', 'positif', 'nol', 'positif']

# Filter + transformasi dengan ternary
data = [1, -2, 3, -4, 5, -6]
hasil = [x * 2 if x > 0 else x * -1 for x in data]
print(hasil)  # [2, 2, 6, 4, 10, 6]

# Membuat matriks 3x3
matriks = [[0 for _ in range(3)] for _ in range(3)]
print(matriks)
# [[0, 0, 0],
#  [0, 0, 0],
#  [0, 0, 0]]

# Matriks dengan nilai berbeda
matriks = [[i * 3 + j + 1 for j in range(3)] for i in range(3)]
print(matriks)
# [[1, 2, 3],
#  [4, 5, 6],
#  [7, 8, 9]]

# Matriks identitas
n = 4
identitas = [[1 if i == j else 0 for j in range(n)] for i in range(n)]
for baris in identitas:
    print(baris)
# [1, 0, 0, 0]
# [0, 1, 0, 0]
# [0, 0, 1, 0]
# [0, 0, 0, 1]

# ⚠️ HATI-HATI: Jangan lakukan ini!
# matriks_salah = [[0] * 3] * 3  ← Semua baris referensi yang sama!
# matriks_salah[0][0] = 1
# print(matriks_salah)  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] ← Semua berubah!

# Cara yang benar dengan comprehension:
matriks_benar = [[0] * 3 for _ in range(3)]
matriks_benar[0][0] = 1
print(matriks_benar)  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]] ← Hanya baris pertama

# Flatten 2D list menjadi 1D
matriks = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
flat = [elemen for baris in matriks for elemen in baris]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Mengambil elemen diagonal
diagonal = [matriks[i][i] for i in range(len(matriks))]
print(diagonal)  # [1, 5, 9]

# Transpose matriks (baris jadi kolom, kolom jadi baris)
transpose = [[matriks[j][i] for j in range(3)] for i in range(3)]
for baris in transpose:
    print(baris)
# [1, 4, 7]
# [2, 5, 8]
# [3, 6, 9]

# Nested list comprehension dengan filter
data_nested = [[1, 2, 0], [0, 3, 4], [5, 0, 6]]
tanpa_nol = [[x for x in baris if x != 0] for baris in data_nested]
print(tanpa_nol)
# [[1, 2], [3, 4], [5, 6]]

# Menggabungkan kata-kata dari nested list
kalimat_nested = [["halo", "dunia"], ["selamat", "pagi"], ["python", "mantap"]]
gabungan = [" ".join(baris) for baris in kalimat_nested]
print(gabungan)
# ['halo dunia', 'selamat pagi', 'python mantap']

# Membuat dictionary dari nested data
siswa_data = [
    ["Budi", 85],
    ["Ani", 92],
    ["Dimas", 78],
    ["Sari", 95]
]
nilai_dict = {nama: nilai for nama, nilai in siswa_data}
print(nilai_dict)  # {'Budi': 85, 'Ani': 92, 'Dimas': 78, 'Sari': 95}

# Grup data berdasarkan kategori
buah = ["apel", "alpukat", "anggur", "bluberi", "belimbing", "ceri"]
grup = {
    huruf: [b for b in buah if b.startswith(huruf)]
    for huruf in sorted(set(b[0] for b in buah))
}
print(grup)
# {'a': ['apel', 'alpukat', 'anggur'],
#  'b': ['bluberi', 'belimbing'],
#  'c': ['ceri']}

# Membuat dict dari range
kuadrat = {x: x**2 for x in range(1, 6)}
print(kuadrat)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Dari dua list menjadi dictionary
nama = ["Budi", "Ani", "Dimas"]
umur = [25, 22, 30]
profil = {n: u for n, u in zip(nama, umur)}
print(profil)  # {'Budi': 25, 'Ani': 22, 'Dimas': 30}

# Invert dictionary (tukar key dan value)
ori = {"a": 1, "b": 2, "c": 3}
terbalik = {v: k for k, v in ori.items()}
print(terbalik)  # {1: 'a', 2: 'b', 3: 'c'}

# Dict comprehension dengan filter
harga = {"apel": 5000, "mangga": 8000, "durian": 50000, "jeruk": 3000}
mahal = {k: v for k, v in harga.items() if v > 10000}
print(mahal)  # {'durian': 50000}

# Hitung frekuensi kemunculan karakter
teks = "hello world"
frekuensi = {c: teks.count(c) for c in set(teks) if c != ' '}
print(frekuensi)  # {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}

# Mapping konversi satuan
suhu_celsius = {"Jakarta": 32, "Bandung": 24, "Surabaya": 34, "Malang": 22}
suhu_fahrenheit = {k: (v * 9/5) + 32 for k, v in suhu_celsius.items()}
print(suhu_fahrenheit)
# {'Jakarta': 89.6, 'Bandung': 75.2, 'Surabaya': 93.2, 'Malang': 71.6}

# Membuat nested dictionary
ukuran = ["S", "M", "L", "XL"]
stok = [10, 25, 15, 5]
harga_diskon = [50000, 60000, 70000, 80000]

produk = {
    u: {"stok": s, "harga": h}
    for u, s, h in zip(ukuran, stok, harga_diskon)
}
print(produk)
# {'S': {'stok': 10, 'harga': 50000},
#  'M': {'stok': 25, 'harga': 60000}, ...}

# Mapping index ke elemen
buah = ["apel", "mangga", "jeruk", "pisang"]
index_mapping = {i: b for i, b in enumerate(buah)}
print(index_mapping)  # {0: 'apel', 1: 'mangga', 2: 'jeruk', 3: 'pisang'}

# Conditional key-value
angka = range(1, 11)
label_map = {
    x: "genap" if x % 2 == 0 else "ganjil"
    for x in angka
}
print(label_map)
# {1: 'ganjil', 2: 'genap', 3: 'ganjil', 4: 'genap', ...}

# Membuat default dictionary
kunci = ["nama", "umur", "email", "telepon"]
profil = {k: None for k in kunci}
print(profil)
# {'nama': None, 'umur': None, 'email': None, 'telepon': None}

# Merge dan filter dictionary
data1 = {"a": 1, "b": 2, "c": 3}
data2 = {"b": 20, "c": 30, "d": 40}
merged = {k: data1.get(k, 0) + data2.get(k, 0) for k in set(data1) | set(data2)}
print(merged)  # {'a': 1, 'b': 22, 'c': 33, 'd': 40}

# Set comprehension dasar
kuadrat = {x**2 for x in range(-5, 6)}
print(kuadrat)  # {0, 1, 4, 9, 16, 25} — unik!

# Perbedaan dengan list comprehension
angka = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
list_hasil = [x for x in angka]
set_hasil = {x for x in angka}
print(list_hasil)  # [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
print(set_hasil)   # {1, 2, 3, 4}

# Mengambil huruf unik dari string
teks = "programming is fun"
huruf_unik = {c for c in teks if c.isalpha()}
print(huruf_unik)  # {'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n', 's', 'f', 'u'}

# Set comprehension dengan filter
angka = range(1, 51)
kelipatan_3_atau_5 = {x for x in angka if x % 3 == 0 or x % 5 == 0}
print(kelipatan_3_atau_5)
# {3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24, 25, 27, 30, 33, 35, 36, 39, 40, 42, 45, 48, 50}

# Operasi himpunan dengan set comprehension
kelipatan_3 = {x for x in range(1, 31) if x % 3 == 0}
kelipatan_5 = {x for x in range(1, 31) if x % 5 == 0}

print(f"Kelipatan 3: {kelipatan_3}")
print(f"Kelipatan 5: {kelipatan_5}")
print(f"Irisan: {kelipatan_3 & kelipatan_5}")   # {15, 30}
print(f"Gabungan: {kelipatan_3 | kelipatan_5}")
print(f"Hanya 3: {kelipatan_3 - kelipatan_5}")

# Membuat set dari kata-kata unik
kalimat = "aku suka python dan python suka aku"
kata_unik = {kata for kata in kalimat.split()}
print(kata_unik)  # {'aku', 'suka', 'python', 'dan'}
print(f"Jumlah kata unik: {len(kata_unik)}")  # 4

# List comprehension — semua elemen langsung di memori
list_comp = [x ** 2 for x in range(1000000)]
print(type(list_comp))  # <class 'list'>
print(len(list_comp))   # 1000000

# Generator expression — elemen dihasilkan satu per satu
gen_exp = (x ** 2 for x in range(1000000))
print(type(gen_exp))    # <class 'generator'>

# Generator TIDAK memiliki panjang (len)
# print(len(gen_exp))  ← Error! TypeError

# Menggunakan generator dengan sum, min, max, any, all
total = sum(x ** 2 for x in range(10))
print(total)  # 285

terbesar = max(x ** 2 for x in range(-5, 6))
print(terbesar)  # 25

# Cek apakah semua elemen memenuhi kondisi
angka = [2, 4, 6, 8, 10]
semua_genap = all(x % 2 == 0 for x in angka)
print(semua_genap)  # True

# Cek apakah ada elemen yang memenuhi kondisi
ada_positif = any(x > 0 for x in [-1, -2, 3, -4])
print(ada_positif)  # True

# Generator dalam for loop
for nilai in (x ** 2 for x in range(5)):
    print(nilai, end=" ")
# 0 1 4 9 16

# Join dengan generator
kata = ["Python", "sangat", "menyenangkan"]
gabungan = " ".join(k.upper() for k in kata)
print(gabungan)  # PYTHON SANGAT MENYENANGKAN

# Generator dengan pipeline
import sys
list_data = [x ** 2 for x in range(1000)]
gen_data = (x ** 2 for x in range(1000))

print(f"List: {sys.getsizeof(list_data)} bytes")  # ~8856 bytes
print(f"Generator: {sys.getsizeof(gen_data)} bytes")  # ~200 bytes
# Generator menggunakan jauh lebih sedikit memori!

# Walrus operator (:=) memungkinkan assignment dalam ekspresi
# Python 3.8+

# Tanpa walrus operator — fungsi dipanggil dua kali
import math
data = [1, 25, 49, 100, 121, 144]
# Kita ingin ambil akar kuadrat yang hasilnya genap

# Cara lama
hasil_lama = []
for x in data:
    akar = math.isqrt(x)
    if akar % 2 == 0:
        hasil_lama.append((x, akar))
print(hasil_lama)  # [(100, 10), (144, 12)]

# Dengan walrus operator — lebih efisien
hasil = [
    (x, akar)
    for x in data
    if (akar := math.isqrt(x)) % 2 == 0
]
print(hasil)  # [(100, 10), (144, 12)]

# Contoh lain: filter berdasarkan nilai yang sudah dihitung
angka = [2, 3, 4, 5, 6, 7, 8, 9, 10]
kuadrat_besar = [
    hasil
    for x in angka
    if (hasil := x ** 2) > 20
]
print(kuadrat_besar)  # [25, 36, 49, 64, 81, 100]

# Menggunakan fungsi dalam comprehension
def bersihkan_nama(nama):
    return nama.strip().title()

nama_kotor = ["  budi ", " ANI  ", "  dimas ", " SARI  "]
nama_bersih = [bersihkan_nama(n) for n in nama_kotor]
print(nama_bersih)  # ['Budi', 'Ani', 'Dimas', 'Sari']

# Comprehension sebagai argumen fungsi
def statistik(data):
    return {
        "total": sum(data),
        "rata_rata": sum(data) / len(data),
        "terkecil": min(data),
        "terbesar": max(data),
        "jumlah": len(data)
    }

nilai = [85, 92, 78, 95, 88, 76, 90]
info = statistik(nilai)
print(info)
# {'total': 604, 'rata_rata': 86.28..., 'terkecil': 76, 'terbesar': 95, 'jumlah': 7}

# Pipeline: chaining comprehension
data_mentah = ["  BUDI  ", "  ani ", " DIMAS  "]
data_bersih = [
    nama.title()
    for nama in [s.strip() for s in data_mentah]
    if len(nama) > 0
]
print(data_bersih)  # ['Budi', 'Ani', 'Dimas']

# Nested comprehension untuk matrix multiplication
A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]

hasil = [
    [sum(A[i][k] * B[k][j] for k in range(2)) for j in range(2)]
    for i in range(2)
]
for baris in hasil:
    print(baris)
# [19, 22]
# [43, 50]

import timeit

# Benchmark 1: Membuat list kuadrat
n = 10000

# Loop tradisional
def dengan_loop():
    hasil = []
    for i in range(n):
        hasil.append(i ** 2)
    return hasil

# List comprehension
def dengan_comprehension():
    return [i ** 2 for i in range(n)]

# map + lambda
def dengan_map():
    return list(map(lambda x: x ** 2, range(n)))

# Generator + list()
def dengan_generator():
    return list(i ** 2 for i in range(n))

# Jalankan benchmark
loop_time = timeit.timeit(dengan_loop, number=100)
comp_time = timeit.timeit(dengan_comprehension, number=100)
map_time = timeit.timeit(dengan_map, number=100)
gen_time = timeit.timeit(dengan_generator, number=100)

print(f"Loop:          {loop_time:.4f}s")
print(f"Comprehension: {comp_time:.4f}s")
print(f"map + lambda:  {map_time:.4f}s")
print(f"Generator:     {gen_time:.4f}s")

# Hasil rata-rata:
# Loop:          0.8234s
# Comprehension: 0.5612s  ← Tercepat!
# map + lambda:  0.7891s
# Generator:     0.6023s

# Kesimpulan: Comprehension ~30% lebih cepat dari loop!

import sys

# List comprehension — semua di memori
list_data = [x ** 2 for x in range(10000)]
print(f"List size: {sys.getsizeof(list_data)} bytes")
# List size: ~87,624 bytes

# Generator expression — lazy, hemat memori
gen_data = (x ** 2 for x in range(10000))
print(f"Generator size: {sys.getsizeof(gen_data)} bytes")
# Generator size: ~200 bytes

# Perbandingan
print(f"List {sys.getsizeof(list_data) / sys.getsizeof(gen_data):.0f}x lebih besar dari Generator")
# List ~438x lebih besar dari Generator!

# Kapan pakai yang mana:
#
# ┌─────────────────────────────────────────────────────┐
# │  List Comprehension          Generator Expression    │
# │  ──────────────────          ──────────────────────  │
# │  ✅ Butuh akses random       ✅ Iterasi sekali       │
# │  ✅ Butuh len()              ✅ Data sangat besar    │
# │  ✅ Butuh operasi list       ✅ Pipeline processing  │
# │  ✅ Data kecil-sedang        ✅ Hemat memori         │
# └─────────────────────────────────────────────────────┘

# ✅ DO: Gunakan untuk operasi sederhana
kuadrat = [x ** 2 for x in range(10)]
bersih = [s.strip().lower() for s in data]

# ✅ DO: Pecah comprehension kompleks menjadi beberapa langkah
# Terlalu kompleks:
# hasil = [f(x) for x in [g(y) for y in data if h(y)] if p(x)]

# Lebih baik:
tahap1 = [g(y) for y in data if h(y)]
hasil = [f(x) for x in tahap1 if p(x)]

# ❌ DON'T: Gunakan comprehension untuk efek samping
# Jangan lakukan ini:
# [print(x) for x in range(10)]  ← Gunakan loop biasa!
# Lebih baik:
for x in range(10):
    print(x)

# ❌ DON'T: Buat comprehension terlalu panjang (max 80 karakter)
# Pecah ke beberapa baris jika perlu:
hasil = [
    transform(item)
    for item in data_sangat_panjang
    if kondisi_kompleks(item) and syarat_lain(item)
]

# ✅ DO: Pakai generator untuk data besar
total = sum(x ** 2 for x in range(1000000))

# ✅ DO: Gunakan walrus operator untuk efisiensi
data = [1, 25, 49, 100, 121]
akar_genap = [
    (x, akar)
    for x in data
    if (akar := int(x ** 0.5)) % 2 == 0
]

# ✅ DO: Gunakan comprehension untuk membuat dictionary dan set
nilai_unik = {x % 10 for x in range(100)}
mapping = {k: v for k, v in pairs if v > 0}

# Ringkasan:
# ┌─────────────────────────────────────────────────┐
# │  Comprehension        │  Loop Biasa             │
# │  ─────────────────────│──────────────────────── │
# │  Transformasi sederhana│ Logika kompleks         │
# │  Filtering data        │ Efek samping (print,    │
# │  Membuat dict/set      │   write, dll)           │
# │  Operasi satu baris    │ Error handling          │
# │                        │ Break/continue          │
# └─────────────────────────────────────────────────┘

# Data penjualan
penjualan = [
    {"produk": "Laptop", "jumlah": 5, "harga": 15000000},
    {"produk": "Mouse", "jumlah": 50, "harga": 150000},
    {"produk": "Keyboard", "jumlah": 30, "harga": 350000},
    {"produk": "Monitor", "jumlah": 10, "harga": 3500000},
    {"produk": "Webcam", "jumlah": 20, "harga": 500000},
    {"produk": "Headset", "jumlah": 15, "harga": 750000},
]

# 1. Hitung total penjualan per produk
total_per_produk = {
    p["produk"]: p["jumlah"] * p["harga"]
    for p in penjualan
}
print(total_per_produk)
# {'Laptop': 75000000, 'Mouse': 7500000, ...}

# 2. Produk dengan pendapatan > 10 juta
produk_laris = {
    k: v for k, v in total_per_produk.items() if v > 10_000_000
}
print(produk_laris)

# 3. Daftar produk yang harganya di bawah 1 juta
murah = [p["produk"] for p in penjualan if p["harga"] < 1_000_000]
print(murah)  # ['Mouse', 'Keyboard', 'Webcam']

# 4. Total keseluruhan pendapatan
total_pendapatan = sum(
    p["jumlah"] * p["harga"] for p in penjualan
)
print(f"Total pendapatan: Rp {total_pendapatan:,.0f}")

# 5. Rata-rata harga per unit
rata_harga = sum(p["harga"] for p in penjualan) / len(penjualan)
print(f"Rata-rata harga: Rp {rata_harga:,.0f}")

# 6. Produk termahal dan termurah
termahal = max(penjualan, key=lambda p: p["harga"])
termurah = min(penjualan, key=lambda p: p["harga"])
print(f"Termahal: {termahal['produk']} (Rp {termahal['harga']:,})")
print(f"Termurah: {termurah['produk']} (Rp {termurah['harga']:,})")