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

URL: https://skillaria.top/id/guides/python/perulangan-python

Perulangan di Python mengulang aksi: for menelusuri elemen koleksi atau range(), sedangkan while berjalan selama kondisinya bernilai benar. Perulangan dihentikan dengan break, iterasi dilewati dengan continue, dan nomor elemen didapat dari enumerate(). Keputusan diambil dengan if/elif/else, sedangkan pemisahan data berdasarkan bentuknya memakai match/case (sejak Python 3.10).

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.

| Pemanggilan | Angka |
| --- | --- |

| `range(5)` | 0, 1, 2, 3, 4 |

| `range(2, 6)` | 2, 3, 4, 5 |

| `range(0, 10, 3)` | 0, 3, 6, 9 |

| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |

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  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.

## FAQ

**Apa beda for dan while di Python?**

for menelusuri urutan yang sudah ada dan otomatis tahu kapan berhenti, sedangkan while mengulang selama kondisinya benar. Jika jumlah pengulangan diketahui atau ada koleksi, pakai for; jika menunggu suatu kejadian, pakai while.

**Bagaimana menelusuri perulangan dengan urutan terbalik?**

Gunakan reversed(items) untuk koleksi, atau range(n - 1, -1, -1) untuk angka. Fungsi reversed tidak menyalin list, melainkan menelusurinya dari belakang.

**Apakah ada switch di Python?**

Tidak ada switch tersendiri. Perannya diambil alih oleh rantai if/elif dan pernyataan match/case yang hadir di Python 3.10. match bisa lebih banyak: membongkar list dan dict berdasarkan bentuknya serta menangkap nilai.

**Mana yang lebih cepat, perulangan atau comprehension?**

List comprehension seperti [x * 2 for x in items] biasanya sedikit lebih cepat daripada perulangan dengan append yang setara, dan lebih ringkas. Untuk logika rumit dengan banyak kondisi, perulangan biasa lebih mudah dibaca.

**Bagaimana keluar sekaligus dari dua perulangan bersarang?**

break hanya menghentikan perulangan dalam. Cara paling sederhana adalah memindahkan perulangan ke dalam fungsi dan keluar dengan return.


---
Source: Skillaria.Top (https://skillaria.top)