Perulangan dan kondisi di Python: for, while, range, enumerate, break, if/elif dan match/case

Perulangan di Python dipakai untuk mengulang suatu aksi: menelusuri daftar belanja, memproses setiap baris berkas, atau terus meminta pengguna memasukkan angka yang benar. Python punya dua jenis perulangan, for dan while, dan di dalamnya keputusan diambil dengan if/elif/else serta match/case. Berikut setiap alat dibahas dengan contoh yang bisa langsung dijalankan.

Kondisi: if, elif, else

Pernyataan kondisi menjalankan blok kode hanya jika ekspresinya bernilai benar. Blok ditandai dengan indentasi 4 spasi — Python tidak memakai kurung kurawal, dan indentasi yang salah langsung menghasilkan IndentationError.

spent = 4200
limit = 5000

if spent > limit:
    print("Batas terlampaui")
elif spent > limit * 0.8:
    print("Sisa anggaran di bawah 20%")
else:
    print("Semuanya aman")

Cabang elif diperiksa dari atas ke bawah, dan hanya cabang pertama yang cocok yang dijalankan. Karena itu, kondisi yang lebih ketat diletakkan di atas: jika pemeriksaan spent > limit * 0.8 ditaruh pertama, pesan tentang batas yang terlampaui tidak akan pernah muncul.

Apa yang dianggap benar

Di dalam kondisi tidak wajib menulis perbandingan. Nilai yang dianggap salah adalah False, None, nol (0, 0.0) dan koleksi kosong: "", [], {}. Selain itu semuanya benar. Karena itu, pemeriksaan «daftar tidak kosong» cukup ditulis singkat:

expenses = []
if not expenses:
    print("Belum ada pengeluaran")

Kondisi digabung dengan and, or, not, dan rentang nilai nyaman diperiksa dengan rantai perbandingan: if 0 < amount <= 100_000:. Untuk pilihan nilai yang singkat tersedia operator ternary: status = "banyak" if spent > limit else "normal".

Perulangan for di Python: sintaks dan contoh

Perulangan for di Python bukan penghitung seperti di C, melainkan penelusuran elemen. Ia mengambil satu per satu elemen dari objek yang bisa diiterasi: list, string, dict, berkas, atau range. Ini setara dengan foreach di bahasa lain.

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

Sintaksnya: for variabel in koleksi:, lalu blok dengan indentasi. Variabel setelah perulangan menyimpan nilai terakhir — kadang ini berguna, tetapi di program besar sebaiknya jangan mengandalkannya.

Perulangan pada string, list dan dict

String ditelusuri karakter demi karakter, list per elemen. Perulangan pada dict secara default melewati kunci; untuk mendapatkan kunci dan nilai sekaligus, gunakan .items():

by_category = {"makan": 3200, "transportasi": 900, "bioskop": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} Rp")

Untuk nilai saja tersedia .values(). Mengubah ukuran dict saat sedang diulang tidak boleh — Anda akan mendapat RuntimeError: dictionary changed size during iteration. Jika perlu menghapus elemen, ulangi salinannya: for key in list(d):.

Fungsi range: perulangan angka

Jika perlu menelusuri angka, gunakan range(). Ia tidak membuat list di memori, melainkan menghasilkan angka satu per satu, sehingga range(10**9) langsung berjalan.

Aturan utamanya: batas kanan tidak ikut dalam rentang. range(1, 10) berakhir di 9 — ini penyebab umum kesalahan «satu angka meleset». Langkah boleh negatif, tetapi tidak boleh nol.

for i in range(1, 4):
    print(f"Hari {i}")
# Hari 1
# Hari 2
# Hari 3

enumerate: penghitung dalam perulangan

Pemula sering menulis for i in range(len(items)) untuk mengetahui nomor elemen. Cara ini berfungsi, tetapi kurang mudah dibaca. Fungsi enumerate() menghasilkan pasangan «nomor, elemen», dan parameter start menentukan dari angka berapa penghitungan dimulai:

items = ["kopi", "taksi", "makan siang"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 kopi
# 2 taksi
# 3 makan siang

Untuk menelusuri dua list secara bersamaan ada zip(): for name, price in zip(names, prices):. Ia berhenti pada list yang paling pendek; sejak Python 3.10 Anda bisa memberi strict=True, dan panjang yang berbeda akan menimbulkan error.

Perulangan while di Python

Perulangan while mengulang blok selama kondisinya benar. Ia dipilih ketika jumlah pengulangan belum diketahui di awal: menunggu input yang benar, membaca data sampai habis, mengulang permintaan sampai berhasil.

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"Uang cukup untuk {month} bulan")  # 4

Bahaya terbesarnya: lupa mengubah variabel yang ada di kondisi. Maka perulangan tidak akan pernah selesai. Jika program «macet», tekan Ctrl+C — Python akan menghentikan eksekusi dengan KeyboardInterrupt.

Perulangan tak terbatas dan pola do while

Kadang perulangan tak terbatas ditulis dengan sengaja: while True: dengan keluar lewat break. Python juga tidak punya konstruksi do while, dan polanya diganti dengan cara ini: badan perulangan dijalankan minimal sekali, dan pemeriksaan ada di akhir.

while True:
    raw = input("Jumlah: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Masukkan bilangan bulat")

Perulangan for tak terbatas jarang dipakai — hanya saat menelusuri iterator tak terbatas, misalnya itertools.count().

break dan continue: keluar dari perulangan dan melewati iterasi

break langsung menghentikan perulangan, dan eksekusi berlanjut ke kode setelahnya. continue melewati sisa iterasi saat ini dan pindah ke iterasi berikutnya.

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # lewati iterasi ini
    if amount > 50_000:
        print("Jumlah mencurigakan, berhenti")
        break             # keluar dari perulangan
    print(amount)

Akan tercetak 350 dan 1200, lalu pesan — perulangan tidak sampai ke 89. Kedua pernyataan ini hanya berlaku untuk perulangan terdekat tempat mereka berada.

else pada perulangan

Baik for maupun while punya cabang else yang tidak biasa: ia dijalankan jika perulangan selesai dengan sendirinya, tanpa break. Ini berguna untuk pencarian:

for amount in expenses:
    if amount > 50_000:
        print("Ditemukan pengeluaran besar")
        break
else:
    print("Tidak ada pengeluaran besar")

Perulangan bersarang

Perulangan di dalam perulangan menjalankan perulangan dalam secara penuh pada setiap iterasi perulangan luar. Cara ini dipakai untuk menelusuri tabel, matriks, atau pasangan.

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

Ada dua hal yang perlu diingat. Pertama, kompleksitasnya cepat membengkak: dua perulangan bersarang masing-masing 10 000 elemen berarti 100 juta operasi. Kedua, break hanya keluar dari perulangan dalam. Untuk menghentikan keduanya, pindahkan perulangan ke dalam fungsi dan gunakan return — ini lebih bersih daripada memakai bendera.

Pernyataan match/case

Rantai panjang if cmd == ... elif ... sejak Python 3.10 bisa diganti dengan pernyataan match (PEP 634). Ini bukan sekadar switch: ia mencocokkan nilai dengan pola berdasarkan bentuk data dan langsung memecahnya menjadi variabel.

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"Tambah {item}: {amount}"
        case ["list"] | ["ls"]:
            return "Tampilkan pengeluaran"
        case ["quit"]:
            return "Keluar"
        case _:
            return "Perintah tidak dikenal"

print(parse("add Kopi 250"))  # Tambah Kopi: 250
print(parse("add Kopi"))      # Perintah tidak dikenal

Pola list ["add", item, amount] hanya cocok dengan list yang berisi tepat tiga elemen dan elemen pertamanya adalah "add". Karena itu perintah tanpa jumlah jatuh ke cabang _, yang menangkap semua sisanya. Simbol | menggabungkan beberapa varian.

Pola dict, tipe, dan syarat penjaga

Pola dict hanya memeriksa kunci yang disebutkan, kunci lain diabaikan. Penulisan int(a) memeriksa tipe sekaligus menangkap nilainya, dan if setelah pola menambahkan syarat tambahan (guard):

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Pengeluaran besar", a)
    case {"type": "expense", "amount": int(a)}:
        print("Pengeluaran", a)

Jebakan utama match

Nama polos di case adalah penangkapan, bukan perbandingan dengan variabel. case limit: akan cocok dengan nilai apa pun dan menyimpannya ke limit. Untuk membandingkan dengan konstanta, gunakan nama dengan titik, misalnya case Color.RED:, atau literal.

Sintaks match hampir tidak berubah sejak 3.10. Di Python 3.15 ada perbaikan kecil pada ketidakseimetrian: dulu pada pola literal hanya tanda minus sebelum angka yang diizinkan, sekarang case +1: juga bisa ditulis. Di versi lama kode seperti ini menghasilkan error sintaks.

Kesalahan umum dalam perulangan

• Mengubah list saat sedang diulang. Menghapus elemen di dalam for melewati elemen tetangganya. Lebih baik buat list baru: clean = [x for x in items if x > 0].
• Batas range. range(1, n) tidak mencakup n.
• Lupa mengubah kondisi di while — perulangan tak berujung.
• Menyambung string dengan += di dalam perulangan untuk data besar lebih lambat daripada "".join(parts).
• Penugasan alih-alih perbandingan: if x = 5 adalah kesalahan sintaks, perbandingan ditulis dengan ==.

Latihan perulangan

1. Hitung jumlah dan rata-rata untuk list pengeluaran, dengan melewati nilai negatif.
2. Cetak tabel perkalian 1–9 dengan perulangan bersarang.
3. Minta pengguna memasukkan angka sampai ia mengetik baris kosong, lalu cetak nilai maksimumnya.
4. Cari angka pertama yang lebih besar dari 1000 dalam list dan beri tahu jika tidak ada (dengan for ... else).
5. Uraikan perintah add, del, list dengan match.

Ringkasan

Perulangan Python bermuara pada dua konstruksi: for menelusuri elemen koleksi atau range(), while bekerja selama kondisinya terpenuhi. break dan continue mengatur jalannya perulangan, enumerate() dan zip() menghilangkan penghitung manual, dan if/elif/else serta match/case mengurus keputusan. Semua alat ini dipraktikkan dengan contoh pencatat pengeluaran dalam pelajaran tentang perulangan di kursus Python.