Latihan – latihan Python Sederhana

### **Materi 1: Perulangan `for`**

Perulangan `for` digunakan untuk mengulang elemen-elemen dalam sebuah urutan (seperti list, tuple, string, atau
`range`).

---

#### **Soal 1: Mencetak Bilangan Genap**

Buatlah program yang mencetak semua bilangan genap dari 1 hingga 20 menggunakan perulangan `for` dan fungsi
`range()`.

#### Pembahasan Soal 1:

**Jawaban/Kode Python:**

```python

# Soal: Mencetak bilangan genap dari 1 hingga 20

print("Bilangan genap dari 1 hingga 20 adalah:")

for angka in range(2, 21, 2): # Mulai dari 2, hingga 20 (exclusive), dengan langkah 2

print(angka)

```

**Penjelasan Kode:**

* `range(2, 21, 2)` adalah kuncinya. Fungsi `range` dapat menerima tiga argumen: `range(start, stop, step)`.

* `start`: Angka awal perulangan, yaitu 2 (bilangan genap pertama).

* `stop`: Angka akhir perulangan (tidak termasuk). Kita ingin hingga 20, jadi kita beri nilai 21.

* `step`: Langkah atau increment setiap iterasi. Karena kita hanya ingin bilangan genap, langkahnya adalah 2.

* Pada setiap iterasi, variabel `angka` akan bernilai 2, 4, 6, ..., hingga 20.

* `print(angka)` akan mencetak nilai `angka` saat ini ke layar.

---

#### **Soal 2: Menghitung Jumlah Huruf Vokal**

Buatlah program yang menghitung jumlah huruf vokal ('a', 'i', 'u', 'e', 'o') dalam sebuah kalimat yang ditentukan.

#### Pembahasan Soal 2:

**Jawaban/Kode Python:**

```python

# Soal: Menghitung jumlah huruf vokal dalam sebuah kalimat

kalimat = "Belajar Python itu sangat menyenangkan"

vokal = "aiueo"

jumlah_vokal = 0

# Ubah kalimat menjadi huruf kecil agar perbandingan konsisten

kalimat_lower = [Link]()

for huruf in kalimat_lower:

if huruf in vokal:

jumlah_vokal += 1 # Sama dengan: jumlah_vokal = jumlah_vokal + 1

print(f"Kalimat: '{kalimat}'")

print(f"Jumlah huruf vokal: {jumlah_vokal}")

```

**Penjelasan Kode:**

* `kalimat` adalah string yang akan kita periksa.

* `vokal` adalah string yang berisi semua huruf vokal untuk acuan perbandingan.

* `jumlah_vokal` adalah variabel *accumulator* (penampung) yang diinisialisasi dengan nilai 0.

* `[Link]()` mengubah seluruh kalimat menjadi huruf kecil agar 'A' dan 'a' dianggap sama.

* `for huruf in kalimat_lower:`: Perulangan `for` akan mengiterasi setiap karakter dalam string `kalimat_lower`. Pada
setiap iterasi, variabel `huruf` akan menampung satu karakter.

* `if huruf in vokal:`: Kondisi ini memeriksa apakah karakter saat ini (`huruf`) ada di dalam string `vokal`.

* `jumlah_vokal += 1`: Jika karakter tersebut adalah vokal, maka nilai `jumlah_vokal` akan bertambah 1.

* Terakhir, program mencetak hasilnya.

---

#### **Soal 3: Mencetak Tabel Perkalian**

Buatlah program yang mencetak tabel perkalian 5x5 (dari 1x1 hingga 5x5).

#### Pembahasan Soal 3:

**Jawaban/Kode Python:**
```python

# Soal: Mencetak tabel perkalian 5x5

print("Tabel Perkalian 5x5")

for i in range(1, 6): # Perulangan untuk baris (1 hingga 5)

for j in range(1, 6): # Perulangan untuk kolom (1 hingga 5)

hasil = i * j

# print(f"{hasil}\t", end="") # Alternatif dengan tab

print(f"{hasil:3}", end="") # Mengatur lebar 3 karakter agar rapi

print() # Mencetak baris baru setelah perulangan inner selesai

```

**Penjelasan Kode:**

* Ini adalah contoh **perulangan bersarang (nested loop)**.

* `for i in range(1, 6):` adalah *outer loop* (perulangan luar) yang mengontrol baris. Variabel `i` akan bernilai 1, 2, 3, 4,
5.

* `for j in range(1, 6):` adalah *inner loop* (perulangan dalam) yang mengontrol kolom. Variabel `j` akan bernilai 1, 2, 3,
4, 5.

* **Alurnya:**

1. Saat `i` = 1, perulangan `j` akan berjalan penuh (dari 1 hingga 5), mencetak `1*1`, `1*2`, `1*3`, `1*4`, `1*5`.

2. Setelah perulangan `j` selesai, `print()` dijalankan untuk membuat baris baru.

3. Kemudian `i` menjadi 2, dan perulangan `j` kembali berjalan penuh, mencetak `2*1`, `2*2`, ..., `2*5`.

4. Proses ini berlanjut hingga `i` mencapai 5.

* `print(f"{hasil:3}", end="")`:

* `f"{hasil:3}"` adalah *formatted string literal* yang mencetak `hasil` dalam ruang selebar 3 karakter. Ini membantu
menyelaraskan kolom agar terlihat rapi.

* `end=""` memberitahu `print` untuk tidak menambahkan baris baru di akhir output, sehingga hasil perkalian untuk
satu baris tetap berada di baris yang sama.

---

#### **Soal 4: Membalik sebuah String**

Buatlah program yang membalik sebuah string tanpa menggunakan fungsi slicing `[::-1]`.

#### Pembahasan Soal 4:

**Jawaban/Kode Python:**

```python

# Soal: Membalik sebuah string tanpa slicing

kata_asli = "Python"

kata_terbalik = ""

for huruf in kata_asli:

kata_terbalik = huruf + kata_terbalik

print(f"Kata asli: {kata_asli}")

print(f"Kata terbalik: {kata_terbalik}")

```

**Penjelasan Kode:**

* `kata_asli` adalah string yang akan kita balik.

* `kata_terbalik` adalah string kosong yang akan kita gunakan untuk menampung hasil.

* `for huruf in kata_asli:`: Perulangan ini mengambil setiap huruf dari `kata_asli` dari depan ke belakang ('P', 'y', 't', 'h',
'o', 'n').

* Logika pembalikan terjadi pada baris `kata_terbalik = huruf + kata_terbalik`.

* **Iterasi 1:** `huruf` = 'P'. `kata_terbalik` = '' + 'P' -> 'P'

* **Iterasi 2:** `huruf` = 'y'. `kata_terbalik` = 'y' + 'P' -> 'yP'

* **Iterasi 3:** `huruf` = 't'. `kata_terbalik` = 't' + 'yP' -> 'tyP'

* ...dan seterusnya hingga string terbalik sempurna ('nohtyP').

---

#### **Soal 5: Menemukan Nilai Maksimum dalam List**

Buatlah program yang menemukan nilai terbesar dalam sebuah list angka tanpa menggunakan fungsi `max()`.

#### Pembahasan Soal 5:

**Jawaban/Kode Python:**

```python

# Soal: Menemukan nilai maksimum dalam list tanpa fungsi max()

angka_list = [23, 45, 12, 67, 89, 34, 56, 9]

# Asumsi list tidak kosong

nilai_terbesar = angka_list[0] # Inisialisasi dengan elemen pertama

for angka in angka_list:

if angka > nilai_terbesar:

nilai_terbesar = angka

print(f"List angka: {angka_list}")

print(f"Nilai terbesar adalah: {nilai_terbesar}")

```

**Penjelasan Kode:**

* `angka_list` adalah list yang akan kita periksa.

* `nilai_terbesar = angka_list[0]`: Kita menginisialisasi variabel `nilai_terbesar` dengan nilai elemen pertama dari list. Ini
adalah asumsi awal kita.

* `for angka in angka_list:`: Perulangan ini akan memeriksa setiap `angka` dalam list.

* `if angka > nilai_terbesar:`: Pada setiap iterasi, kita bandingkan `angka` saat ini dengan `nilai_terbesar` yang kita
simpan.

* `nilai_terbesar = angka`: Jika `angka` saat ini lebih besar, maka kita update `nilai_terbesar` dengan `angka` tersebut.

* Setelah perulangan selesai, variabel `nilai_terbesar` akan menampung nilai tertinggi yang ditemukan di seluruh list.

---

---

### **Materi 2: Perulangan `while`**

Perulangan `while` akan terus berjalan selama kondisinya bernilai `True`.

---

#### **Soal 1: Menjumlahkan Bilangan Hingga Batas**

Buatlah program yang meminta pengguna memasukkan angka positif. Program terus meminta input hingga pengguna
memasukkan angka negatif. Setelah itu, tampilkan jumlah dari semua angka positif yang dimasukkan.

#### Pembahasan Soal 1:

**Jawaban/Kode Python:**

```python

# Soal: Menjumlahkan bilangan positif hingga input negatif

total = 0

angka = 0 # Inisialisasi agar masuk ke loop pertama kali

print("Masukkan angka positif untuk dijumlahkan.")

print("Ketik angka negatif untuk berhenti.")

while angka >= 0:

try:

angka_str = input("Masukkan angka: ")

angka = int(angka_str)

if angka > 0:

total += angka

elif angka < 0:

print("Perhitungan dihentikan.")

else: # angka == 0

print("Angka nol tidak dijumlahkan.")

except ValueError:

print("Input tidak valid. Masukkan angka bulat.")

print(f"Total semua angka positif adalah: {total}")

```

**Penjelasan Kode:**

* `total` adalah variabel penampung jumlah, diinisialisasi dengan 0.

* `angka` diinisialisasi dengan 0 agar kondisi `while angka >= 0` bernilai `True` saat pertama kali dijalankan.

* `while angka >= 0:`: Loop akan berjalan selama nilai `angka` lebih besar atau sama dengan 0.

* Di dalam loop, program meminta input dari pengguna. `try-except` digunakan untuk menangani kesalahan jika
pengguna memasukkan bukan angka.

* `angka = int(angka_str)`: Input dari pengguna (string) diubah menjadi integer.

* `if angka > 0:`: Jika angka positif, tambahkan ke `total`.

* `elif angka < 0:`: Jika angka negatif, cetak pesan berhenti. Loop akan berhenti dengan sendirinya di iterasi berikutnya
karena kondisi `while` sudah tidak terpenuhi.

* Loop akan berhenti ketika pengguna memasukkan angka negatif, dan program akan mencetak `total` akhir.

---

#### **Soal 2: Menebak Angka**

Buatlah program "tebak angka". Komputer menyimpan sebuah angka rahasia (misalnya 1-100). Pengguna harus
menebak angka tersebut. Program memberi petunjuk "terlalu besar" atau "terlalu kecil" hingga pengguna menebak
dengan benar.

#### Pembahasan Soal 2:

**Jawaban/Kode Python:**

```python

# Soal: Permainan tebak angka

import random

angka_rahasia = [Link](1, 100)

tebakan = 0

percobaan = 0

print("=== Permainan Tebak Angka (1-100) ===")

while tebakan != angka_rahasia:

try:

tebakan_str = input("Masukkan tebakan Anda: ")

tebakan = int(tebakan_str)

percobaan += 1

if tebakan < angka_rahasia:

print("Tebakan Anda terlalu kecil!")

elif tebakan > angka_rahasia:

print("Tebakan Anda terlalu besar!")

else:

print(f"Selamat! Anda menebak dengan benar.")

print(f"Angka rahasianya adalah {angka_rahasia}.")

print(f"Anda berhasil menebak dalam {percobaan} percobaan.")

except ValueError:

print("Input tidak valid. Masukkan angka.")

```

**Penjelasan Kode:**

* `import random`: Mengimpor modul `random` untuk menghasilkan angka acak.

* `angka_rahasia = [Link](1, 100)`: Menghasilkan sebuah integer acak antara 1 dan 100.
* `while tebakan != angka_rahasia:`: Loop akan terus berjalan selama tebakan pengguna belum sama dengan angka
rahasia.

* Di dalam loop, program meminta input pengguna dan mengubahnya menjadi integer.

* `percobaan += 1`: Menghitung jumlah percobaan.

* `if tebakan < angka_rahasia:`: Jika tebakan lebih kecil, beri petunjuk.

* `elif tebakan > angka_rahasia:`: Jika tebakan lebih besar, beri petunjuk lain.

* `else:`: Jika tidak lebih kecil dan tidak lebih besar, berarti tebakan benar. Program mencetak pesan kemenangan dan
jumlah percobaan. Loop akan berhenti karena kondisi `while` sudah tidak terpenuhi (`tebakan == angka_rahasia`).

---

#### **Soal 3: Validasi Password**

Buatlah program yang meminta pengguna memasukkan password. Password harus memenuhi kriteria:

1. Minimal 8 karakter.

2. Harus mengandung angka.

Program terus meminta input hingga password valid.

#### Pembahasan Soal 3:

**Jawaban/Kode Python:**

```python

# Soal: Validasi password

password = ""

is_valid = False

print("Buat password baru:")

print("1. Minimal 8 karakter")

print("2. Harus mengandung angka")

while not is_valid:

password = input("Masukkan password: ")

has_digit = False

# Cek panjang password

if len(password) >= 8:

# Cek apakah ada angka

for char in password:

if [Link]():
 has_digit = True

break # Keluar dari loop for jika sudah ketemu angka

if has_digit:

is_valid = True

print("Password berhasil dibuat!")

else:

print("Password harus mengandung setidaknya satu angka. Coba lagi.")

else:

print("Password minimal 8 karakter. Coba lagi.")

print(f"Password Anda yang valid: {password}")

```

**Penjelasan Kode:**

* `is_valid` adalah *flag* (penanda) yang diinisialisasi dengan `False`. Loop `while` akan berjalan selama `is_valid`
adalah `False`.

* Di dalam `while`, program meminta input password.

* `has_digit` adalah flag lain untuk mengecek keberadaan angka, di-set `False` di awal setiap percobaan.

* `if len(password) >= 8:`: Pertama, cek panjang password.

* Jika panjangnya cukup, jalankan perulangan `for` untuk memeriksa setiap karakter dalam password.

* `if [Link]()`: Fungsi `isdigit()` mengembalikan `True` jika karakter adalah angka.

* Jika angka ditemukan, `has_digit` di-set menjadi `True` dan `break` menghentikan perulangan `for` karena tidak perlu
memeriksa lagi.

* Setelah loop `for`, `if has_digit:` diperiksa. Jika `True`, maka `is_valid` di-set `True` yang akan menghentikan loop
`while` di iterasi berikutnya. Jika tidak, pesan error ditampilkan.

* Jika panjang password kurang dari 8, pesan error lain ditampilkan.

---

#### **Soal 4: Konversi Desimal ke Biner**

Buatlah program yang mengkonversi sebuah bilangan desimal (basis 10) menjadi bilangan biner (basis 2) tanpa
menggunakan fungsi `bin()`.

#### Pembahasan Soal 4:

**Jawaban/Kode Python:**

```python

# Soal: Konversi desimal ke biner

desimal = int(input("Masukkan bilangan desimal: "))

if desimal == 0:

biner = "0"

else:

biner = ""

n = desimal

while n > 0:

sisa = n % 2

biner = str(sisa) + biner

n = n // 2 # Pembagian integer

print(f"Bilangan desimal {desimal} dalam biner adalah: {biner}")

```

**Penjelasan Kode:**

* Program meminta input bilangan desimal dari pengguna.

* `if desimal == 0:`: Kasus khusus untuk angka 0, karena logika while tidak akan berjalan.

* `n = desimal`: Kita membuat salinan nilai desimal ke variabel `n` agar nilai asli tidak berubah.

* `while n > 0:`: Loop akan berjalan selama nilai `n` (yang akan terus dibagi 2) masih lebih besar dari 0.

* `sisa = n % 2`: Ini adalah inti konversi. Kita mengambil sisa hasil bagi `n` dengan 2 (hasilnya akan selalu 0 atau 1). Ini
adalah digit biner.

* `biner = str(sisa) + biner`: Sisa hasil bagi (yang sudah diubah ke string) ditambahkan di **depan** string `biner`. Ini
penting karena digit biner dihasilkan dari belakang ke depan.

* `n = n // 2`: Nilai `n` diperbarui dengan hasil pembagian bulat (integer division) dari `n` dengan 2.

* Contoh untuk `desimal = 13`:

* n=13: sisa=1, biner="1", n=6

* n=6: sisa=0, biner="01", n=3

* n=3: sisa=1, biner="101", n=1

* n=1: sisa=1, biner="1101", n=0

* Loop berhenti. Hasilnya "1101".

---

#### **Soal 5: Mesin ATM Sederhana**

Simulasikan mesin ATM sederhana. Pengguna memasukkan PIN (misal "123456"). Jika PIN salah 3 kali, program berhenti
dan mencetak "Akun diblokir". Jika benar, tampilkan menu (1. Cek Saldo, 2. Keluar). Program kembali ke menu utama
hingga pengguna memilih keluar.

#### Pembahasan Soal 5:

**Jawaban/Kode Python:**

```python

# Soal: Simulasi mesin ATM sederhana

PIN_BENAR = "123456"

saldo = 1000000

kesempatan = 3

pin_benar = False

# Tahap 1: Verifikasi PIN

while kesempatan > 0 and not pin_benar:

pin_input = input("Masukkan PIN Anda: ")

if pin_input == PIN_BENAR:

pin_benar = True

print("PIN benar. Selamat datang!")

else:

kesempatan -= 1

if kesempatan > 0:

print(f"PIN salah! Sisa kesempatan: {kesempatan}")

else:

print("PIN salah 3 kali. Akun Anda diblokir.")

# Tahap 2: Menu ATM (jika PIN benar)

if pin_benar:

while True: # Loop tak terbatas yang akan kita hentikan secara manual

print("\n--- Menu ATM ---")

print("1. Cek Saldo")

print("2. Keluar")

pilihan = input("Pilih menu: ")

if pilihan == "1":

print(f"Saldo Anda adalah: Rp {saldo:,}")

 elif pilihan == "2":

print("Terima kasih. Sampai jumpa.")

break # Keluar dari loop menu

else:

print("Pilihan tidak valid. Coba lagi.")

```

**Penjelasan Kode:**

* **Tahap 1: Verifikasi PIN**

* `while kesempatan > 0 and not pin_benar:`: Loop berjalan selama masih ada kesempatan dan PIN belum benar.

* `pin_input == PIN_BENAR`: Memeriksa kecocokan PIN.

* Jika benar, `pin_benar` di-set `True` untuk menghentikan loop ini dan melanjutkan ke tahap 2.

* Jika salah, `kesempatan` dikurangi 1. Jika `kesempatan` habis, pesan blokir ditampilkan.

* **Tahap 2: Menu ATM**

* `if pin_benar:`: Bagian ini hanya dijalankan jika verifikasi PIN berhasil.

* `while True:`: Ini adalah idiom umum untuk membuat loop yang akan berjalan terus-menerus hingga ada perintah
`break`.

* Di dalam loop, menu ditampilkan, dan program meminta input `pilihan`.

* `if pilihan == "1"`: Menampilkan saldo. `:,` pada f-string adalah format untuk menambahkan pemisah ribuan.

* `elif pilihan == "2"`: Mencetak pesan penutup dan `break` digunakan untuk keluar dari loop `while True`.

* `else`: Menangani input pilihan yang tidak valid.

---

---

### **Materi 3: Kondisional `if`**

Pernyataan `if` digunakan untuk menjalankan kode berdasarkan kondisi tertentu.

---

#### **Soal 1: Menentukan Kelulusan**

Buatlah program yang menentukan apakah seorang siswa lulus atau tidak. Siswa dinyatakan lulus jika nilainya 70 atau ke
atas.

#### Pembahasan Soal 1:

**Jawaban/Kode Python:**

```python
# Soal: Menentukan kelulusan siswa

nilai = int(input("Masukkan nilai siswa: "))

if nilai >= 70:

print("Selamat, Anda LULUS!")

else:

print("Maaf, Anda TIDAK LULUS.")

```

**Penjelasan Kode:**

* Program meminta input nilai dari pengguna dan mengubahnya menjadi integer.

* `if nilai >= 70:`: Ini adalah kondisi yang diperiksa. Jika nilai yang dimasukkan 70 atau lebih besar, maka blok kode di
bawah `if` akan dijalankan.

* `print("Selamat, Anda LULUS!")`: Baris ini hanya dijalankan jika kondisi `if` benar.

* `else:`: Jika kondisi `if` salah (nilai kurang dari 70), maka blok kode di bawah `else` yang akan dijalankan.

* `print("Maaf, Anda TIDAK LULUS.")`: Baris ini hanya dijalankan jika kondisi `if` salah.

---

#### **Soal 2: Kategori Umur**

Buatlah program yang mengkategorikan umur seseorang berdasarkan input:

* 0-12 tahun: Anak-anak

* 13-17 tahun: Remaja

* 18-59 tahun: Dewasa

* 60 tahun ke atas: Lansia

#### Pembahasan Soal 2:

**Jawaban/Kode Python:**

```python

# Soal: Kategori umur

umur = int(input("Masukkan umur Anda: "))

if umur >= 0 and umur <= 12:

print("Kategori: Anak-anak")

elif umur >= 13 and umur <= 17:

 print("Kategori: Remaja")

elif umur >= 18 and umur <= 59:

print("Kategori: Dewasa")

elif umur >= 60:

print("Kategori: Lansia")

else:

print("Input umur tidak valid.")

```

**Penjelasan Kode:**

* Program meminta input umur dan mengubahnya menjadi integer.

* Kita menggunakan serangkaian `if-elif-else` untuk memeriksa beberapa kondisi secara berurutan.

* Python akan memeriksa kondisi `if` pertama. Jika benar, blok tersebut dijalankan dan seluruh struktur `if-elif-else`
diakhiri.

* Jika salah, Python akan melanjutkan ke `elif` berikutnya dan memeriksanya. Proses ini berlanjut hingga sebuah
kondisi benar atau semua kondisi salah.

* `and` digunakan untuk menggabungkan dua kondisi, misalnya `umur >= 0 and umur <= 12`.

* `else` di akhir akan menangkap semua kemungkinan yang tidak tercover oleh kondisi di atasnya (dalam kasus ini,
umur negatif).

---

#### **Soal 3: Diskon Berdasarkan Member dan Total Belanja**

Sebuah toko memberikan diskon:

* Member: Diskon 10% jika total belanja di atas Rp 200.000.

* Non-Member: Diskon 5% jika total belanja di atas Rp 300.000.

Buatlah program yang menghitung harga akhir berdasarkan status member dan total belanja.

#### Pembahasan Soal 3:

**Jawaban/Kode Python:**

```python

# Soal: Menghitung diskon

total_belanja = int(input("Masukkan total belanja: "))

status_member = input("Apakah Anda member? (ya/tidak): ").lower()

diskon = 0

harga_akhir = total_belanja
if status_member == "ya":

if total_belanja > 200000:

diskon = 0.10

else: # Jika bukan member

if total_belanja > 300000:

diskon = 0.05

harga_akhir = total_belanja - (total_belanja * diskon)

print(f"Total belanja: Rp {total_belanja:,}")

print(f"Diskon yang didapat: {diskon*100:.0f}%")

print(f"Harga yang harus dibayar: Rp {harga_akhir:,.0f}")

```

**Penjelasan Kode:**

* Program meminta total belanja dan status member. `.lower()` pada input status memastikan jawaban "Ya", "YA", atau
"ya" akan dianggap sama.

* `diskon = 0`: Variabel `diskon` diinisialisasi dengan 0.

* `if status_member == "ya":`: Ini adalah **kondisional bersarang (nested if)**. Pertama, kita periksa status member.

* Jika member, kita masuk ke blok `if` ini dan memeriksa kondisi kedua: `if total_belanja > 200000:`. Jika benar,
`diskon` diubah menjadi 0.10.

* `else:`: `else` ini terkait dengan `if status_member == "ya"`. Jika pengguna bukan member, blok ini dijalankan.

* Di dalamnya, kita periksa kondisi untuk non-member: `if total_belanja > 300000:`. Jika benar, `diskon` diubah
menjadi 0.05.

* Setelah struktur `if-else` selesai, kita hitung `harga_akhir` dengan rumus yang sudah ada.

* `f"{harga_akhir:,.0f}"` digunakan untuk memformat output menjadi mata uang yang mudah dibaca (dengan koma dan
tanpa desimal).

---

#### **Soal 4: Menentukan Tahun Kabisat**

Buatlah program untuk menentukan apakah sebuah tahun adalah tahun kabisat. Aturan tahun kabisat:

* Tahun habis dibagi 4 adalah tahun kabisat, **KECUALI**

* Jika tahun tersebut habis dibagi 100, maka **BUKAN** tahun kabisat, **KECUALI**

* Jika tahun tersebut juga habis dibagi 400, maka **ADALAH** tahun kabisat.

#### Pembahasan Soal 4:

**Jawaban/Kode Python:**

```python

# Soal: Menentukan tahun kabisat

tahun = int(input("Masukkan tahun: "))

if (tahun % 4 == 0 and tahun % 100 != 0) or (tahun % 400 == 0):

print(f"Tahun {tahun} adalah tahun kabisat.")

else:

print(f"Tahun {tahun} bukan tahun kabisat.")

```

**Penjelasan Kode:**

* Program meminta input tahun dari pengguna.

* Logika tahun kabisat diterjemahkan langsung ke dalam kode Python menggunakan operator logika `and`, `or`, dan
`not`.

* `tahun % 4 == 0`: Cek apakah tahun habis dibagi 4.

* `tahun % 100 != 0`: Cek apakah tahun TIDAK habis dibagi 100.

* `tahun % 400 == 0`: Cek apakah tahun habis dibagi 400.

* Kondisi digabung dengan `and` dan `or` sesuai aturan:

* `(tahun % 4 == 0 and tahun % 100 != 0)`: Ini adalah aturan utama. Harus habis dibagi 4 DAN tidak habis dibagi 100.

* `or (tahun % 400 == 0)`: Aturan ini menjadi pengecualian. Jika aturan pertama tidak terpenuhi, tetapi tahun habis
dibagi 400, maka tetap dianggap kabisat.

* Jika salah satu dari dua kondisi besar (yang di dalam kurung) terpenuhi, maka tahun tersebut adalah kabisat.

---

#### **Soal 5: Kalkulator Sederhana**

Buatlah program kalkulator sederhana yang meminta dua angka dan sebuah operator (+, -, \*, /). Program akan
menghitung dan menampilkan hasilnya. Jika operator tidak dikenal, tampilkan pesan error. Tangani juga kasus
pembagian dengan nol.

#### Pembahasan Soal 5:

**Jawaban/Kode Python:**

```python

# Soal: Kalkulator sederhana

angka1 = float(input("Masukkan angka pertama: "))

operator = input("Masukkan operator (+, -, *, /): ")

angka2 = float(input("Masukkan angka kedua: "))

hasil = 0

error = False

if operator == '+':

hasil = angka1 + angka2

elif operator == '-':

hasil = angka1 - angka2

elif operator == '*':

hasil = angka1 * angka2

elif operator == '/':

if angka2 == 0:

print("Error: Tidak bisa membagi dengan nol!")

error = True

else:

hasil = angka1 / angka2

else:

print("Error: Operator tidak dikenal!")

error = True

if not error:

print(f"Hasil: {angka1} {operator} {angka2} = {hasil}")

```

**Penjelasan Kode:**

* Program meminta dua angka (menggunakan `float()` agar bisa menghandle desimal) dan sebuah operator.

* `error = False`: Sebuah *flag* untuk melacak apakah terjadi kesalahan.

* Serangkaian `if-elif-else` digunakan untuk memilih operasi berdasarkan input `operator`.

* `elif operator == '/':`: Kasus khusus untuk pembagian.

* `if angka2 == 0:`: Sebelum melakukan pembagian, kita periksa apakah pembagi (angka2) adalah nol.

* Jika ya, cetak pesan error dan set `error = True`.

* Jika tidak, lakukan pembagian.

* `else:`: Blok ini akan dijalankan jika input `operator` tidak cocok dengan +, -, \*, atau /. Cetak pesan error dan set
`error = True`.

* `if not error:`: Di akhir program, kita periksa flag `error`. Jika tidak ada error (`False`), maka baris hasil akan dicetak.
Jika ada error, baris ini tidak akan dijalankan.
---

---

### **Materi 4: Tipe Data `list`**

`list` adalah kumpulan item yang terurut dan dapat diubah (mutable). Item-itemnya dipisahkan dengan koma dan diapit
oleh kurung siku `[]`.

---

#### **Soal 1: Akses dan Modifikasi Elemen List**

Diberikan sebuah list `buah = ["apel", "jeruk", "mangga", "pisang"]`. Buatlah program yang:

1. Mencetak buah kedua.

2. Mengubah buah keempat menjadi "anggur".

3. Menambahkan "semangka" di akhir list.

4. Mencetak list yang sudah diubah.

#### Pembahasan Soal 1:

**Jawaban/Kode Python:**

```python

# Soal: Akses dan modifikasi elemen list

buah = ["apel", "jeruk", "mangga", "pisang"]

print(f"List awal: {buah}")

# 1. Mencetak buah kedua (indeks 1)

print(f"Buah kedua adalah: {buah[1]}")

# 2. Mengubah buah keempat (indeks 3) menjadi "anggur"

buah[3] = "anggur"

# 3. Menambahkan "semangka" di akhir list

[Link]("semangka")

# 4. Mencetak list yang sudah diubah

print(f"List setelah dimodifikasi: {buah}")

```

**Penjelasan Kode:**

* `buah[1]`: Elemen list diakses menggunakan indeksnya. Indeks dimulai dari 0, jadi buah kedua ("jeruk") ada di indeks
1.

* `buah[3] = "anggur"`: List bersifat *mutable* (dapat diubah). Kita bisa mengubah nilai elemen di indeks tertentu
dengan cara ini.

* `[Link]("semangka")`: Method `.append()` digunakan untuk menambahkan satu elemen baru ke akhir list.

* Setelah semua operasi, `buah` akan berisi `['apel', 'jeruk', 'mangga', 'anggur', 'semangka']`.

---

#### **Soal 2: Mencari Elemen dalam List**

Buatlah program yang meminta pengguna memasukkan nama buah. Cek apakah buah tersebut ada di dalam list `buah =
["apel", "jeruk", "mangga", "pisang", "anggur"]`. Jika ada, beri tahu indeksnya. Jika tidak ada, beri tahu bahwa buah tidak
ditemukan.

#### Pembahasan Soal 2:

**Jawaban/Kode Python:**

```python

# Soal: Mencari elemen dalam list

buah = ["apel", "jeruk", "mangga", "pisang", "anggur"]

buah_dicari = input("Masukkan nama buah yang dicari: ").lower()

if buah_dicari in buah:

indeks = [Link](buah_dicari)

print(f"Buah '{buah_dicari}' ditemukan di indeks {indeks}.")

else:

print(f"Buah '{buah_dicari}' tidak ditemukan dalam list.")

```

**Penjelasan Kode:**

* Program meminta input nama buah dari pengguna. `.lower()` digunakan agar pencarian tidak case-sensitive (misal
"Apel" akan dianggap sama dengan "apel").

* `if buah_dicari in buah:`: Operator `in` digunakan untuk memeriksa keanggotaan. Ini akan mengembalikan `True` jika
`buah_dicari` ada di dalam list `buah`, dan `False` jika tidak.

* Jika buah ditemukan (`True`), maka blok `if` dijalankan.

 * `indeks = [Link](buah_dicari)`: Method `.index()` akan mencari elemen dalam list dan mengembalikan indeks
pertama di mana elemen tersebut ditemukan.

* Program kemudian mencetak pesan sukses beserta indeksnya.

* Jika buah tidak ditemukan (`False`), blok `else` dijalankan, yang mencetak pesan bahwa buah tidak ada.

---

#### **Soal 3: Menghitung Rata-rata Nilai**

Diberikan sebuah list `nilai = [85, 92, 78, 90, 88]`. Buatlah program yang menghitung dan menampilkan rata-rata dari
semua nilai dalam list tersebut tanpa menggunakan fungsi `sum()` dan `len()`.

#### Pembahasan Soal 3:

**Jawaban/Kode Python:**

```python

# Soal: Menghitung rata-rata nilai dalam list

nilai = [85, 92, 78, 90, 88]

total = 0

jumlah_elemen = 0

for n in nilai:

total += n

jumlah_elemen += 1

if jumlah_elemen > 0:

rata_rata = total / jumlah_elemen

print(f"List nilai: {nilai}")

print(f"Total nilai: {total}")

print(f"Jumlah elemen: {jumlah_elemen}")

print(f"Rata-rata nilai: {rata_rata:.2f}")

else:

print("List kosong, tidak bisa menghitung rata-rata.")

```

**Penjelasan Kode:**

* `total` dan `jumlah_elemen` diinisialisasi dengan 0. Keduanya akan menjadi *accumulator*.

* `for n in nilai:`: Perulangan `for` mengiterasi setiap elemen dalam list `nilai`.

* Di dalam loop:
 * `total += n`: Setiap nilai `n` ditambahkan ke variabel `total`.

* `jumlah_elemen += 1`: Setiap kali loop berjalan, counter `jumlah_elemen` bertambah 1.

* Setelah loop selesai, `total` berisi jumlah semua nilai dan `jumlah_elemen` berisi banyaknya nilai.

* `if jumlah_elemen > 0:`: Sebagai langkah pengaman, kita periksa apakah list tidak kosong untuk menghindari
pembagian dengan nol.

* `rata_rata = total / jumlah_elemen`: Rata-rata dihitung dengan membagi total nilai dengan jumlah elemen.

* `f"{rata_rata:.2f}"` memformat output rata-rata agar hanya memiliki dua angka di belakang koma.

---

#### **Soal 4: Membuat List Baru dari List Lain (Filtering)**

Diberikan list `angka = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`. Buatlah program yang membuat list baru yang hanya berisi bilangan
genap dari list `angka` tersebut.

#### Pembahasan Soal 4:

**Jawaban/Kode Python:**

```python

# Soal: Membuat list baru berisi bilangan genap

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

angka_genap = [] # List kosong untuk menampung hasil

for n in angka:

if n % 2 == 0:

angka_genap.append(n)

print(f"List asli: {angka}")

print(f"List bilangan genap: {angka_genap}")

# Alternatif dengan List Comprehension (lebih singkat)

# angka_genap_lc = [n for n in angka if n % 2 == 0]

# print(f"List bilangan genap (dengan list comprehension): {angka_genap_lc}")

```

**Penjelasan Kode:**

* `angka_genap = []`: Kita membuat sebuah list kosong yang akan diisi dengan bilangan genap.

* `for n in angka:`: Kita iterasi setiap bilangan `n` dalam list `angka`.

* `if n % 2 == 0:`: Kita periksa apakah bilangan `n` adalah genap (jika sisa hasil bagi dengan 2 adalah 0).
* `angka_genap.append(n)`: Jika `n` adalah bilangan genap, kita tambahkan `n` ke dalam list `angka_genap`
menggunakan method `.append()`.

* Setelah loop selesai, `angka_genap` akan berisi `[2, 4, 6, 8, 10]`.

* **List Comprehension:** Saya sertakan alternatif yang lebih "Pythonic" dan ringkas. `[n for n in angka if n % 2 == 0]`
melakukan hal yang sama: buat list baru dengan `n` untuk setiap `n` di `angka` jika `n` genap.

---

#### **Soal 5: Menghapus Elemen Duplikat**

Diberikan list dengan elemen duplikat, misal `data = [1, 2, 2, 3, 4, 4, 5, 1]`. Buatlah program yang menghasilkan list baru
tanpa ada elemen duplikat.

#### Pembahasan Soal 5:

**Jawaban/Kode Python:**

```python

# Soal: Menghapus elemen duplikat dari list

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

data_unik = [] # List untuk menampung elemen unik

for item in data:

if item not in data_unik:

data_unik.append(item)

print(f"List awal (dengan duplikat): {data}")

print(f"List baru (tanpa duplikat): {data_unik}")

# Alternatif yang lebih efisien dengan set

# data_unik_set = list(set(data))

# print(f"List baru (dengan set): {data_unik_set}")

```

**Penjelasan Kode:**

* `data_unik = []: ` List kosong untuk menampung hasil.

* `for item in data:`: Iterasi setiap `item` di list `data` yang memiliki duplikat.

* `if item not in data_unik:`: Ini adalah kuncinya. Sebelum menambahkan `item` ke list baru, kita periksa terlebih dahulu
apakah `item` tersebut **sudah ada** di list `data_unik`.

* `data_unik.append(item)`: Jika `item` belum ada (`not in`), maka kita tambahkan ke `data_unik`.
* Jika `item` sudah ada, tidak ada yang terjadi, dan loop melanjjutkan ke `item` berikutnya.

* Setelah loop selesai, `data_unik` akan berisi `[1, 2, 3, 4, 5]`.

* **Alternatif dengan `set`:** Cara yang lebih efisien dan singkat adalah dengan mengubah list menjadi `set`. `set`
adalah tipe data yang secara otomatis tidak mengizinkan duplikat. Setelah diubah ke `set`, kita ubah kembali menjadi
`list`. `list(set(data))` akan langsung memberikan list dengan elemen unik. Urutan mungkin tidak terjamin, tapi ini adalah
solusi yang sangat umum.

---

---

### **Materi 5: Tipe Data `tuple`**

`tuple` mirip dengan `list`, namun bersifat tidak dapat diubah (immutable) setelah dibuat. Item-itemnya dipisahkan
koma dan diapit oleh kurung biasa `()`.

---

#### **Soal 1: Membuat dan Mengakses Tuple**

Buatlah sebuah tuple `koordinat` yang berisi tiga nilai: x=10, y=20, z=30. Kemudian, akses dan cetak nilai y dan z.

#### Pembahasan Soal 1:

**Jawaban/Kode Python:**

```python

# Soal: Membuat dan mengakses tuple

# Membuat tuple

koordinat = (10, 20, 30)

print(f"Tuple koordinat: {koordinat}")

# Mengakses elemen

# Indeks 0: x, Indeks 1: y, Indeks 2: z

nilai_y = koordinat[1]

nilai_z = koordinat[2]

print(f"Nilai y (indeks 1): {nilai_y}")

print(f"Nilai z (indeks 2): {nilai_z}")

```
**Penjelasan Kode:**

* `koordinat = (10, 20, 30)`: Tuple dibuat dengan mendefinisikan elemen-elemen di dalam kurung `()`.

* Sama seperti list, elemen tuple diakses menggunakan indeks yang dimulai dari 0.

* `koordinat[1]` akan mengakses elemen kedua, yaitu 20.

* `koordinat[2]` akan mengakses elemen ketiga, yaitu 30.

* Program kemudian mencetak nilai-nilai yang telah diakses.

---

#### **Soal 2: Pembongkaran Tuple (Tuple Unpacking)**

Diberikan sebuah tuple `siswa = ("Budi", 20, "Teknik Informatika")`. Gunakan *tuple unpacking* untuk menyimpan
setiap nilai ke dalam variabel terpisah (`nama`, `umur`, `jurusan`) dan cetak variabel-variabel tersebut.

#### Pembahasan Soal 2:

**Jawaban/Kode Python:**

```python

# Soal: Tuple unpacking

siswa = ("Budi", 20, "Teknik Informatika")

# Tuple unpacking

nama, umur, jurusan = siswa

print("Data Siswa:")

print(f"Nama: {nama}")

print(f"Umur: {umur}")

print(f"Jurusan: {jurusan}")

```

**Penjelasan Kode:**

* `siswa` adalah sebuah tuple dengan tiga elemen.

* `nama, umur, jurusan = siswa`: Ini adalah *tuple unpacking*. Python secara otomatis "membongkar" tuple `siswa`
dan menugaskan setiap elemennya ke variabel di sebelah kiri sesuai urutannya.

* `"Budi"` ditugaskan ke `nama`.

* `20` ditugaskan ke `umur`.

* `"Teknik Informatika"` ditugaskan ke `jurusan`.

* Cara ini membuat kode lebih mudah dibaca daripada harus mengakses satu per satu dengan indeks (`siswa[0]`,
`siswa[1]`, dll.).

---

#### **Soal 3: Imutabilitas Tuple**

Coba ubah elemen pertama dari tuple `hari = ("Senin", "Selasa", "Rabu")` menjadi "Ahad". Amati dan jelaskan error yang
terjadi.

#### Pembahasan Soal 3:

**Jawaban/Kode Python:**

```python

# Soal: Demonstrasi imutabilitas tuple

hari = ("Senin", "Selasa", "Rabu")

print(f"Tuple awal: {hari}")

try:

hari[0] = "Ahad"

print(f"Tuple setelah diubah: {hari}")

except TypeError as e:

print(f"\nTerjadi error: {e}")

print("Penjelasan: Tuple bersifat 'immutable', artinya elemennya tidak dapat diubah setelah dibuat.")

```

**Penjelasan Kode:**

* `hari` adalah sebuah tuple.

* `hari[0] = "Ahad"`: Kita mencoba mengubah elemen pertama (indeks 0) dari tuple.

* Karena tuple bersifat **immutable** (tidak dapat diubah), operasi ini tidak diperbolehkan dan akan memunculkan
`TypeError`.

* Saya membungkus kode dalam blok `try-except` untuk "menangkap" error tersebut agar program tidak berhenti
secara tiba-tiba.

* `except TypeError as e:`: Jika terjadi `TypeError`, blok ini akan dijalankan.

* Program akan mencetak pesan error yang dihasilkan Python dan memberikan penjelasan bahwa hal ini terjadi karena
sifat immutable dari tuple.

---

#### **Soal 4: Menghitung Jumlah Kemunculan Elemen**

Diberikan tuple `nilai = (90, 85, 90, 78, 85, 90)`. Hitung berapa kali nilai 90 muncul dalam tuple tersebut.

#### Pembahasan Soal 4:

**Jawaban/Kode Python:**

```python

# Soal: Menghitung jumlah kemunculan elemen dalam tuple

nilai = (90, 85, 90, 78, 85, 90)

# Menggunakan method count()

jumlah_90 = [Link](90)

print(f"Tuple nilai: {nilai}")

print(f"Nilai 90 muncul sebanyak {jumlah_90} kali.")

```

**Penjelasan Kode:**

* Tuple `nilai` berisi beberapa angka dengan duplikat.

* Tuple memiliki beberapa method yang mirip dengan list, salah satunya adalah `.count()`.

* `[Link](90)`: Method `.count()` akan menghitung jumlah kemunculan elemen yang diberikan sebagai argumen
(dalam hal ini `90`) di dalam tuple `nilai`.

* Hasilnya (3) disimpan dalam variabel `jumlah_90` dan kemudian dicetak.

---

#### **Soal 5: Tuple sebagai Kunci Dictionary**

Buatlah sebuah dictionary untuk menyimpan nama kota berdasarkan koordinatnya. Gunakan tuple `(latitude, longitude)`
sebagai kunci dan nama kota sebagai nilainya. Tambahkan dua data, lalu akses nama kota untuk salah satu koordinat.

#### Pembahasan Soal 5:

**Jawaban/Kode Python:**

```python

# Soal: Menggunakan tuple sebagai kunci dictionary

# Membuat dictionary kosong

lokasi_kota = {}

# Menambahkan data dengan tuple sebagai kunci

lokasi_kota[( -6.2088, 106.8456 )] = "Jakarta"

lokasi_kota[( -7.2575, 112.7521 )] = "Surabaya"

print(f"Dictionary lokasi: {lokasi_kota}")

# Mengakses nilai menggunakan kunci tuple

koordinat_jakarta = (-6.2088, 106.8456)

kota = lokasi_kota[koordinat_jakarta]

print(f"\nKoordinat {koordinat_jakarta} adalah kota {kota}.")

```

**Penjelasan Kode:**

* `lokasi_kota = {}`: Membuat sebuah dictionary kosong.

* `lokasi_kota[( -6.2088, 106.8456 )] = "Jakarta"`: Di sini, kita menggunakan tuple `(-6.2088, 106.8456)` sebagai
**kunci**.

* Mengapa tuple bisa digunakan sebagai kunci dictionary? Karena kunci dictionary harus bersifat *hashable*, yang
artinya nilainya tidak boleh berubah. Karena tuple **immutable**, ia memenuhi syarat ini. List tidak bisa digunakan
sebagai kunci karena bersifat mutable.

* Setelah menambahkan dua data, dictionary `lokasi_kota` akan terlihat seperti `{(-6.2088, 106.8456): 'Jakarta', (-
7.2575, 112.7521): 'Surabaya'}`.

* `kota = lokasi_kota[koordinat_jakarta]`: Kita bisa mengakses nilai (nama kota) dengan cara yang sama seperti
dictionary pada umumnya, yaitu dengan menyertakan kuncinya (dalam hal ini, sebuah tuple).