# Bab 6. Algoritma Dan Module

**OBJEKTIF:**

1. Mahasiswa mampu memahami Algoritma pada Pyhton.
2. Mahasiswa mampu memahami Rekursif pada Python.
3. Mahasiswa mampu memahami Algoritma Pencarian pada Pyhton.
4. Mahasiswa mampu memahami Algoritma Penyortiran pada Python.
5. Mahasiswa mampu memahami *Module* pada Python.

---

## 6.1 Algoritma
Suatu persoalan dapat mempunyai beberapa algoritma untuk menyelesaikannya. Misalkan,
persoalan mencari nilai maksimum dari tiga angka. Satu cara adalah dengan menggunakan
struktur seleksi seperti berikut:

if x1 >= x2 and x1 >= x3:
    max = x1
elif x2 >= x1 and x2 >= x3:
    max = x2
else:
    max = x3

> Catatan:
>
> Kita menguji setiap nilai terhadap nilai-nilai lainnya dan jika nilai tersebut lebih besar maka kita tetapkan menjadi nilai max.

<br>

Cara kedua adalah dengan mengasumsikan salah satu nilai adalah nilai terbesar lalu bandingkan
nilai tersebut dengan nilai-nilai lainnya dan menukar nilai terbesar dengan nilai yang
dibandingkan jika nilai yang dibandingkan lebih besar.

max = x1
    if x2 > max:
max = x2
    if x3 > max:
max = x3

> Catatan:
> 1. Kita mengasumsikan x1 sebagai nilai terbesar dengan menyimpan nilainya sebagai
> max
> 2. Kita membandingkan max dengan nilai-nilai lainnya, dan jika nilai tersebut lebih besar
> dari nilai max, tukar nilai max dengan nilai tersebut

<br>

### 6.1.1 Algoritma Nilai Maksimum
Satu cara mencari nilai terbesar adalah dengan menggunakan struktur seleksi seperti berikut:

if x1 >= x2 and x1 >= x3:
    max = x1
elif x2 >= x1 and x2 >= x3:
    max = x2
else:
    max = x3

> Catatan:
>
> Kita menguji setiap nilai terhadap nilai-nilai lainnya dan jika nilai tersebut lebih besar maka
> kita tetapkan menjadi nilai max.

<br>

Cara lain adalah dengan mengasumsikan salah satu nilai adalah nilai terbesar lalu bandingkan
nilai tersebut dengan nilai-nilai lainnya dan jika terdapat nilai yang lebih besar maka kita menukar
nilai terbesar.

max = x1
    if x2 > max:
max = x2
    if x3 > max:
max = x3

> Catatan:
> 1. Kita mengasumsikan x1 sebagai nilai terbesar dengan menyimpan nilainya sebagai
> max
> 2. Kita membandingkan max dengan nilai-nilai lainnya, dan jika nilai tersebut lebih besar
> dari nilai max, tukar nilai max dengan nilai tersebut

<br>

Algoritma ini lebih bagus dibandingkan dengan algoritma sebelumnya karena kita dapat
mengembangkannya untuk mencari nilai terbesar dari berapapun banyak angka.

Kita dapat menggunakan struktur loop untuk mengembangkan algoritma nilai terbesar #2 untuk
mencari nilai terbesar dari angka-angka sebanyak berapapun. Misalkan kita mencari nilai terbesar
dari 10 angka berikut:
<center>35, 73, 90, 65, 23, 86, 43, 81, 34, 58</center>

<br>

Pertama, untuk memudahkan mengolah nilai-nilai di atas kita menyimpannya dalam sebuah list:
<center>
<img src="https://i.imgur.com/fQHWpKH.jpg">
</center>

Kemudian, kita dapat menggunakan struktur loop seperti berikut untuk mencari nilai maksimum:

# Inisialisasi nilai max dengan elemen pertama
max = angka[0]
for elm in angka:
    if elm >= max:
        max = elm

### 6.1.2 Algoritma Terbaik
Kita telah melihat suatu persoalan dapat mempunyai lebih dari satu algoritma untuk
menyelesaikannya. Namun, algoritma yang terbaik adalah algoritma yang paling efisien dan
biasanya algoritma yang menyelesaikan persoalan tercepat
<br>

## 6.2 Rekursif
Rekursif adalah fungsi yang memanggil dirinya sendiri. Contoh fungsi rekursif yaitu:

# rekursif_tanpa_akhir.py
# Program ini mempunyai sebuah fungsi rekursif

def pesan():
    print('Ini adalah fungsi rekursif')
    pesan()
    
def main():
    pesan()
    
main()

*Output:*

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif

Ini adalah fungsi rekursif
…

<br>

Di dalam definisi fungsi pesan terdapat *statement* yang memanggil fungsi pesan (dirinya sendiri).
Fungsi rekursif pesan() memanggil dirinya terus menerus tanpa akhir. Ketika kita mendesain
fungsi rekursif, kita harus menentukan kondisi kapan pemanggilan rekursif berakhir.

Pada contoh sebelumnya pemanggilan rekursif terjadi terus menerus, karena tidak ada yang
menghentikannya. Sama seperti sebuah *loop*, sebuah fungsi rekursif harus mempunyai cara
untuk mengendalikan berapa kali fungsi tersebut memanggil dirinya sehingga pemanggilan
rekursif dapat berhenti

# rekursi.py
# Program ini mempunyai sebuah fungsi rekursif

def pesan(kali):
    if kali > 0:
        print('Ini adalah fungsi rekursif')
        pesan(kali-1)
        
def main():
    pesan(5)
    
main()

Untuk menghentikan fungsi rekursif pesan(), kita memberikan kondisi kapan fungsi memanggil
dirinya dan memberikan argumen dalam pemanggilan dirinya yang bisa mengubah hasil evaluasi kondisi.

Ilustrasi pemanggilan rekursif pada contoh:
<center>
<img src="https://i.imgur.com/kIDixH8.jpg"
style="zoom:60%; display: block;" />
</center>
<br>

### 6.2.1 Problem Solving Dengan Rekursif
Untuk mendesain algoritma dengan rekursif, kita mengidentifkasi dua hal:
1. *Base* case (kasus dasar): Kasus dasar adalah kasus dimana pemanggilan rekursif berakhir.
2. *Recursive* case (kasus rekursif): Kasus dimana fungsi memanggil dirinya sendiri.

Kita akan melihat contoh penggunaan algoritma rekursif untuk dua persoalan yaitu faktorial dan
fibonacci.
<br>

### 6.2.2 Faktorial
Faktorial didefinisikan sebagai faktorial dari *integer* positif 𝑛 dinotasikan dengan 𝑛! adalah produk
semua *integer* positif kurang dari atau sama dengan 𝑛:
<center>𝑛! = 𝑛 × 𝑛 − 1 × 𝑛 − 2 × 𝑛 − 3 × ∙∙∙× 3 × 2 × 1
</center>

Contoh :

1! = 1

5! = 5 × 4 × 3 × 2 × 1 = 120

15! = 15 × 14 × ⋯ × 2 × 1 = 1307674368000

Adapun penyelesaian persoalan faktorial secara rekursif:

<center>
<img src="https://i.imgur.com/bvC3cSo.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Definisi fungsi faktorial dapat kita tuliskan sebagai berikut:
<center>
<img src="https://i.imgur.com/Tng4IRO.jpg"
style="zoom:70%; display: block;" />
</center>
<br>
<br>

Program berikut mendemonstrasikan fungsi faktorial:

# faktorial.py
# Fungsi ini menghitung nilai faktorial

# Definisi fungsi faktorial
def faktorial(n):
    # Base case
    if n == 1:
        return 1
# Recursive case
else:
    return n * faktorial(n-1)

# Fungsi main untuk menguji fungsi faktorial
def main():
    n = int(input('Masukkan nilai n: '))
    print(f'{n}! = {faktorial(n)}')
    
main()

*Output*:

Masukkan nilai n: 5 5! = 120

*Output*:

Masukkan nilai n: 15 15! = 1307674368000

<br>
<br>

### 6.2.3 Fibonacci

Barisan Fibonacci didefinisikan sebagai barisan bilangan yang suku ke-𝑛 nya, dinotasikan dengan
𝐹𝑛, adalah hasil jumlah dari suku ke-(𝑛 − 1) dan suku ke-(𝑛 − 2) dan dimulai dengan suku ke-0
adalah 0 dan suku ke-1 adalah 1. Atau dalam persamaan matematika, dituliskan sebagai berikut:

<center>
<img src="https://i.imgur.com/FdpHqrV.jpg"
style="zoom:65%; display: block;" />
</center>
<br>

dengan 𝐹0 = 0 dan 𝐹1 = 1.

Adapun Barisan Fibonacci dalam angka:

<center>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …</center>
<br>

Fibonacci memiliki kasus dasar dan kasus rekursif. Pada kasus dasar (terdapat dua kasus)
yaitu:

1. 𝑛 = 0 yang menghasilkan 0
2. 𝑛 = 1 yang menghasilkan 1

Sedangkan kasus rekursif yaitu:

1. 𝑛 > 1 dengan
<br>

Kita dapat menuliskan fungsi Fibonacci sebagai berikut:

def fibo(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibo(n - 1) + fibo(n - 2)

Program yang mendemonstrasikan fungsi fibonacci:

# fibonacci.py
# Program ini mendemonstrasikan barisan Fibonacci

# Definisi fungsi fibonacci
def fibo(n):
    # Base Cases
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibo(n - 1) + fibo(n - 2)
    
# Fungsi main untuk menguji fungsi Fibonacci
def main():
    n = int(input('Masukkan nilai n: '))
    f = fibo(n)
    print(f'Suku ke-{n} dari barisan Fibonacci: {f}')
    
main()

<br>

### 6.2.4 Rekursif Vs Loop
Perlu diketahui, semua persoalan yang dapat diselesaikan secara rekursif pasti dapat juga
diselesaikan dengan struktur *iterasi* (*loop*).

Faktorial dengan rekursif:

def faktorial(n):
    if n == 1:
        return 1
    else:
        return n * faktorial(n-1)

Faktorial dengan *loop*:

def faktorial(n):
    hasil = 1
    for i in range(1, num + 1):
        hasil = i * hasil

Fibonacci dengan rekursif:

def fibo(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibo(n - 1) + fibo(n - 2)

Fibonacci dengan *loop*:

def fibo(n):
    a, b = 0, 1
    if n == 0:
        return a
    elif n == 1:
        return b
else:
    for i in range(2, n + 1):
    suku_i = a + b
    a, b = b, suku_i
return suku_i

Beberapa persoalan lebih mudah diselesaikan menggunakan pendekatan rekursif dibandingkan
menggunakan *loop*. Rekursif lebih lambat dan lebih memakan *resource* komputer dibandingkan
*loop*. Namun, dalam beberapa persoalan, pendekatan rekursif memudahkan logika program dan
menjadikan program lebih mudah dibaca.
<br>

## 6.3 Algoritma Pencarian
Salah satu persoalan pemrograman yang paling umum adalah persoalan menentukan apakah
suatu nilai terdapat di dalam suatu data.

<center>
<img src="https://i.imgur.com/lXqdrGK.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Persoalan ini disebut persoalan pencarian dan terdapat dua algoritma dasar untuk persoalan ini:
1. Algoritma Pencarian *linear*
2. Algoritma Pencarian biner
<br>

### 6.3.1 Algoritma Pencarian Linear
Misalkan kita mencari nilai 73 dalam data yang disimpan dalam sebuah *list* terurut seperti
berikut:
<center>
<img src="https://i.imgur.com/jGPe9or.jpg"
style="zoom:80%; display: block;" />
</center>
<br>

Algoritma pencarian *linear* bekerja dengan menguji setiap elemen pada data dengan nilai yang
dicari secara berurut (dimulai dari elemen pertama, kedua dan seterusnya).
<center>
<img src="https://i.imgur.com/ugBj5uG.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/MUPz9dd.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/JoCOl8V.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

… dan seterusnya sampai elemen terakhir atau sampai dengan nilai yang dicari cocok dengan
suatu elemen.
Kita dapat menuliskan algoritma pencarian *linear* seperti berikut:
<center>
<img src="https://i.imgur.com/CMIHsVM.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Program yang mendemonstrasikan algoritma pencarian *linear*:

# Program ini mendemonstrasikan algoritma
# pencarian linear

# Fungsi linear_search mengimplementasikan algoritma pencarian linear
def linear_search(num, data):
    for index in range(len(data)):
        if num == data[index]:
            return index
        
    return -1
# Fungsi main untuk menguji pencarian linear
def main():
    num = 73
    data = [23, 34, 35, 43, 58, 65, 73, 81, 86, 90]
    
    index = linear_search(num, data)
    if index == -1:
        print('Data tidak ditemukan')
    else:
        print(f'Data ditemukan pada indeks ke-{index}') 
        
main()

*Output* :

Data ditemukan pada indeks ke-6

<br>
Algoritma pencarian *linear* adalah algoritma pencarian paling sederhana namun algoritma ini
paling tidak efisien. Jika kita mempunyai 99 angka pada data, algoritma ini dapat melakukan
pengujian hingga 99 kali. Terdapat algoritma pencarian yang lebih efisien dari algoritma
pencarian *linear* yaitu algoritma pencarian biner.
<br>

### 6.3.2 Algoritma Pencarian Biner
Ide dasar dari algoritma pencarian biner:
<center>
<img src="https://i.imgur.com/OPxr74H.jpg"
style="zoom:45%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/zGyMtiV.jpg"
style="zoom:45%; display: block;" />
</center>
<br>

Algoritma pencarian biner dapat kita tuliskan sebagai berikut:
<center>
<img src="https://i.imgur.com/hCdhy5E.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Program yang mendemonstrasikan algoritma pencarian biner:

# Program ini mendemonstrasikan algoritma
# pencarian biner

# Fungsi binary_search melakukan pencarian
# dengan algoritma pencarian biner
def binary_search(num, data):
    low = 0
    high = len(data) - 1
    
    while low <= high:
        mid = (low + high) // 2
        if num == data[mid]:
            return mid
        elif num < data[mid]:
            high = mid - 1
        else:
            low = mid - 1
            
    return -1

# Fungsi main untuk menguji pencarian linear
def main():
    num = 73
    data = [23, 34, 35, 43, 58, 65, 73, 81, 86, 90]
    
    index = binary_search(num, data)
    if index == -1:
        print('Data tidak ditemukan')
    else:
        print(f'Data ditemukan pada indeks ke-{index}')
        
main()

<br>

*Output*:

Data ditemukan pada indeks ke-6

<br>

Algoritma pencarian biner lebih efisien dibandingkan algoritma pencarian *linear* karena paling
banyak pengujian nilai dilakukan sebanyak setengah banyak data yang berarti setengah dari
banyaknya nilai yang diuji oleh algoritma pencarian *linear*.
<br>

## 6.4 Algoritma Penyortiran
Persoalan pemrograman dasar lain yang juga merupakan salah satu persoalan pemrograman
yang umum adalah persoalan penyortiran data.

Terdapat dua algoritma penyortiran dasar yaitu:

1. *Selection sort*
2. *Quicksort*
<br>

### 6.4.1 Selection Sort
Ide dasar dari *selection sort* adalah sebagai berikut:
<center>
<img src="https://i.imgur.com/6z3ZxuH.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/mcFB94k.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/mQYu2rd.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/0hwxRJK.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/mVBTO2p.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

<center>
<img src="https://i.imgur.com/oXmG3xU.jpg"
style="zoom:70%; display: block;" />
</center>
<br>
<br>
<br>

Kita dapat menuliskan algoritma selection sort seperti berikut:
<center>
<img src="https://i.imgur.com/5tf0iSI.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Program yang mendemonstrasikan *selection sort*:

# selection_sort.py
# Program ini mendemonstrasikan selection sort

# Fungsi yang mencari indeks minimun dari data dalam list
def indeks_minimum(data):
    indeks_min = 0
    min = data[indeks_min]
    for indeks in range(1, len(data)):
        if data[indeks] <= min:
            indeks_min = indeks
            min = data[indeks_min]
            
    return indeks_min

# Fungsi yang mengimplementasikan algoritma selection sort
def selection_sort(data):
    data_tersortir = []
    for i in range(len(data)):
        indeks_min = indeks_minimum(data)
        data_tersortir.append(data[indeks_min])
        data.pop(indeks_min)
        
    return data_tersortir

# Fungsi main untuk menguji selection sort
def main():
    data = [35, 73, 90, 65, 23, 86, 43, 81, 34, 58]
    data_tersortir = selection_sort(data)
    print(data_tersortir)
    
main()

*Output*:

[23, 34, 35, 43, 58, 65, 73, 81, 86, 90]

<br>

### 6.4.2 Quicksort
Algoritma *quicksort* adalah algoritma penyortiran yang jauh lebih cepat dibandingkan dengan
algoritma *selection sort*. Kita akan menggunakan pendekatan rekursif dari algoritma *quicksort*.
Base case dan *recursive case* dari algoritma *quicksort*:
1. *Base case*:
*List* kosong []: *list* kosong tidak perlu disortir
*List* satu elemen: *list* satu elemen tidak perlu disortir juga
2. *Recursive case*:
*List* dengan panjang lebih dari satu elemen
<br>

List dengan dua elemen:
<center>
<img src="https://i.imgur.com/FP0sX3X.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

1. Pilih salah satu elemen dalam *list*. Elemen ini kita sebut sebagai *pivot*.
Kita memilih elemen pertama sebagai *pivot*. (Cat. Kita dapat memilih elemen manapun
sebagai *pivot*.)
2. Partisi *list* dengan membuat sebuah *list* baru yang elemen-elemennya lebih kecil dari *pivot* di
sebelah kiri *pivot* dan sebuah *list* baru yang elemen-elemennya lebih besar dari *pivot* di
sebelah kanan *pivot*.
3. Sortir *list* yang elemen-elemennya lebih kecil dari *pivot* (sebelah kiri *pivot*) dengan *quicksort*
juga dan sortir *list* yang elemen-elemennya lebih besar dari *pivot* (sebelah kanan *pivot*)
dengan *quicksort* juga. Konkatenasi *list* lebih kecil dari *pivot*, *pivot*, dan *list* lebih besar dari
*pivot*.

*List* dengan tiga elemen:
<center>
<img src="https://i.imgur.com/43J5auO.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

*list* dengan empat elemen:
<center>
<img src="https://i.imgur.com/Sx6yFQt.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Algoritma *quicksort* dapat kita tuliskan seperti berikut:
<center>
<img src="https://i.imgur.com/A6zE1xW.jpg"
style="zoom:70%; display: block;" />
</center>
<br>

Uji fungsi *quicksort* yang sebelumnya:

def main():
    data = [35, 73, 90, 65, 23, 86, 43, 81, 34, 58]
    data_tersortir = quicksort(data)
    print(data_tersortir)
    
main()

*Output* :

[23, 34, 35, 43, 58, 65, 73, 81, 86, 90]

<br>

## 6.5 Module
Dengan semakin membesarnya dan semakin kompleks program yang kita tulis, kita perlu
mengorganisasi program kita. Kita telah melihat bahwa kita dapat memecah program menjadi
fungsi-fungsi yang masing-masing fungsi mengerjakan tugas spesifik tertentu. Lebih lanjut, kita
dapat mengelompokkan fungsi-fungsi yang mengerjakan tugas-tugas terkait ke dalam suatu
*module-module* . *Module* adalah sebuah *file* berekstensi .py yang berisi definisi-definisi fungsi.
Pengorganisasian fungsi-fungsi ke dalam module ini disebut dengan modularisasi. Dengan
modularisasi kita dapat menggunakan fungsi-fungsi dalam program-program berbeda, program
akan lebih mudah dipahami, diuji, dan dikelola.

Misalkan kita membuat sebuah program yang menghitung

1. Luas dari sebuah lingkaran
2. Keliling dari sebuah lingkaran
3. Luas dari sebuah persegi panjang
4. Area dari sebuah persegi panjang

Kita dapat mengelompokkan tugas-tugas dari program kita menjadi dua *module*:
1. *Module* yang berisi fungsi-fungsi yang terkait dengan lingkaran (misalkan kita namakan
dengan lingkaran.py)
2. *Module* yang berisi fungsi-fungsi yang terkait dengan persegi panjang (misalkan kita
namakan dengan persegi_panjang.py)

*Module* lingkaran (disimpan dalam *file* lingkaran.py):

# lingkaran.py
# Module lingkaran berisi fungsi-fungsi yang melakukan
# kalkulasi terkait lingkaran
import math

# Fungsi luas menerima radius (jari-jari) dari lingkaran sebagai argumen
# dan mengembalikan luas dari lingkaran
def luas(radius):
    return math.pi * radius ** 2

# Fungsi keliling menerima radius (jari-jari) dari lingkaran sebagai argumen
# dan mengembalikan keliling dari lingkaran
def keliling(radius):
    return 2 * math.pi * radius

*Module* persegipanjang (disimpan dalam *file* persegipanjang.py)

# persegipanjang.py
# Module persegipanjang berisi fungsi-fungsi yang melakukan
# kalkulasi terkait persegipanjang

# Fungsi luas menerima lebar dan panjang sebagai argumen
# dan mengembalikan luas persegi panjang
def luas(lebar, panjang):
    return lebar * panjang

# Fungsi keliling menerima lebar dan panjang sebagai argumen
# dan mengembalikan keliling persegi panjang
def keliling(lebar, panjang):
    return 2 * (panjang + lebar)

Untuk menggunakan *module-module* yang kita buat dalam suatu program kita harus meng*import*nya dengan *statement import* yang diikuti nama *module* (nama *file* tanpa ekstensi)

import <nama_module>

Misalkan, untuk meng*import* *module* lingkaran:

import lingkaran

Setelah meng*import* *module*, kita dapat memanggil fungsi dalam *module* menggunakan notasi
dot. Misalkan untuk memanggil fungsi luas dari *module* lingkaran dan menugaskan nilai kembali
fungsi luas tersebut ke suatu variabel, kita menuliskan:

luas_lingkaran = lingkaran.luas(radius)
kel_lingkaran = lingkaran.keliling(radius)

<br>
<br>

Hal yang perlu diperhatikan dalam membuat *module*:
1. *Module* harus disimpan dalam file berekstensi .py (jika tidak berekstensi .py, kita tidak akan
dapat meng*import*-nya ke program)
2. Nama *module* tidak boleh sama dengan *keyword* Python
Program berikut mendemonstrasikan penggunaan *module-module* sebelumnya:

# geometri.py
# Program ini meminta pengguna untuk memilih kalkulasi
# geometri dari sebuah menu. Program mengimport module
# lingkaran dan persegipanjang
import lingkaran
import persegipanjang

# CONSTANT untuk pilihan menu
PILIHAN_LUAS_LINGKARAN = 1
PILIHAN_KELILING_LINGKARAN = 2
PILIHAN_LUAS_PERSEGIPANJANG = 3
PILIHAN_KELILING_PERSEGIPANJANG = 4
PILIHAN_KELUAR = 5

# Fungsi tampilkan_menu menampikan menu ke pengguna
def tampilkan_menu():
    print(' MENU')
    print('1) Luas lingkaran')
    print('2) Keliling lingkaran')
    print('3) Luas persegi panjang')
    print('4) Keliling persegi panjang')
    print('5) Keluar’)

# Fungsi main
def main():
    # variabel pilihan untuk
    # menyimpan pilihan pengguna
    pilihan = 0
    
    while pilihan != PILIHAN_KELUAR:
        # Tampilkan menu
        tampilkan_menu()
        # Minta pilihan pengguna
        pilihan = int(input('Masukkan pilihan Anda: '))
        # Lakukan perhitungan pilihan penguna
        if pilihan == PILIHAN_LUAS_LINGKARAN:
            radius = float(input('Masukkan radius lingkaran: '))
            print('Luas lingkaran adalah', lingkaran.luas(radius))
    elif pilihan == PILIHAN_KELILING_LINGKARAN:
        radius = float(input('Masukkan radius lingkaran: '))
        print('Keliling lingkaran adalah', lingkaran.keliling(radius))
    elif pilihan == PILIHAN_LUAS_PERSEGIPANJANG:
        lebar = float(input('Masukkan lebar persegi panjang: '))
        panjang = float(input('Masukkan panjang persegi panjang: '))
        print('Luas persegi panjang adalah', persegipanjang.luas(lebar,
panjang))
    elif pilihan == PILIHAN_KELILING_PERSEGIPANJANG:
        lebar = float(input('Masukkan lebar persegi panjang: '))
        panjang = float(input('Masukkan panjang persegi panjang: '))
        print('Keliling persegi panjang adalah',
persegipanjang.keliling(lebar, panjang))
    elif pilihan == PILIHAN_KELUAR:
        print('Keluar dari program...')
    else:
        print('Error: pilihan tidak valid.')
        
# Panggil fungsi main
main()

<br>
<br>

**REFERENSI**
[1] Gaddis, Tony. 2012. *Starting Out With Python Second Edition*. United States of America: Addison-Wesley