Python MIT 6.100L: Rekursi, OOP, Class, dan Inheritance

1
# Faktorial dengan rekursi
2
def faktorial(n):
3
    # Base case: kasus terkecil yang bisa langsung dijawab
4
    if n == 0 or n == 1:
5
        return 1
6
    # Recursive case: pecah ke sub-masalah lebih kecil
7
    return n * faktorial(n - 1)
8

9
print(faktorial(5))  # 120
10
# Cara kerja:
11
# faktorial(5) = 5 * faktorial(4)
12
#              = 5 * 4 * faktorial(3)
13
#              = 5 * 4 * 3 * faktorial(2)
14
#              = 5 * 4 * 3 * 2 * faktorial(1)
15
#              = 5 * 4 * 3 * 2 * 1 = 120

1
# Jumlahkan semua angka dari 1 sampai n
2
def jumlah(n):
3
    if n == 1:          # base case
4
        return 1
5
    return n + jumlah(n - 1)  # recursive case
6

7
print(jumlah(10))  # 55

1
# Iterasi
2
def faktorial_iter(n):
3
    hasil = 1
4
    for i in range(1, n + 1):
5
        hasil *= i
6
    return hasil
7

8
# Rekursi — lebih dekat ke definisi matematika
9
def faktorial_rekur(n):
10
    return 1 if n <= 1 else n * faktorial_rekur(n - 1)

1
# Balik string secara rekursif
2
def balik_string(s):
3
    if len(s) <= 1:          # base case
4
        return s
5
    return balik_string(s[1:]) + s[0]  # rekursi
6

7
print(balik_string("python"))   # "nohtyp"
8
print(balik_string("hello"))    # "olleh"
9

10
# Cek palindrome
11
def palindrome(s):
12
    if len(s) <= 1:
13
        return True
14
    if s[0] != s[-1]:
15
        return False
16
    return palindrome(s[1:-1])
17

18
print(palindrome("radar"))   # True
19
print(palindrome("python"))  # False

1
# Jumlahkan semua elemen list secara rekursif
2
def jumlah_list(L):
3
    if len(L) == 0:
4
        return 0
5
    return L[0] + jumlah_list(L[1:])
6

7
print(jumlah_list([1, 2, 3, 4, 5]))  # 15
8

9
# Ratakan list bersarang
10
def ratakan(L):
11
    if len(L) == 0:
12
        return []
13
    if isinstance(L[0], list):
14
        return ratakan(L[0]) + ratakan(L[1:])
15
    return [L[0]] + ratakan(L[1:])
16

17
print(ratakan([1, [2, 3], [4, [5, 6]]]))  # [1, 2, 3, 4, 5, 6]

1
def hanoi(n, dari, ke, lewat):
2
    if n == 1:
3
        print(f"Pindahkan cakram 1 dari {dari} ke {ke}")
4
        return
5
    hanoi(n - 1, dari, lewat, ke)      # pindah n-1 cakram ke B
6
    print(f"Pindahkan cakram {n} dari {dari} ke {ke}")
7
    hanoi(n - 1, lewat, ke, dari)      # pindah n-1 cakram ke C
8

9
hanoi(3, 'A', 'C', 'B')
10
# Butuh 2^n - 1 = 7 langkah untuk n=3

1
def fib(n):
2
    if n <= 1:
3
        return n
4
    return fib(n - 1) + fib(n - 2)
5

6
# fib(10)  → cepat
7
# fib(40)  → mulai lambat (jutaan panggilan)
8
# fib(100) → praktis tidak selesai

1
# Memoization dengan dictionary
2
memo = {}
3
def fib_memo(n):
4
    if n in memo:
5
        return memo[n]    # pakai hasil yang sudah ada
6
    if n <= 1:
7
        return n
8
    hasil = fib_memo(n - 1) + fib_memo(n - 2)
9
    memo[n] = hasil       # simpan untuk nanti
10
    return hasil
11

12
print(fib_memo(100))  # selesai instan!
13

14
# Python punya decorator bawaan untuk ini
15
from functools import lru_cache
16

17
@lru_cache(maxsize=None)
18
def fib_cached(n):
19
    if n <= 1:
20
        return n
21
    return fib_cached(n - 1) + fib_cached(n - 2)

1
# Tanpa OOP — data tersebar
2
nama1, umur1, nilai1 = "Ana", 20, 85
3
nama2, umur2, nilai2 = "Budi", 21, 78
4

5
# Dengan OOP — data terkapsulasi
6
class Mahasiswa:
7
    def __init__(self, nama, umur):
8
        self.nama = nama
9
        self.umur = umur
10
        self.nilai = []
11

12
    def tambah_nilai(self, n):
13
        self.nilai.append(n)
14

15
    def rata_rata(self):
16
        return sum(self.nilai) / len(self.nilai) if self.nilai else 0
17

18
ana = Mahasiswa("Ana", 20)
19
ana.tambah_nilai(85)
20
ana.tambah_nilai(90)
21
print(ana.rata_rata())  # 87.5

1
class Hewan:
2
    # Class variable — dibagi semua instance
3
    jumlah_hewan = 0
4

5
    def __init__(self, nama, suara):
6
        # Instance variable — unik per objek
7
        self.nama = nama
8
        self.suara = suara
9
        Hewan.jumlah_hewan += 1
10

11
    def bersuara(self):
12
        print(f"{self.nama} berbunyi: {self.suara}")
13

14
    def info(self):
15
        return f"Hewan: {self.nama}"
16

17
# Membuat instance
18
kucing = Hewan("Kucing", "meow")
19
anjing = Hewan("Anjing", "woof")
20

21
kucing.bersuara()   # Kucing berbunyi: meow
22
anjing.bersuara()   # Anjing berbunyi: woof
23
print(Hewan.jumlah_hewan)  # 2

1
class Lingkaran:
2
    PI = 3.14159
3

4
    def __init__(self, jari_jari):
5
        self.r = jari_jari
6

7
    def luas(self):
8
        return Lingkaran.PI * self.r ** 2
9

10
    def keliling(self):
11
        return 2 * Lingkaran.PI * self.r
12

13
c = Lingkaran(5)
14
print(c.luas())      # 78.53975
15
print(c.keliling())  # 31.4159

1
class Vektor:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
    # Representasi string — untuk print()
7
    def __str__(self):
8
        return f"Vektor({self.x}, {self.y})"
9

10
    # Representasi resmi — untuk debugging
11
    def __repr__(self):
12
        return f"Vektor({self.x!r}, {self.y!r})"
13

14
    # Penjumlahan dengan +
15
    def __add__(self, lain):
16
        return Vektor(self.x + lain.x, self.y + lain.y)
17

18
    # Perkalian skalar dengan *
19
    def __mul__(self, skalar):
20
        return Vektor(self.x * skalar, self.y * skalar)
21

22
    # Panjang vektor dengan len()
23
    def __len__(self):
24
        return int((self.x ** 2 + self.y ** 2) ** 0.5)
25

26
    # Perbandingan dengan ==
27
    def __eq__(self, lain):
28
        return self.x == lain.x and self.y == lain.y
29

30
v1 = Vektor(2, 3)
31
v2 = Vektor(1, 4)
32
print(v1)           # Vektor(2, 3)
33
print(v1 + v2)      # Vektor(3, 7)
34
print(v1 * 3)       # Vektor(6, 9)
35
print(v1 == v2)     # False

1
class Hewan:
2
    def __init__(self, nama):
3
        self.nama = nama
4

5
    def bergerak(self):
6
        print(f"{self.nama} bergerak")
7

8
    def makan(self):
9
        print(f"{self.nama} makan")
10

11
# Subclass mewarisi semua dari Hewan
12
class Anjing(Hewan):
13
    def __init__(self, nama, ras):
14
        super().__init__(nama)  # panggil __init__ parent
15
        self.ras = ras
16

17
    # Override method parent
18
    def bergerak(self):
19
        print(f"{self.nama} berlari dengan 4 kaki")
20

21
    # Method baru khusus Anjing
22
    def menggonggong(self):
23
        print(f"{self.nama}: Woof!")
24

25
class Burung(Hewan):
26
    def bergerak(self):
27
        print(f"{self.nama} terbang")
28

29
# Pakai
30
anjing = Anjing("Rex", "Labrador")
31
anjing.bergerak()    # Rex berlari dengan 4 kaki (overridden)
32
anjing.makan()       # Rex makan (inherited)
33
anjing.menggonggong()  # Rex: Woof! (new)
34

35
burung = Burung("Tweety")
36
burung.bergerak()    # Tweety terbang (overridden)

1
print(isinstance(anjing, Anjing))  # True
2
print(isinstance(anjing, Hewan))   # True — Anjing adalah Hewan
3
print(isinstance(burung, Anjing))  # False
4

5
# Cek class
6
print(type(anjing))          # <class '__main__.Anjing'>
7
print(type(anjing).__name__) # 'Anjing'

1
class Aktivitas:
2
    def __init__(self, durasi, kalori):
3
        self.durasi = durasi   # menit
4
        self.kalori = kalori
5

6
    def ringkasan(self):
7
        return f"{durasi} menit, {self.kalori} kal"
8

9
class Lari(Aktivitas):
10
    def __init__(self, durasi, kalori, jarak):
11
        super().__init__(durasi, kalori)
12
        self.jarak = jarak  # km
13

14
    def kecepatan(self):
15
        return self.jarak / (self.durasi / 60)  # km/jam
16

17
    def ringkasan(self):
18
        base = super().ringkasan()
19
        return f"Lari: {base}, {self.jarak} km ({self.kecepatan():.1f} km/h)"
20

21
class Renang(Aktivitas):
22
    def __init__(self, durasi, kalori, kolam):
23
        super().__init__(durasi, kalori)
24
        self.kolam = kolam  # panjang kolam (m)
25

26
    def ringkasan(self):
27
        base = super().ringkasan()
28
        return f"Renang: {base}, {self.kolam}m kolam"
29

30
r = Lari(30, 300, 5)
31
print(r.ringkasan())  # Lari: 30 menit, 300 kal, 5 km (10.0 km/h)