i

KATA PENGANTAR

Algoritma dan pemrograman adalah dasar utama dalam pembuatan perangkat lunak. Algoritma
memberikan langkah-langkah jelas untuk menyelesaikan masalah, sedangkan pemrograman
mengubah langkah-langkah tersebut menjadi kode yang bisa dijalankan komputer. Python, dengan
sintaksisnya yang sederhana dan fleksibilitasnya yang tinggi, telah menjadi bahasa pemrograman
yang populer dalam berbagai aplikasi. Dengan menguasai algoritma dan pemrograman Python,
pembaca dapat membangun fondasi yang kuat dalam ilmu komputer.

Buku Algoritma dan Pemrograman pada Python ini disusun dengan tujuan memberikan
pemahaman mendalam mengenai konsep dasar algoritma dan pemrograman Python kepada
pembaca, khususnya bagi pembaca yang baru memulai perkuliahan di bidang ilmu komputer.
Materi yang disajikan mencakup spektrum yang luas, mulai dari pengenalan konsep algoritma,
tipe data, hingga struktur kontrol dan fungsi. Setiap topik dilengkapi dengan contoh-contoh
implementasi dalam bahasa Python serta latihan-latihan yang dirancang untuk menguji
pemahaman pembaca.

Melalui buku ini, pembaca diharapkan dapat mengembangkan keterampilan dasar

pemrograman dan memecahkan masalah secara efisien menggunakan algoritma yang tepat.
Penggunaan Python sebagai alat bantu pembelajaran diharapkan memudahkan pembaca dalam
memahami konsep-konsep logika pemrograman, serta memberikan fondasi yang kuat untuk
melanjutkan studi lebih lanjut di bidang teknologi informasi. Semoga buku ini dapat menjadi
kontribusi yang bermanfaat dalam mendukung proses pembelajaran dan pengembangan keilmuan
di bidang algoritma dan pemrograman.

Malang, 2024

Penulis

ii
 DAFTAR ISI

KATA PENGANTAR .................................................................................................................... ii

DAFTAR ISI.................................................................................................................................. iii

BAB I ALGORITMA DAN PEMROGRAMAN ........................................................................... 1

1.1 Pengantar............................................................................................................................... 1

1.2 Algoritma .............................................................................................................................. 1

1.3 Pemrograman ........................................................................................................................ 3

1.4 Pengenalan Python ................................................................................................................ 4

1.5 Instalasi lingkungan Python .................................................................................................. 4

1.6 IDE dan alat pendukung........................................................................................................ 5

1.7 Latihan .................................................................................................................................. 9

BAB II SINTAKS DASAR DAN TIPE DATA ........................................................................... 10

2.1 Pengantar............................................................................................................................. 10

2.2 Sintaks dasar ....................................................................................................................... 10

2.3 Variabel dan konstanta ........................................................................................................ 11

2.4 Tipe data.............................................................................................................................. 12

2.5 Operator dan ekspresi ......................................................................................................... 16

2.6 Input dan output .................................................................................................................. 18

2.7 Komentar............................................................................................................................. 19

2.8 Latihan ................................................................................................................................ 19

2.9 Tugas ................................................................................................................................... 20

BAB III STRUKTUR KONTROL ............................................................................................... 22

3.1 Pengantar............................................................................................................................. 22

iii
 3.2 Percabangan ........................................................................................................................ 22

3.3 Perulangan........................................................................................................................... 26

3.4 Latihan ................................................................................................................................ 29

3.5 Tugas ................................................................................................................................... 30

BAB IV FUNGSI DAN PROSEDUR .......................................................................................... 31

4.1 Pengantar............................................................................................................................. 31

4.2 Struktur data fungsi ............................................................................................................. 31

4.3 Struktur data prosedur ......................................................................................................... 32

4.4 Variabel lokal dan global .................................................................................................... 34

4.5 Pemanggilan fungsi dan prosedur ....................................................................................... 35

4.6 Prosedur dengan parameter by value dan by reference ....................................................... 36

4.7 Fungsi bawaan (built-in function) ....................................................................................... 37

4.8 Fungsi rekursif .................................................................................................................... 37

4.9 Modularitas program ........................................................................................................... 38

4.10 Latihan .............................................................................................................................. 40

4.11 Tugas ................................................................................................................................. 40

BAB V KOLEKSI DATA DAN MATRIKS................................................................................ 42

5.1 Pengantar............................................................................................................................. 42

5.2 Koleksi data ........................................................................................................................ 42

5.3 List, tuple, dictionary, dan set ............................................................................................. 43

5.4 Matriks ................................................................................................................................ 46

5.5 Latihan ................................................................................................................................ 55

5.6 Tugas ................................................................................................................................... 55

BAB VI FILE DALAM PYTHON ............................................................................................... 56

iv
 6.1 Pengantar............................................................................................................................. 56

6.2 File handler ......................................................................................................................... 56

6.3 Membaca dari file ............................................................................................................... 59

6.4 Menulis ke file .................................................................................................................... 61

6.5 Latihan ................................................................................................................................ 62

6.6 Tugas ................................................................................................................................... 62

BAB VII MASALAH SEDERHANA DAN SOLUSI ALGORITMA ........................................ 64

7.1 Pengantar............................................................................................................................. 64

7.2 Soal dan Pembahasan .......................................................................................................... 64

7.3 Latihan ................................................................................................................................ 77

v
 BAB I
ALGORITMA DAN PEMROGRAMAN
1.1 Pengantar

Bab ini akan membahas dasar-dasar algoritma dan pemrograman, serta panduan instalasi
lingkungan pengembangan Python. Memahami algoritma merupakan fondasi yang sangat penting
dalam dunia pemrograman. Algoritma adalah serangkaian langkah logis yang dirancang untuk
menyelesaikan suatu masalah secara efisien. Dengan memahami algoritma, seorang pengembang
dapat merancang solusi yang optimal untuk berbagai permasalahan dalam pengembangan
perangkat lunak. Pemrograman adalah proses menulis instruksi yang dapat dijalankan oleh
komputer untuk menyelesaikan tugas tertentu. Proses ini melibatkan logika, algoritma, dan
pemahaman bahasa pemrograman.

Python adalah bahasa pemrograman yang mudah dipelajari dan digunakan. Python
memiliki sintaks yang sederhana dan banyak diaplikasikan dalam berbagai bidang seperti
pengembangan web, ilmu data, dan pembelajaran mesin. Mempelajari algoritma dan pemrograman
membantu Anda berpikir logis dan sistematis dalam menyelesaikan masalah. Kemampuan ini
sangat berharga di dunia kerja dan kehidupan sehari-hari.

1.2 Algoritma
1.2.1 Pengertian algoritma
Algoritma adalah solusi atas permasalahan yang terdefinisi langkah-langkahnya secara
runtut. Konsep ini merupakan dasar dari pemikiran logis dan sistematis yang digunakan dalam
berbagai bidang, tidak terbatas hanya pada ilmu komputer. Algoritma menyediakan kerangka kerja
yang terstruktur untuk menyelesaikan masalah, mulai dari yang sederhana hingga yang kompleks.
Keunikan algoritma terletak pada sifatnya yang universal dan dapat diterapkan dalam berbagai
konteks, baik dalam dunia digital maupun dalam kehidupan sehari-hari.

Meskipun sering dikaitkan dengan komputasi, algoritma sebenarnya memiliki aplikasi yang
luas dalam kehidupan sehari-hari. Banyak aktivitas rutin yang manusia lakukan tanpa sadar
sebenarnya mengikuti pola algoritma, meskipun tidak selalu dilakukan dengan runtut dan detil.
Contoh-contoh sederhana seperti membuat secangkir teh, membeli barang di toko, atau memesan

1
ojek online, semuanya melibatkan serangkaian langkah yang dapat didefinisikan sebagai
algoritma. Perbedaannya terletak pada tingkat detail dan formalisasi; dalam kehidupan sehari-hari,
manusia cenderung melakukan langkah-langkah ini secara intuitif tanpa perlu menjabarkannya
secara eksplisit.
1.2.2 Contoh algoritma dalam kehidupan sehari-hari
Algoritma untuk membuat secangkir teh:

• Panaskan air.
• Masukkan teh ke dalam cangkir.
• Tuangkan air panas ke dalam cangkir.
• Tambahkan gula atau susu jika diinginkan.
• Aduk dan teh siap dinikmati.
1.2.3 Karakteristik algoritma yang baik
Algoritma yang baik harus memiliki beberapa karakteristik utama yang memastikan solusi
yang diberikan efektif dan efisien. Berikut adalah karakteristik tersebut:

• Kejelasan dan Tidak Ambigu

Setiap langkah dalam algoritma harus didefinisikan dengan jelas dan tidak boleh
menimbulkan kebingungan. Instruksi yang ambigu menyebabkan hasil yang salah atau
tidak konsisten ketika algoritma dijalankan.

• Terbatas
Algoritma harus memiliki titik akhir yang jelas, artinya algoritma harus berhenti
setelah sejumlah langkah tertentu. Algoritma yang tidak terbatas akan terus berjalan tanpa
henti, yang tentu saja tidak praktis. Dengan memiliki akhir yang jelas, algoritma
memastikan bahwa masalah yang dihadapi dapat diselesaikan dalam waktu yang wajar dan
tidak menyebabkan loop tanpa akhir.
• Efektif
Efektivitas dalam algoritma berarti algoritma harus mampu menyelesaikan masalah
yang diberikan. Setiap langkah dalam algoritma harus membawa proses lebih dekat ke
solusi akhir dan solusi yang dihasilkan harus tepat serta sesuai dengan tujuan awal.
Efektivitas juga mencakup kemapuan algoritma untuk memberikan solusi yang dapat

2
 diterapkan dalam situasi nyata, bukan hanya secara teoritis. Algoritma yang efektif
memastikan bahwa hasil akhirnya dapat diandalkan dan sesuai dengan kebutuhan yang
telah ditentukan.
• Efisien

Efisiensi algoritma dilihat dari dua aspek utama, yaitu waktu dan ruang. Waktu
mengacu pada jumlah langkah yang diperlukan untuk menyelesaikan algoritma, sedangkan
ruang mengacu pada jumlah memori yang digunakan selama eksekusi. Algoritma yang
efisien meminimalkan penggunaan kedua sumber daya serta memastikan bahwa solusi
ditemukan dengan cepat dan tanpa membebani sistem dengan kebutuhan memori yang
besar.

1.3 Pemrograman

Program komputer merupakan implementasi konkret dari suatu algoritma di dalam lingkungan
komputasi. Proses mengubah algoritma menjadi program disebut sebagai pemrograman.
Pemrograman dapat dipahami sebagai seni dan ilmu menerjemahkan algoritma ke dalam bahasa
yang dapat dimengerti dan dieksekusi oleh komputer. Hal ini melibatkan tidak hanya penguasaan
sintaks bahasa pemrograman tertentu, tetapi juga kemampuan untuk memecah masalah kompleks
menjadi langkah-langkah yang lebih kecil dan dapat dikelola.

Pemrograman mencakup kemampuan untuk mengoptimalkan kode agar berjalan secara

efisien, baik dari segi waktu eksekusi maupun penggunaan sumber daya. Seorang pemrogram
harus mempertimbangkan berbagai faktor, seperti pemilihan struktur data yang tepat, pengelolaan
memori, serta penggunaan algoritma yang efisien, guna memastikan bahwa program tidak hanya
berfungsi dengan benar, tetapi juga optimal. Selain itu, pemrograman melibatkan proses pengujian
dan debugging, yaitu mengidentifikasi dan memperbaiki kesalahan dalam kode untuk memastikan
program beroperasi sesuai dengan yang diharapkan. Proses ini menuntut kemampuan analitis yang
kuat untuk mendeteksi bug atau kesalahan logika. Pada akhirnya, pemrograman bukan hanya
tentang penulisan kode, tetapi juga proses kreatif yang memerlukan pemahaman mendalam
tentang algoritma, keterampilan teknis, dan ketajaman analisis untuk menciptakan solusi efektif
dan efisien bagi berbagai masalah komputasi.

3
1.4 Pengenalan Python

Python adalah bahasa pemrograman tingkat tinggi yang dirancang untuk memiliki sintaksis
yang mudah dibaca dan ditulis. Dikembangkan oleh Guido van Rossum dan pertama kali dirilis
pada tahun 1991, Python telah menjadi salah satu bahasa pemrograman paling populer di dunia.
Python menekankan pada kesederhanaan sintaksis yang memungkinkan penulisan kode yang jelas
dan mudah dipahami. Bahasa ini mendukung berbagai paradigma pemrograman seperti
berorientasi objek, imperatif, dan fungsional, memberikan fleksibilitas luar biasa dalam
pengembangan perangkat lunak. Selain itu, Python dirancang untuk mengutamakan produktivitas
pengembang, memungkinkan mereka untuk menulis kode dengan lebih cepat dan efisien.

Salah satu keunggulan utama Python adalah ekosistemnya yang luas dan terus berkembang.
Python Package Index (PyPI) menyediakan ribuan library dan framework yang memungkinkan
Python digunakan untuk berbagai aplikasi, mulai dari pengembangan web dengan Django dan
Flask hingga analisis data dengan Pandas dan NumPy, serta kecerdasan buatan dan pembelajaran
mesin dengan TensorFlow dan PyTorch. Komunitas Python yang besar dan aktif berperan penting
dalam perkembangan bahasa ini, seperti menyediakan dokumentasi, tutorial, dan dukungan yang
membantu pengembang dari semua tingkat pengalaman.

Python terus diperbarui dan disempurnakan, dengan versi terbaru, Python 3.12 yang dirilis
pada Oktober 2023. Versi ini membawa berbagai peningkatan, termasuk optimisasi kinerja,
perbaikan sistem type hinting, dan pembaruan pada modul asyncio untuk penanganan konkurensi
yang lebih baik. Perbedaan signifikan antara Python 3 dan versi sebelumnya (Python 2), meliputi
perubahan dalam sintaksis print, pembagian integer, penanganan Unicode, dan peningkatan
konsistensi dalam iterasi dan pengelolaan memori. Dengan kombinasi kesederhanaan, kekuatan,
dan fleksibilitas, Python tetap menjadi pilihan utama bagi pengembang di berbagai industri dan
lembaga akademis.

1.5 Instalasi lingkungan Python

1.5.1 Mengunduh dan Menginstal Python
• Kunjungi situs resmi Python di [Link]
• Unduh installer sesuai dengan sistem operasi yang digunakan (Windows, macOS, Linux).
• Ikuti petunjuk instalasi yang diberikan.

4
1.5.2 Mengatur PATH pada Sistem Operasi Windows
Setelah menginstal Python, langkah penting selanjutnya adalah menambahkan Python ke
variabel lingkungan PATH. Variabel PATH ini menunjuk ke direktori-direktori yang berisi
executable (file yang dapat dijalankan), seperti [Link]. Dengan menambahkan Python ke
PATH, pengguna dapat menjalankan perintah Python langsung dari command prompt atau
terminal tanpa perlu menspesifikasikan path lengkapnya.

Berikut merupakan cara menambahkan Python ke PATH:

• Buka pengaturan sistem dan cari variabel lingkungan pada perangkat masing-masing.
Biasanya terdapat bagian yang bernama "Environment Variables" atau "Advanced system
settings".
• Tambahkan path ke direktori instalasi Python ke dalam variabel PATH. Pastikan
memisahkan setiap path dengan tanda titik koma (;) pada Windows atau titik dua (:) pada
macOS dan Linux.
• Simpan perubahan yang telah dibuat.

1.6 IDE dan alat pendukung

1.6.1 Integrated Development Environment (IDE)
IDE adalah singkatan dari Integrated Development Environment, sebuah aplikasi perangkat
lunak yang dirancang untuk membantu para programmer dalam mengembangkan perangkat lunak
secara efisien. IDE menggabungkan berbagai alat dan fungsi yang dibutuhkan dalam
pengembangan perangkat lunak ke dalam satu antarmuka yang terpadu. Beberapa fungsi utama
IDE antara lain:

• Editor Teks

Editor teks merupakan bagian utama dari IDE di mana pengguna dapat menulis kode
program. Editor teks pada IDE biasanya memiliki fitur-fitur canggih seperti:

1. Pelengkapan kode otomatis

IDE dapat menyarankan potongan kode yang mungkin ingin pengguna tulis,
sehingga pengguna tidak perlu mengetik semuanya secara manual.

2. Penyorotan sintaks

5
 IDE akan mewarnai elemen-elemen sintaks dalam kode pengguna dengan
warna yang berbeda, sehingga lebih mudah membaca dan menemukan kesalahan.
• Debugging

IDE memungkinkan pengguna untuk menelusuri kode secara baris demi baris untuk
menemukan dan memperbaiki kesalahan.

• Kompiler atau Interpreter

IDE terintegrasi dengan kompiler atau interpreter untuk bahasa pemrograman yang
digunakan, sehingga pengguna dapat langsung mengkompilasi atau menjalankan kode dari
dalam IDE.

• Build Automation

IDE dapat membantu pengguna dalam mengotomatiskan proses membangun

aplikasi, seperti mengkompilasi kode sumber, menghubungkan pustaka, dan menghasilkan
file yang dapat dieksekusi.

• Kontrol Versi

Banyak IDE yang terintegrasi dengan sistem kontrol versi seperti Git, sehingga
pengguna dapat melacak perubahan pada kode dan bekerja sama dengan programmer lain.
1.6.2 Visual Studio Code
Terdapat banyak contoh IDE yang populer, salah satunya adalah Visual Studio Code. Visual
Studio Code (VSCode) adalah salah satu editor kode sumber yang serbaguna dan digunakan oleh
banyak pengembang di seluruh dunia. VSCode dikembangkan oleh Microsoft, menawarkan
berbagai fitur canggih yang memudahkan pengembangan perangkat lunak, termasuk dukungan
yang baik untuk pemrograman Python. Beberapa fitur utama VSCode yang membuatnya ideal
untuk Python antara lain:

• Ekstensi

VSCode memiliki ribuan ekstensi yang dapat memperkaya fungsionalitasnya.

Untuk Python, terdapat banyak ekstensi yang menyediakan fitur seperti auto-completion,
linting, debugging, dan integrasi dengan berbagai framework dan library Python.

• Version Control

6
 Version control adalah sistem yang memungkinkan pengguna melacak dan mengelola
perubahan kode. Dalam Visual Studio Code, Git berfungsi untuk memudahkan pengguna
melakukan commit, push, dan pull langsung dari editor.
• Terminal Terintegrasi
VSCode memiliki terminal bawaan yang dapat digunakan untuk menjalankan
perintah-perintah shell, termasuk perintah untuk mengelola lingkungan virtual Python.
• Kustomisasi
VSCode sangat dapat dikustomisasi, sehingga memungkinkan untuk menyesuaikan
tema, shortcut, dan pengaturan lainnya sesuai dengan preferensi.

Berikut merupakan langkah instalasi Visual Studio Code.

• Mengunduh VSCode sesuai sistem operasi masing-masing dari situs resmi di

[Link]
• Ikuti petunjuk instalasi yang diberikan.
• Buka fitur Extensions pada VSCode, lalu instal Python Debugger milik Microsoft.
1.6.3 Menulis dan Menjalankan Kode di IDE
Setelah menginstal Visual Studio Code dan ekstensi Python yang diperlukan, pengguna
dapat memulai proses penulisan kode Python. VSCode menyediakan antarmuka yang intuitif
untuk memfasilitasi penulisan dan eksekusi kode. Berikut ini merupakan langkah-langkah
penulisan dan eksekusi kode pada VSCode.

• Membuat File Baru

➢ Buka aplikasi Visual Studio Code pada perangkat masing-masing.
➢ Buatlah direktori baru untuk menyimpan proyek Python dengan cara akses menu
File > Open Folder.
➢ Di dalam direktori proyek, buatlah file baru dengan ekstensi ‘.py’. Contohnya,
‘[Link]’.
• Penulisan Kode Python
➢ Mulai tulis kode Python di dalam file yang baru dibuat. Contoh kode sebagai
berikut.
print("Hello, world!")

7
 ➢ Pada tahap ini, pengguna dapat memanfaatkan fitur-fitur pada VSCode, seperti
IntelliSense, Linting, dan Pemformatan. IntelliSense berfungsi untuk menyarankan
kode, parameter fungsi, dan dokumentasi saat pengguna mengetik. Linting
bertujuan untuk menemukan potensi kesalahan sintaksis dan gaya penulisan yang
tidak sesuai dengan standar. Terakhir, performatan digunakan pengguna untuk
mengatur VSCode dalam penformatan kode secara otomatis sesuai dengan gaya
tertentu, misalnya PEP 8.
• Eksekusi Kode
➢ Cari ikon ”Run” pada toolbar VSCode lalu klik ikon dan kode akan langsung
dieksekusi.
➢ Pengguna juga dapat melakukan kombinasi tombol Ctrl+Alt+N (Windows/Linux)
atau Cmd+Alt+N (macOS) yang biasanya digunakan sebagai shortcut untuk
menjalankan kode.
➢ Pengguna juga dapat menjalankan kode melalui terminal yang terintegrasi di
VSCode. Buka terminal dengan menekan Ctrl+ atau Cmd+ dan ketik perintah
python ’nama_file.py’. Contohnya adalah python ’[Link]’.
1.6.4 Penggunaan Terminal/Command Prompt
Terminal/Command Prompt di Visual Studio Code adalah jendela yang terintegrasi langsung
ke dalam IDE, memungkinkan pengguna untuk menjalankan perintah-perintah sistem operasi
secara langsung. Pengguna dapat melakukan berbagai tugas seperti mengelola proyek,
menjalankan perintah Git, menginstal paket, dan menjalankan skrip. Keunggulan utama
menggunakan terminal di VSCode adalah efisiensi, fleksibilitas, dan integrasi yang erat dengan
fitur-fitur lain dari IDE.
1.6.5 Manajemen Paket dengan pip
Pip merupakan manajer paket default untuk Python. pip digunakan untuk menginstal, meng-
upgrade, dan menghapus paket Python. Dengan pip, pengguna dapat dengan mudah menginstal
ribuan paket yang tersedia di Python Package Index (PyPI). Contoh penggunaan pip, yaitu:

• Menginstal paket: pip install numpy

• Meng-upgrade paket: pip install --upgrade numpy
• Membuat lingkungan virtual: python -m venv my_env

8
 • Mengaktifkan lingkungan virtual: my_env\Scripts\activate (Windows) atau source
my_env/bin/activate (Linux/macOS)
1.7 Latihan

Lakukanlah proses instalasi lingkungan Python dan Visual Studio Code pada perangkat Anda
masing-masing sesuai dengan petunjuk sebelumnya.

9
 BAB II
SINTAKS DASAR DAN TIPE DATA
2.1 Pengantar

Bab ini akan membahas dasar-dasar sintaks dan tipe data dalam bahasa pemrograman Python.
Pada bab sebelumnya, telah diuraikan tentang pengantar algoritma dan pemrograman serta
instalasi lingkungan pengembangan menggunakan Python. Pembahasan dalam bab sebelumnya
memberikan fondasi bagi pemahaman konsep dasar algoritma serta langkah awal dalam
mempersiapkan lingkungan pemrograman yang diperlukan untuk memulai belajar Python.

Pada bab ini, fokus utama adalah memahami elemen-elemen dasar yang membentuk sintaks
dalam Python, seperti variabel, konstanta, tipe data, operator, serta cara melakukan input dan
output. Selain itu, akan dijelaskan pula penggunaan komentar dalam kode, yang bertujuan untuk
memudahkan pemeliharaan dan pengembangan program. Pemahaman yang mendalam tentang
konsep-konsep ini akan memberikan dasar yang kuat bagi pembelajaran lebih lanjut mengenai
pemrograman dalam Python dan pengembangan aplikasi yang lebih kompleks.

Melalui bab ini, Anda diharapkan mampu memahami cara kerja sintaks dasar dalam Python,
bagaimana cara mendeklarasikan variabel dan konstanta, mengenali berbagai tipe data yang
tersedia, serta menguasai penggunaan operator dan operasi input-output. Pemahaman terhadap
konsep-konsep ini sangat penting dalam menulis kode yang efisien dan efektif, serta dalam
pengembangan program yang dapat diandalkan dan mudah dibaca.

2.2 Sintaks dasar

Sintaks dasar dalam Python dirancang untuk menjadi sederhana dan mudah dibaca,
menjadikannya salah satu bahasa pemrograman yang paling ramah untuk pemula. Salah satu fitur
yang paling menonjol adalah penggunaan identasi untuk menentukan blok kode, berbeda dengan
banyak bahasa pemrograman lain yang menggunakan kurung kurawal atau kata kunci khusus.
Identasi merupakan pengaturan posisi teks (spasi atau tab) dari margin kiri untuk menunjukkan
bahwa suatu blok kode berada dalam lingkup tertentu, seperti dalam pernyataan kondisional,
perulangan, fungsi, atau kelas.

10
 if 5 > 2:
print("Lima lebih besar dari dua!") # Baris ini diindentasikan

Identasi bukan hanya untuk estetika, tetapi merupakan bagian integral dari sintaks Python.

if 5 > 2:
print("Ini salah karena tidak diindentasikan") # Ini akan menyebabkan
IndentationError

Python juga menggunakan titik dua (:) untuk memulai blok kode baru, seperti setelah
pernyataan if, for, while, atau definisi fungsi. Pernyataan dalam Python umumnya ditulis satu per
satu baris untuk meningkatkan keterbacaan kode. Namun, untuk kasus-kasus sederhana, beberapa
pernyataan bisa ditulis dalam satu baris dengan menggunakan titik koma (;) sebagai pemisah.
Python tidak memerlukan tanda titik koma di akhir setiap pernyataan beberapa bahasa lain,
meskipun penggunaannya tidak akan menyebabkan error.

x = 5; y = 10; print(x + y) # Ini bisa dilakukan, tetapi tidak disarankan

2.3 Variabel dan konstanta

2.3.1 Variabel
Variabel adalah tempat penyimpanan yang diberi nama untuk menyimpan nilai yang dapat
diubah selama program berjalan. Contoh penamaan variabel yang benar adalah ‘nama, alamat,
usia’. Sementara, contoh penamaan variabel yang salah adalah ‘4xyz, +62, nama saya’.
Penggunaan variabel memungkinkan untuk menyimpan dan memanipulasi data secara efisien
dalam program yang dibuat.

nama = 'Budi' # String

jenis_kelamin = 'L' # Char
alamat = 'Indonesia' # String
usia = 20 # Integer

4xy = 'salah' # diawali angka

+62 = 'error' # diawali karakter +
nama saya = 'tidak bisa' # terdapat spasi
rata-rata = 'undefined' # terdapat karakter -

Variabel pada Python tidak harus dideklarasikan secara eksplisit. Deklarasi variabel terjadi
secara otomatis saat memberikan sebuah nilai pada suatu variabel. Dalam contoh di atas, nama

11
dan alamat akan menyimpan data berupa String, usia akan berisi angka (dalam hal ini bertipe
integer).

Dalam pemrograman Python, penting untuk memahami bagaimana memberikan nama

yang sesuai untuk variabel dan pengenal lainnya. Aturan dalam memberikan nama untuk pengenal
pada variabel adalah sebagai berikut.

• Menggunakan huruf (A-Z, a-z), digit (0-9), dan garis bawah (_)
• Tidak diawali dengan angka
• Penggunaan huruf kecil dan huruf kapital dibedakan (case sensitive)
• Tidak menggunakan reserved-word yaitu kata yang sudah digunakan secara khusus oleh
bahasa pemrograman tersebut. Di Python, kata itu meliputi and, continue, else, for,
import, not, def, except, from, in, or, return, is, try, class, elif, if,
print, while.
2.3.2 Konstanta
Konstanta adalah menyatakan nilai yang tetap dan tidak diperkenankan untuk berubah dalam
kondisi normal. Meskipun Python tidak memiliki tipe data khusus untuk konstanta, konvensi yang
umum adalah menulis nama konstanta dalam huruf besar, seperti berikut ini.

PI = 3.14159
GRAVITASI = 9.8

Dengan menggunakan konstanta, kode lebih mudah dibaca dan dipelihara karena nilai-nilai
penting yang tidak boleh diubah didefinisikan dengan jelas.

2.4 Tipe data

2.4.1 Angka
Seperti pada umumnya bahasa pemrograman, tipe data integer dan float juga tersedia di
Python. Tipe data integer digunakan untuk menyimpan nilai bilangan bulat, sedangkan float
digunakan untuk menyimpan nilai bilangan desimal. Hal ini memungkinkan pengguna Python
untuk melakukan berbagai operasi matematika dengan presisi yang dibutuhkan.

12
 # Integer
a = 10
b = -5

# Float
c = 3.14
d = -0.75

print("Nilai a:", a)
print("Nilai b:", b)
print("Nilai c:", c)
print("Nilai d:", d)

Namun, tidak seperti beberapa bahasa pemrograman lainnya, Python tidak mengenal
operasi unary seperti operator increment (x++) dan decrement (x--). Sebagai gantinya, Python
menggunakan bentuk eksplisit untuk operasi penambahan dan pengurangan, misalnya 𝑥+= 1 atau
𝑥−= 1.

# Increment
x = 5
x += 1 # Sama dengan x = x + 1
print("Nilai x setelah increment:", x)

# Decrement
y = 10
y -= 1 # Sama dengan y = y - 1
print("Nilai y setelah decrement:", y)

Untuk akurasi yang lebih tinggi dan kebutuhan komputasi tertentu, Python juga
menyediakan tipe data long integer dan bilangan kompleks. Tipe data long integer di Python secara
otomatis digunakan ketika nilai integer melebihi batas representasi integer standar, sehingga tidak
ada batasan praktis pada ukuran integer yang dapat disimpan.

# Long Integer
big_number = 123456789012345678901234567890
print("Nilai big_number:", big_number)

Selain itu, Python juga mendukung bilangan kompleks, yang diwakili oleh tipe kompleks.
Bilangan kompleks memiliki bagian real dan bagian imajiner, misalnya z = 3 + 4j, di mana 𝑗
merupakan unit imajiner.

13
 # Bilangan Kompleks
z = 3 + 4j
print("Bagian real dari z:", [Link])
print("Bagian imajiner dari z:", [Link])
print("Nilai z:", z)

2.4.2 Boolean
Tipe data dasar boolean juga tersedia di Python, digunakan untuk merepresentasikan nilai
benar (True) dan salah (False). Operator boolean diimplementasikan dalam kata bahasa Inggris
seperti and, or, dan not, bukan menggunakan simbol seperti && dan || yang umum ditemukan
dalam bahasa pemrograman lain.

# Deklarasi boolean
benar = True
salah = False

# Operator AND
a = True
b = False
hasil_and = a and b
print(f"Hasil dari {a} and {b} adalah {hasil_and}") # Output: False

# Operator OR
hasil_or = a or b
print(f"Hasil dari {a} or {b} adalah {hasil_or}") # Output: True

# Operator NOT
hasil_not = not a
print(f"Hasil dari not {a} adalah {hasil_not}") # Output: False

# Contoh penggunaan dalam kondisi

umur = 20
punya_sim = True

if umur >= 18 and punya_sim:

print("Anda diperbolehkan mengemudi.")
else:
print("Anda tidak diperbolehkan mengemudi.")

14
2.4.3 String
String merupakan rangkaian karakter yang digunakan untuk menyimpan dan memanipulasi
teks. Python mengenali rangkaian karakter sebagai string ketika diawali dan diakhiri dengan
karakter petik yang sama, baik petik tunggal (') maupun petik ganda ("). Hal ini memberikan
fleksibilitas dalam penulisan string yang mengandung petik tanpa perlu menggunakan karakter
escape. Selain itu, string yang membutuhkan beberapa baris, Python menyediakan cara penulisan
dengan tiga tanda petik di awal dan di akhir (''' atau """). Metode ini memudahkan dalam
menuliskan teks panjang atau dokumen yang memerlukan pemformatan khusus.

# String dengan petik tunggal

nama = 'Alice'
print(nama) # Output: Alice

# String dengan petik ganda

alamat = "Jalan Kenangan No. 45"
print(alamat) # Output: Jalan Kenangan No. 45

# String dengan petik tunggal mengandung petik ganda

kalimat = 'Dia berkata, "Halo!"'
print(kalimat) # Output: Dia berkata, "Halo!"

# String dengan petik ganda mengandung petik tunggal

kutipan = "It's a beautiful day!"
print(kutipan) # Output: It's a beautiful day!

# String multi-baris dengan tiga tanda petik

pesan = """Halo,
Ini adalah contoh string
yang terdiri dari beberapa baris.
Terima kasih!"""
print(pesan)
# Output:
# Halo,
# Ini adalah contoh string
# yang terdiri dari beberapa baris.
# Terima kasih!

Python memiliki sejumlah fitur yang berguna untuk memanipulasi String.

15
 print([Link]()) # Huruf besar di awal
print([Link]()) # Huruf besar semua
print([Link](9)) # Rata kanan dengan lebar 9
print([Link](9)) # Rata tengah dengan lebar 9
print([Link]('l', '(el)')) # mengganti 'l' dengan '(el)'
print(' hello '.strip()) # Menghapus whitespace di awal dan akhir

2.5 Operator dan ekspresi

Ekspresi adalah representasi nilai yang seringkali berupa transformasi data dan peubah dalam
bentuk persamaan yang direlasikan oleh operator dan operand. Operand dapat berupa data, tetapan,
peubah, atau hasil suatu fungsi, sementara operator adalah simbol-simbol yang memiliki fungsi
untuk menghubungkan operand sehingga bertransformasi. Misalnya, dalam ekspresi aritmatika
sederhana seperti 2 + 3, angka 2 dan 3 adalah operand, sedangkan simbol + adalah operator yang
menghubungkan keduanya untuk menghasilkan nilai 5.

### Operator Aritmatika

3 + 5 # operator plus
5 - 7 # operator minus
4 * 6 # operator kali (multiply)
2 ** 3 # operator pangkat (power)
4 / 3 # operator bagi (division)
4.0 / 3 # tipe data operand menentukan tipe data hasil
4 // 3.0 # floor division
8 % 3 # operator sisa bagi (modulo)

### Operator Bitwise

2 << 2 # Left Shift (10 --> 1000) = 8
11>> 1 # Right Shift (1011 --> 101) = 5
5 & 3 # bitwise AND (5 & 3 ~ 101 AND 11) = 1
5 | 3 # bitwise OR (5 | 3 ~ 101 OR 11) = 7
5 ^ 3 # bitwise XOR (5 ^ 3 ~ 101 XOR 11) = 6
~5 # bitwise invert (~5 = -(5+1)) = -6

### Operator Perbandingan

5 <= 3 # Less than or equal to
5 >= 3 # More than or equal to
5 == 3 # Equal to
5 != 3 # Not Equal to

16
 ### Operator Logika
x, y = True, False
not x # NOT
x and y # AND
x or y # OR

### Tipe data Boolean di setiap operand dan menggunakan bitwise

operator
x & y
x | y
x ^ y

2.5.1 Derajat prioritas

Derajat prioritas operator menentukan bagian ekspresi mana yang dieksekusi terlebih dahulu jika
terdapat lebih dari satu operator dalam suatu ekspresi. Semisal 2 + 3 ∗ 4, seharusnya perkalian
dieksekusi terlebih dahulu seperti dulu diajarkan di sekolah. Jika ingin mengeksekusi bagian

tertentu lebih dahulu, gunakan tanda kurung ().

Derajat operator secara lengkap di Python adalah sebagai berikut.

• Ekspresi lambda (lambda)

• Boolean (or, and, not)
• Membership test (in, not in)
• Identity test (is,is not)
• Perbandingan (<, >, <=, >=, ==, ! =)
• Bitwise (|, &)
• Shifts (<<,>>)
• Penjumlahan/Pengurangan (+, −)
• Perkalian/Pembagian (∗, /, %)
• Negasi (−𝑥)
• Bitwise NOT (~𝑥)
• Pangkat (**)

17
 print(2+3*4)
print((2+3)*4)
print(2+3>4)
print(2+3>4>5)

panjang = 5
lebar = 2
luas = panjang * lebar
print('Luas bidang sebesar', luas)
print('Keliling bidang sepanjang', 2*(panjang+lebar))

2.6 Input dan output

Interaksi dengan pengguna merupakan bagian penting dari banyak program, dan Python
menyediakan cara sederhana untuk mengambil input dari pengguna dan menampilkan output.
Fungsi input() digunakan untuk mengambil input dari pengguna dalam bentuk string. Sebagai
contoh, pernyataan nama = input("Masukkan nama Anda: ") akan meminta pengguna untuk
memasukkan namanya. Selain itu, pada Python pengguna diperbolehkan untuk mengonversi input
ke tipe data lain jika diperlukan, seperti umur = int(input("Masukkan umur Anda: ")) untuk
mengonversi input ke tipe data integer.

# Mengambil input dari pengguna

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

Untuk menampilkan output, Python menggunakan fungsi print(). Fungsi ini dapat
digunakan untuk menampilkan pesan atau nilai variabel ke layar, seperti print("Selamat datang, "
+ nama) yang akan menggabungkan string dengan nilai variabel nama. Selain itu, pada Python
juga dapat menggunakan format string modern dengan f-string, seperti print(f"Nama Anda adalah
{nama} dan umur Anda {umur} tahun"), yang lebih mudah dibaca dan ditulis.

# Menampilkan output menggunakan print()

print("Selamat datang, " + nama)
print("Nama Anda adalah " + nama + " dan umur Anda " + str(umur)
+ " tahun.")

# Menampilkan output menggunakan f-string

print(f"Nama Anda adalah {nama} dan umur Anda {umur} tahun.")

18
2.7 Komentar

Komentar adalah cara untuk menyisipkan catatan atau penjelasan dalam kode yang tidak akan
dieksekusi oleh Python. Penggunaan Python mendukung dua jenis komentar yaitu komentar satu
baris dan multi-baris. Komentar satu baris dimulai dengan tanda pagar (#). Komentar satu baris
berguna untuk penjelasan singkat atau catatan di samping kode.

# Ini adalah komentar

Komentar multi-baris atau lebih panjang menggunakan tanda kutip tiga (’’’ atau ”””).
Komentar ini juga tidak dieksekusi oleh Python dan digunakan untuk memberikan penjelasan lebih
rinci atau catatan penting di awal fungsi atau modul.

"""
Fungsi ini menghitung luas lingkaran
dengan rumus pi * r^2
"""
def luas_lingkaran(r):
return [Link] * r * r

Penggunaan komentar yang efektif bukan hanya tentang menjelaskan apa yang dilakukan
kode, tetapi juga mengapa kode tersebut ditulis dengan cara tertentu. Hal ini sangat membantu
dalam pemeliharaan jangka panjang, terutama saat bekerja dalam tim atau meninjau kode setelah
beberapa waktu. Python mendukung docstrings yaitu string dokumentasi yang dapat diakses
secara programatik, yang memungkinkan integrasi dokumentasi dengan alat pengembangan dan
sistem dokumentasi otomatis. Menulis komentar yang jelas dan informatif adalah keterampilan
penting yang meningkatkan kualitas kode dan kolaborasi dalam pengembangan perangkat lunak.

2.8 Latihan

1) Buat program untuk menghitung keliling dan luas dari bidang persegi, persegi panjang,
segitiga, dan lingkaran. Gunakan input dari pengguna untuk memasukkan sisi atau panjang
yang diperlukan setiap bidang.
2) Buat program yang mendeklarasikan tiga variabel: x sebagai integer, y sebagai float, dan z
sebagai boolean. Gunakan operator perbandingan untuk membandingkan x dan y, serta
gunakan operator logika untuk menggabungkan hasil perbandingan dengan z. Cetak hasil

19
 perbandingan dan operasi logika tersebut, dan tambahkan komentar yang menjelaskan
setiap operasi dan hasilnya.
3) Buat program yang meminta pengguna untuk memasukkan nama, umur, dan tinggi badan.
Hitung dan tampilkan pesan yang menginformasikan apakah pengguna tersebut memenuhi
syarat tinggi minimum (contoh: 150 cm) untuk mengikuti sebuah kegiatan. Gunakan
format string modern (f-string) untuk output.

2.9 Tugas

Studi Kasus Sistem Manajemen Perpustakaan Sederhana

• Latar Belakang
Perpustakaan sekolah ingin membuat sistem manajemen sederhana untuk melacak buku
yang dipinjam oleh siswa. Sistem ini akan meminta input dari pengguna, melakukan
perhitungan, dan menampilkan hasilnya dengan format yang rapi. Program ini juga harus
memiliki komentar yang jelas untuk memudahkan pemahaman.
• Deskripsi Tugas
Anda diminta untuk membuat program Python yang dapat melakukan hal-hal berikut:
1) Minta pengguna memasukkan judul buku, nama peminjam, dan jumlah hari
peminjaman.
2) Tetapkan biaya peminjaman per hari (misalnya, Rp 2.000 per hari). Hitung total biaya
peminjaman berdasarkan jumlah hari peminjaman.
3) Tampilkan judul buku, nama peminjam, jumlah hari peminjaman, dan total biaya
dengan format yang rapi.
4) Tambahkan komentar pada setiap bagian kode untuk menjelaskan fungsinya.
• Tugas Tambahan
1) Modifikasi program untuk menambahkan batas maksimum hari peminjaman (contoh:
30 hari). Jika pengguna memasukkan jumlah hari lebih dari 30, tampilkan pesan
peringatan.
2) Tambahkan opsi bagi pengguna untuk memasukkan beberapa buku sekaligus dan
menampilkan total biaya keseluruhan.

20
3) Integrasikan pengecekan validasi untuk memastikan input jumlah hari adalah angka
positif.

21
 BAB III
STRUKTUR KONTROL
3.1 Pengantar

Pada bab sebelumnya, telah dibahas sintaks dasar dan tipe data dalam Python, yang
memberikan fondasi penting untuk pemrograman. Pemahaman tentang sintaks dasar dan tipe data
memungkinkan untuk menggunakan struktur kontrol dengan lebih efektif. Dalam bab ini, akan
dilanjutkan dengan eksplorasi mendalam mengenai struktur kontrol dalam pemrograman Python,
yang meliputi percabangan dan perulangan.

Struktur kontrol adalah elemen fundamental dalam pemrograman yang memungkinkan

pengembang untuk menentukan alur eksekusi program berdasarkan kondisi tertentu atau untuk
mengulangi serangkaian instruksi beberapa kali. Dengan menggunakan struktur kontrol, program
dapat membuat keputusan otomatis dan menjalankan tugas berulang secara efisien.

Percabangan (conditional statements) memungkinkan program untuk memilih jalur eksekusi

yang berbeda berdasarkan hasil evaluasi suatu kondisi. Hal ini sangat penting dalam membuat
program yang dinamis dan mampu merespon berbagai input atau situasi dengan cara yang berbeda.
Sementara itu, perulangan (loops) memungkinkan program untuk menjalankan blok kode berulang
kali selama kondisi tertentu terpenuhi. Hal ini bermanfaat untuk tugas yang berulang seperti iterasi
melalui elemen-elemen array atau pengolahan data dalam jumlah besar. Dengan memahami dan
menerapkan kedua struktur kontrol ini dengan baik, pengembang dapat menulis kode yang lebih
efisien, terstruktur, dan mudah dipahami.

3.2 Percabangan

Percabangan adalah mekanisme dalam pemrograman yang memungkinkan alur eksekusi

program untuk bercabang berdasarkan kondisi tertentu. Dengan percabangan, program dapat
membuat keputusan otomatis dan mengeksekusi blok kode yang sesuai dengan kondisi yang
dievaluasi. Kondisi ini biasanya berupa ekspresi logika yang menghasilkan nilai benar (true) atau
salah (false). Percabangan memainkan peran penting dalam membuat program yang fleksibel dan
mampu merespon berbagai situasi atau input pengguna dengan cara yang berbeda.

22
3.2.1 If-else statement
If-else statement adalah bentuk percabangan yang paling sederhana dan umum digunakan
dalam pemrograman. Pernyataan ini memungkinkan program untuk mengeksekusi blok kode
tertentu jika kondisi yang diberikan bernilai benar (true), dan blok kode yang berbeda jika kondisi
tersebut bernilai salah (false). Penggunaan if-else sangat penting dalam skenario di mana program
perlu membuat keputusan dan bertindak berdasarkan hasil evaluasi kondisi tertentu, seperti
memeriksa nilai input pengguna atau status suatu variabel.

nilai = 85

if nilai >= 90:

print("A")
elif nilai >= 80:
print("B")
elif nilai >= 70:
print("C")
elif nilai >= 60:
print("D")
else:
print("F")

Dalam contoh di atas, nilai variabel ‘nilai’ dievaluasi terhadap beberapa kondisi
menggunakan if-else. Program mencetak "B" karena nilai 85 memenuhi kondisi nilai ≥ 80.

Penggunaan if-else tidak terbatas pada kondisi sederhana karena dapat dikombinasikan dengan
operator logika seperti and, or, dan not untuk membentuk kondisi yang lebih kompleks. Dengan
memeriksa beberapa kondisi sekaligus, program dapat membuat keputusan yang lebih cerdas dan
responsif terhadap berbagai situasi.

23
 umur = 25
pendapatan = 50000
status_pelajar = False

# Menggunakan operator logika AND

if umur > 18 and pendapatan > 40000:
print("Anda berhak mendapatkan pinjaman.")
else:
print("Anda tidak berhak mendapatkan pinjaman.")

# Menggunakan operator logika OR

if umur < 18 or pendapatan < 30000:
print("Anda tidak memenuhi syarat untuk mendapatkan kartu kredit.")
else:
print("Anda memenuhi syarat untuk mendapatkan kartu kredit.")

# Menggunakan operator logika NOT

if not status_pelajar:
print("Anda tidak berhak mendapatkan diskon pelajar.")
else:
print("Anda berhak mendapatkan diskon pelajar.")

Dalam contoh di atas, kondisi pertama menggunakan operator and untuk memeriksa apakah
usia lebih dari 18 tahun dan pendapatan lebih dari 40.000. Kedua kondisi terpenuhi, sehingga
mencetak "Anda berhak mendapatkan pinjaman.". Kondisi kedua menggunakan operator or untuk
memeriksa apakah usia kurang dari 18 tahun atau pendapatan kurang dari 30.000. Kedua kondisi
tidak terpenuhi, sehingga mencetak "Anda memenuhi syarat untuk mendapatkan kartu kredit.".
Kondisi ketiga menggunakan operator not untuk memeriksa apakah status pelajar adalah False.
Kondisi terpenuhi, sehingga mencetak "Anda tidak berhak mendapatkan diskon pelajar.".
3.2.2 Nested If-else
Nested if-else adalah teknik pemrograman di mana satu struktur if-else ditempatkan di dalam
struktur if-else lainnya, menciptakan tingkatan atau hierarki dalam pengambilan keputusan
program. Bayangkan sebuah pohon keputusan, di mana setiap cabang memiliki cabang-cabang
lebih kecil. Struktur ini memungkinkan programmer untuk menangani skenario yang kompleks
dengan berbagai kondisi yang saling bergantung. Misalnya, dalam sebuah aplikasi cuaca, program
mungkin pertama-tama memeriksa apakah hari ini hujan atau cerah, kemudian di dalam masing-
masing kondisi tersebut, memeriksa suhu untuk menentukan rekomendasi pakaian yang tepat.

24
 def pilih_aktivitas(cuaca, dana):
if cuaca == "cerah":
if dana >= 100000:
print("Cuaca cerah dan dana cukup. Ayo pergi ke pantai!")
elif 50000 <= dana < 100000:
print("Cuaca cerah, tapi dana terbatas. Kita bisa piknik di taman.")
else:
print("Cuaca cerah, tapi dana minim. Bagaimana kalau jalan-jalan di
sekitar rumah?")
elif cuaca == "hujan":
if dana >= 75000:
print("Hujan dan ada cukup dana. Nonton film di bioskop sepertinya
ide bagus.")
elif 30000 <= dana < 75000:
print("Hujan, dana cukup untuk aktivitas sederhana. Mungkin ke kafe
untuk minum kopi?")
else:
print("Hujan dan dana terbatas. Mari kita nonton film di rumah
saja.")
else:
print("Cuaca tidak menentu. Lebih baik kita tetap di rumah dan membaca
buku.")

# Contoh penggunaan fungsi

pilih_aktivitas("cerah", 120000)
pilih_aktivitas("hujan", 40000)
pilih_aktivitas("berawan", 10000)

Kode program di atas mendemonstrasikan bagaimana nested if-else dapat digunakan untuk
membuat keputusan berdasarkan multiple conditions yang saling terkait. Meskipun powerful,
penggunaan nested if-else yang berlebihan dapat mengakibatkan kode yang sulit dibaca dan
dipelihara, fenomena yang sering disebut sebagai "arrow code" atau "pyramid of doom". Oleh
karena itu, saat menggunakan nested if-else, penting untuk menjaga keseimbangan antara
fungsionalitas dan keterbacaan, mempertimbangkan alternatif seperti switch statements atau
pendekatan pemrograman yang lebih modular ketika kompleksitas meningkat.
3.2.3 Match-case statement
Mulai dari versi 3.0, Python telah memperkenalkan sintaks match-case yang berfungsi mitip
dengan switch-case di bahasa pemrograman lain. Fitur ini bertujuan untuk membandingkan nilai
secara lebih efisien. Sebelum adanya match-case, programmer Python sering menggunakan

25
kombinasi if-elif-else atau kamus (dictionary) untuk mencapai fungsionalitas yang sama.
Meskipun masih bisa digunakan, match-case menawarkan cara yang lebih baik.

# Fungsi sederhana untuk mencocokkan angka dengan teks

def runMatch():
num = int(input("Masukkan angka antara 1 dan 3: "))

# Pencocokan angka dengan teks menggunakan match-case

match num:
# Jika angka adalah 1
case 1:
print("Satu")
# Jika angka adalah 2
case 2:
print("Dua")
# Jika angka adalah 3
case 3:
print("Tiga")
# Jika angka bukan antara 1 dan 3
case _:
print("Angka tidak antara 1 dan 3")
runMatch()

Kode Python di atas mendefinisikan sebuah fungsi bernama runMatch(). Fungsi ini meminta
pengguna untuk memasukkan sebuah angka antara 1 dan 3. Kemudian, menggunakan match-case,
program memeriksa nilai angka yang dimasukkan dan mencetak teks yang sesuai. Jika angka yang
dimasukkan bukan antara 1 dan 3, fungsi runMatch() akan dipanggil kembali untuk meminta input
ulang.

3.3 Perulangan

Perulangan digunakan untuk mengulang eksekusi statement hingga beberapa kali sesuai
dengan iterasi yang didefinisikan. Python menggunakan keyword for dan while untuk melakukan
perulangan ini.

• for digunakan ketika kita ingin mengulang suatu blok kode untuk setiap elemen dalam
suatu urutan (sequence) seperti list, tuple, atau string. Perulangan for sangat efisien untuk
melakukan iterasi pada setiap elemen dalam suatu koleksi data.

26
 • while bekerja berdasarkan suatu kondisi. Selama kondisi tersebut bernilai benar (True),
blok kode di dalam perulangan akan terus dijalankan. Perulangan while berguna ketika
tidak tahu pasti berapa kali perulangan akan dilakukan, tetapi memiliki kondisi yang harus
dipenuhi agar perulangan berhenti.
3.3.1 For loop
For loop digunakan ketika jumlah iterasi yang diperlukan sudah diketahui atau dapat ditentukan
sebelumnya. Struktur ini memungkinkan program untuk menjalankan blok kode berulang kali
untuk setiap elemen dalam sebuah urutan, seperti list, tuple, atau rentang angka. For loop berguna
untuk situasi di mana jumlah iterasi ditentukan secara eksplisit, seperti saat mengiterasi elemen
dalam array atau melakukan perhitungan dengan rentang angka tertentu.

for i in range(5):
print("Iterasi ke-", i)

3.3.2 While loop

While loop menjalankan blok kode selama kondisi yang diberikan bernilai benar (True), dan
berhenti hanya ketika kondisi tersebut tidak lagi memenuhi syarat. Struktur ini efisien dalam
situasi di mana jumlah iterasi tidak dapat ditentukan sebelumnya atau bervariasi berdasarkan
keadaan yang dinamis. Misalnya, while loop sering digunakan untuk pemrosesan data yang
memerlukan pengulangan hingga kondisi tertentu tercapai, seperti membaca input dari pengguna
sampai nilai yang valid diterima, atau terus melakukan operasi hingga batas tertentu dipenuhi.

hitungan = 0

while hitungan < 5:

print("Hitungan adalah", hitungan)
hitungan += 1

3.3.3 Nested loop

Nested loop atau perulangan bersarang dalam Python adalah sebuah konstruksii
pemrograman di mana satu perulangan (loop) berada di dalam perulangan lainnya. Nested loop
memungkinkan melakukan iterasi pada struktur data multi-dimensi atau menjalankan serangkaian
tindakan yang berulang secara bersusun. Setiap kali perulangan luar selesai satu kali, perulangan
dalam akan berjalan hingga selesai untuk semua elemen pada baris tersebut sebelum melanjutkan
ke baris berikutnya.

27
 for i in range(3):
for j in range(3):
print(f"i={i}, j={j}")

Nested loop dengan nested if-else merupakan dua konstruksi yang berbeda untuk membuat
struktur kode yang lebih kompleks. Nested loops digunakan untuk mengulang suatu blok kode
secara berulang untuk setiap elemen dalam beberapa urutan, menciptakan pola atau mengolah data
multi-dimensi. Sebaliknya, nested if-else digunakan untuk membuat keputusan berdasarkan
beberapa kondisi yang saling berkaitan. Jika suatu kondisi terpenuhi, maka blok kode di dalamnya
akan dijalankan, dan percabangan lainnya akan diabaikan. Singkatnya, nested loop berfokus pada
pengulangan, sedangkan nested if-else berfokus pada pengambilan keputusan.
3.3.4 Statement break
Perintah break berfungsi sebagai mekanisme untuk menghentikan secara paksa eksekusi
perulangan saat kondisi tertentu terpenuhi. Ketika interpreter Python menemukan pernyataan
break di dalam sebuah loop, ia akan segera keluar dari loop tersebut dan melanjutkan eksekusi
kode yang berada di luar blok loop. Hal ini berguna saat ingin menghentikan perulangan sebelum
semua iterasi selesai, misalnya ketika suatu kondisi tertentu sudah terpenuhi atau ketika data yang
dicari telah ditemukan.

x = 1
while x <= 5:
if x == 3:
break # Keluar dari loop
print(x)
x += 1

for x in range(1, 5):

if x == 3:
break # Keluar dari loop
print(x)

Kedua potongan kode di atas memiliki fungsi yang sama yaitu mencetak bilangan dari 1 sampai
5, namun menggunakan pendekatan perulangan yang berbeda. Kode pertama menggunakan
perulangan while dan akan terus berjalan selama x masih kurang dari atau sama dengan 5.
Sedangkan, kode kedua menggunakan fungsi range(1, 5) untuk iterasi dari bilangan 1 sampai 4
(tidak termasuk 5). Pernyataan break dalam kedua kode di atas berfungsi sebagai "pemutus" yang

28
menghentikan proses perulangan secara prematur ketika kondisi tertentu terpenuhi. Dalam kasus
ini, kondisi tersebut adalah ketika nilai variabel x sama dengan 3. Kedua kode menghasilkan output
yang sama yaitu 1 dan 2.

3.4 Latihan

1) Buat suatu program untuk melakukan konversi nilai akhir kuliah dari angka ke huruf
dengan ketentuan berikut.
• A : 100 - 90.01
• A- : 90 - 85.01
• B : 85 - 75.01
• B-: 75 - 65.01
• C : 65 - 55.01
• D : 55 - 44.01
• E : 44 – 0
2) Buat program yang menerima suatu bilangan. Jika bilangan tersebut hanya merupakan
kelipatan 3, tuliskan dor. Jika bilangan tersebut hanya merupakan kelipatan 5, tuliskan
rong. Jika bilangan tersebut merupakan kelipatan 3 dan 5, tuliskan dorong. Selain kondisi
tersebut, tuliskan bebas.
3) Tampilkan semua bilangan asli dan ganjil yang kurang dari 10.
4) Buatlah gambar segitiga menggunakan karakter * berdasarkan masukan tinggi dari
pengguna. Luaran contoh sebagai berikut.
# Tinggi 1

*
** # Tinggi 2

*
**
*** # Tinggi 3

29
3.5 Tugas

Studi Kasus Sistem Pendaftaran Kursus Online

• Deskripsi kasus
Anda bekerja sebagai pengembang perangkat lunak untuk platform pendaftaran
kursus online. Platform ini menawarkan berbagai kursus kepada pengguna, dan Anda perlu
membuat sistem yang dapat mengelola pendaftaran kursus dengan beberapa aturan
tertentu.
• Permintaan
1) Pendaftaran Kursus
a. Setiap pengguna dapat mendaftar untuk kursus yang mereka minati. Setiap kursus
memiliki batas kuota, dan pendaftaran hanya diterima jika kuota masih tersedia.
b. Gunakan if-else statement untuk memeriksa apakah kuota kursus masih mencukupi
dan apakah pengguna sudah mendaftar untuk kursus lain pada waktu yang
bersamaan. Jika kondisi-kondisi ini terpenuhi, izinkan pendaftaran; jika tidak, tolak
pendaftaran dan beri tahu pengguna alasan penolakan.
2) Tampilan Status Pendaftaran
a. Tampilkan status pendaftaran pengguna setelah mereka mencoba mendaftar.
Gunakan for loop untuk mengiterasi melalui daftar kursus yang tersedia dan
menampilkan informasi kursus yang telah diambil pengguna serta kursus yang
masih bisa didaftarkan.
b. Misalkan setiap pengguna dapat mendaftar untuk maksimum 3 kursus sekaligus.
Gunakan while loop untuk terus meminta input pengguna untuk memilih kursus
hingga mereka mencapai batas maksimum atau memilih untuk berhenti.

30
 BAB IV
FUNGSI DAN PROSEDUR
4.1 Pengantar

Pada bab ini akan membahas mengenai konsep fungsi dan prosedur dalam pemrograman, yang
merupakan lanjutan dari pembahasan sebelumnya tentang struktur kontrol. Struktur kontrol
memberikan dasar untuk memahami bagaimana alur program dapat dikendalikan berdasarkan
kondisi tertentu, sedangkan fungsi dan prosedur berperan penting dalam modularisasi program,
memungkinkan penyusunan kode yang lebih terstruktur, efisien, dan mudah dipelihara.

Dalam bahasa Python, baik fungsi maupun prosedur memiliki struktur dasar yang serupa, di
mana keduanya diawali dengan kata kunci `def` diikuti dengan nama yang diberikan untuk fungsi
atau prosedur tersebut. Meskipun secara sintaksis keduanya sama, perbedaan mendasar terletak
pada penggunaannya: fungsi digunakan ketika diperlukan hasil pengolahan atau perhitungan untuk
dikembalikan, sementara prosedur digunakan untuk menjalankan serangkaian instruksi tanpa perlu
mengembalikan hasil apapun. Dengan kata lain, dalam konteks Python, apakah suatu blok kode
disebut fungsi atau prosedur lebih ditentukan oleh ada tidaknya pernyataan `return` yang
mengembalikan nilai. Pendekatan ini menjadikan Python lebih fleksibel dan sederhana dalam
penulisan kode, tanpa harus membedakan secara eksplisit antara fungsi dan prosedur, tetapi tetap
menjaga kejelasan peran dari masing-masing blok kode tersebut.

4.2 Struktur data fungsi

Fungsi adalah suatu blok program yang dapat dipanggil berulang kali menggunakan nama yang
didefinisikan. Struktur data fungsi terdiri dari beberapa elemen kunci:

1. Nama fungsi, yaitu identifikator unik yang digunakan untuk memanggil fungsi.
2. Paramater, adalah variabel yang menerima nilai saat fungsi dipanggil (bersifat opsional).
3. Blok kode, yaitu serangkaian instruksi yang dieksekusi saat fungsi dipanggil.
4. Pernyataan return, untuk menentukan nilai yang dikembalikan oleh fungsi (bersifat
opsional, namun umum digunakan).

31
 def nama_fungsi(parameter1, parameter2):
# Blok kode
# Melakukan operasi
return hasil # Nilai yang dikembalikan

Fungsi dapat memiliki parameter dengan nilai default, yang memungkinkan pemanggilan
fungsi tanpa menyediakan semua argumen. Python juga mendukung fungsi dengan jumlah
argumen yang bervariasi menggunakan *args dan **kwargs. Berikut merupakan contoh fungsi
yang lebih kompleks.

def hitung_luas_persegi_panjang(panjang, lebar=1):

"""
Menghitung luas persegi panjang.

:param panjang: panjang persegi panjang

:param lebar: lebar persegi panjang (default 1)
:return: luas persegi panjang
"""
luas = panjang * lebar
return luas

# Pemanggilan fungsi
print(hitung_luas_persegi_panjang(5, 3)) # Output: 15
print(hitung_luas_persegi_panjang(4)) # Output: 4 (menggunakan lebar default)

4.3 Struktur data prosedur

Dalam Python, tidak ada perbedaan sintaksis antara fungsi dan prosedur. Prosedur pada
dasarnya adalah fungsi yang tidak mengembalikan nilai (atau secara implisit mengembalikan
None). Struktur prosedur mirip dengan fungsi, tetapi biasanya tidak menggunakan pernyataan
return untuk nilai.

Perbedaan utama antara fungsi dan prosedur terletak pada tujuan dan hasil yang
diharapkan. Fungsi dirancang untuk melakukan perhitungan atau operasi dan mengembalikan
hasil, sementara prosedur biasanya digunakan untuk melakukan tindakan atau efek samping
(seperti mencetak output atau memodifikasi data).

32
def cetak_info_mahasiswa(nama, nim, jurusan):
"""
Mencetak informasi mahasiswa.

:param nama: nama mahasiswa

:param nim: nomor induk mahasiswa
:param jurusan: jurusan mahasiswa
"""
print(f"Nama : {nama}")
print(f"NIM : {nim}")
print(f"Jurusan : {jurusan}")

# Pemanggilan prosedur
cetak_info_mahasiswa("Budi Santoso", "12345", "Informatika")

# Contoh penggunaan fungsi dan prosedur bersama

def hitung_rata_rata(nilai):
"""
Menghitung rata-rata dari list nilai.

:param nilai: list nilai

:return: rata-rata nilai
"""
total = sum(nilai)
return total / len(nilai)

def cetak_hasil(nama, nilai, rata_rata):

"""
Mencetak hasil nilai dan rata-rata.

:param nama: nama siswa

:param nilai: list nilai
:param rata_rata: rata-rata nilai
"""
print(f"Nama: {nama}")
print(f"Nilai: {nilai}")
print(f"Rata-rata: {rata_rata:.2f}")

# Penggunaan fungsi dan prosedur

nilai_siswa = [85, 90, 78, 92, 88]
rata_rata = hitung_rata_rata(nilai_siswa)
cetak_hasil("Ani", nilai_siswa, rata_rata)

33
 Dalam contoh di atas, hitung_rata_rata adalah fungsi yang mengembalikan nilai, sementara
cetak_hasil adalah prosedur yang hanya mencetak informasi tanpa mengembalikan nilai. Dalam
praktiknya, pemilihan antara fungsi dan prosedur tergantung pada kebutuhan spesifik program:

• Gunakan fungsi ketika diperlukan menghitung dan mengembalikan nilai yang akan
digunakan di bagian lain program.
• Gunakan prosedur ketika ingin melakukan serangkaian tindakan tanpa perlu
mengembalikan nilai.

4.4 Variabel lokal dan global

4.4.1 Variabel lokal
Variabel lokal adalah variabel yang didefinisikan di dalam suatu fungsi atau blok kode tertentu.
Mereka hanya dapat diakses dari dalam fungsi atau blok kode tersebut. Variabel lokal memiliki
beberapa karakteristik penting, yaitu:

1. Ruang lingkup terbatas pada fungsi di mana mereka didefinisikan.

2. Dibuat saat fungsi dipanggil dan dihapus setelah fungsi selesai dieksekusi.
3. Tidak dapat diakses dari luar fungsi.

def hitung_luas_lingkaran(radius):
pi = 3.14159 # Variabel lokal
luas = pi * radius ** 2
return luas

print(hitung_luas_lingkaran(5)) # Output: 78.53975

# print(pi) # Ini akan menyebabkan error karena pi adalah variabel lokal

4.4.2 Variabel global

Variabel global adalah variabel yang didefinisikan di luar semua fungsi dan dapat diakses dari
seluruh bagian program. Karakteristik variabel global meliputi:

1. Dapat diakses dan dimodifikasi dari mana saja dalam program.

2. Memiliki masa hidup sepanjang program berjalan.
3. Dapat menyebabkan masalah jika tidak dikelola dengan baik.

34
 pi = 3.14159 # Variabel global

def hitung_luas_lingkaran(radius):
global pi # Mendeklarasikan penggunaan variabel global
luas = pi * radius ** 2
return luas

def ubah_pi():
global pi
pi = 3.14 # Mengubah nilai variabel global

print(hitung_luas_lingkaran(5)) # Output: 78.53975

ubah_pi()
print(hitung_luas_lingkaran(5)) # Output: 78.5

4.5 Pemanggilan fungsi dan prosedur

Pemanggilan fungsi dan prosedur dalam Python dilakukan dengan menyebutkan nama fungsi
atau prosedur diikuti dengan tanda kurung yang berisi argumen (jika ada). Perbedaan utama dalam
pemanggilan adalah bahwa hasil fungsi biasanya disimpan atau digunakan, sementara prosedur
hanya dijalankan untuk efeknya.

def tambah(a, b): # Definisi fungsi

return a + b

hasil = tambah(3, 4)
print(hasil) # Output: 7

# Pemanggilan fungsi sebagai bagian dari ekspresi

print(tambah(2, tambah(3, 4))) # Output: 9

def cetak_garis(): # Definisi prosedur

print("-" * 20)

cetak_garis() # Pemanggilan prosedur menghasilkan output: ----------------------

def sapa(nama):
print(f"Halo, {nama}!")

sapa("Alice") # Output: Halo, Alice!

35
4.6 Prosedur dengan parameter by value dan by reference

Dalam pemrograman, ada dua cara utama untuk mengirim argumen ke fungsi atau prosedur
yaitu by value dan by reference.
4.6.1 By value
Ketika argumen dikirim by value, sebuah salinan dari nilai argumen dibuat dan diteruskan
ke fungsi. Perubahan pada parameter di dalam fungsi tidak mempengaruhi variabel asli di luar
fungsi. Di Python, tipe data yang tidak dapat diubah (immutable) seperti integer, float, string, dan
tuple secara efektif diteruskan by value.

def ubah_nilai(x):
x = 100
print("Nilai x di dalam fungsi:", x)

a = 50
ubah_nilai(a)
print("Nilai a di luar fungsi:", a)

# Output:
# Nilai x di dalam fungsi: 100
# Nilai a di luar fungsi: 50

4.6.2 By reference
Ketika argumen dikirim by reference, referensi ke objek asli diteruskan ke fungsi. Perubahan
pada parameter di dalam fungsi akan mempengaruhi objek asli. Di Python, tipe data yang dapat
diubah (mutable) seperti list, dictionary, dan set secara efektif diteruskan by reference.

def ubah_list(lst):
[Link](4)
print("List di dalam fungsi:", lst)

my_list = [1, 2, 3]
ubah_list(my_list)
print("List di luar fungsi:", my_list)

# Output:
# List di dalam fungsi: [1, 2, 3, 4]
# List di luar fungsi: [1, 2, 3, 4]

36
4.7 Fungsi bawaan (built-in function)

Python menyediakan sejumlah fungsi bawaan yang dapat digunakan tanpa perlu mengimpor
modul tambahan. Fungsi-fungsi ini mencakup berbagai operasi umum dan sangat berguna dalam
pemrograman sehari-hari. Beberapa contoh fungsi bawaan yang sering digunakan:

• print(): Mencetak output ke konsol.

• len(): Mengembalikan panjang objek (string, list, dll).
• type(): Mengembalikan tipe objek.
• int(), float(), str(): Mengubah tipe data.
• max(), min(): Mencari nilai maksimum dan minimum.
• sum(): Menjumlahkan semua elemen dalam iterable.
• range(): Menghasilkan urutan angka.

# Menggunakan beberapa fungsi bawaan

numbers = [1, 2, 3, 4, 5]
print("Panjang list:", len(numbers))
print("Nilai maksimum:", max(numbers))
print("Jumlah semua elemen:", sum(numbers))

# Mengubah tipe data

x = "10"
y = int(x) + 5
print("Hasil konversi dan penjumlahan:", y)

# Menggunakan range
for i in range(5):
print(i, end=" ")

Fungsi bawaan bertujuan untuk membantu dalam menulis kode yang efisien dan mudah dibaca.
Mereka menyediakan fungsionalitas umum tanpa perlu menulis implementasi sendiri.

4.8 Fungsi rekursif

Fungsi rekursif adalah suatu fungsi yang memanggil fungsi tersebut dalam pendefinisian
fungsi itu sendiri. Salah satu keunggulan fungsi rekursif adalah kesederhanaan dalam
pendefinisian fungsi tersebut. Contoh yang termasuk fungsi rekursif adalah faktorial dimana n! =
n × (n − 1)!.

37
 def faktorial(n):
assert n >=1
if n == 1:
return 1
else:
return n * faktorial(n-1)
print(faktorial(5)) # Output: 120

Dalam mendefinisikan fungsi rekursif, perlu diperhatikan dua hal. Pertama adalah basis
dimana kondisi rekursif itu berhenti, dalam contoh faktorial adalah ketika n = 1. Kedua adalah
bagian rekurens yaitu pemanggilan kembali fungsi tersebut dengan kondisi data konvergen dari
pemanggilan awal menuju ke basis, dalam contoh faktorial adalah berkurangnya nilai n yang
mengarah ke n = 1.

Contoh lainnya adalah fungsi rekursif untuk menghitung angka Fibonacci.

def fibonacci(n):
if n <= 1: # Kasus dasar
return n
else: # Kasus rekursif
return fibonacci(n-1) + fibonacci(n-2)

for i in range(10):
print(fibonacci(i), end=" ") # Output: 0 1 1 2 3 5 8 13 21 34

4.9 Modularitas program

Modularitas adalah konsep penting dalam pengembangan perangkat lunak yang melibatkan
pembagian program menjadi modul-modul atau komponen-komponen yang lebih kecil dan
independen. Fungsi dan prosedur adalah alat utama untuk mencapai modularitas dalam
pemrograman. Keuntungan modularitas, yaitu:

1. Meningkatkan keterbacaan kode

2. Memudahkan pemeliharaan dan debugging
3. Memungkinkan penggunaan kembali kode
4. Memfasilitasi pengembangan paralel oleh tim

38
 def baca_data():
"""Membaca data dari pengguna."""
nama = input("Masukkan nama: ")
usia = int(input("Masukkan usia: "))
return nama, usia

def hitung_tahun_pensiun(usia, usia_pensiun=65):

"""Menghitung tahun sampai pensiun."""
return usia_pensiun - usia

def tampilkan_hasil(nama, usia, tahun_ke_pensiun):

"""Menampilkan hasil perhitungan."""
print(f"\nHasil Analisis untuk {nama}:")
print(f"Usia saat ini: {usia} tahun")
print(f"Tahun sampai pensiun: {tahun_ke_pensiun} tahun")

def main():
"""Fungsi utama program."""
nama, usia = baca_data()
tahun_ke_pensiun = hitung_tahun_pensiun(usia)
tampilkan_hasil(nama, usia, tahun_ke_pensiun)

# Menjalankan program
main()

Dalam contoh kode program di atas, baca_data() bertanggung jawab untuk input pengguna.
Fungsi hitung_tahun_pensiun() melakukan perhitungan. Fungsi tampilkan_hasil() menangani
output. Terakhir, fungsi main() mengkoordinasikan alur program keseluruhan.

Menggunakan pendekatan modular memiliki beberapa keuntungan yaitu, setiap fungsi

memiliki tugas spesifik sehingga meningkatkan keterbacaan. Fungsi-fungsi dapat diuji secara
terpisah yang dapat memudahkan debugging. Fungsi seperti hitung_tahun_pensiun() dapat
digunakan kembali di bagian lain program atau bahkan di program lain. Selain itu, perubahan pada
satu fungsi (misalnya, mengubah cara menampilkan hasil) tidak mempengaruhi fungsi lain.

39
4.10 Latihan

1) Buat fungsi yang mengembalikan nilai penjumlahan seluruh bilangan asli kurang dari 10.
2) Himpunan bilangan asli kurang dari 10 yang merupakan kelipatan 3 atau 5 adalah 3,5,6,9.
Jumlah seluruh bilangan tersebut adalah 23. Hitung jumlah seluruh bilangan asli yang
merupakan kelipatan 3 atau 5 dan kurang dari 1000.
3) Buatlah fungsi pangkat dari x^y , tanpa menggunakan operator primitif pangkat dari
Python.
4) Buatlah sebuah program yang mendemonstrasikan perbedaan antara parameter by value
dan by reference. Program harus memiliki fungsi ubah_nilai(x) yang mencoba mengubah
nilai parameter (untuk tipe data immutable), fungsi ubah_list(lst) yang mengubah isi list
(untuk tipe data mutable), dan fungsi main yang mendemonstrasikan pemanggilan kedua
fungsi tersebut dan menampilkan hasilnya.
5) Buatlah sebuah program analisis teks sederhana yang terdiri dari tiga modul Python
terpisah: input_teks.py untuk membaca input teks dari pengguna, analisis_teks.py yang
berisi fungsi-fungsi untuk menghitung jumlah kata, jumlah karakter, dan menemukan kata
terpanjang dalam teks, serta [Link] yang mengintegrasikan kedua modul tersebut untuk
membaca input, melakukan analisis, dan menampilkan hasilnya. Pastikan untuk
menggunakan fungsi-fungsi bawaan Python yang relevan dalam implementasi Anda, dan
terapkan prinsip modularitas untuk memisahkan fungsionalitas ke dalam modul-modul
yang berbeda.

4.11 Tugas

Studi kasus Sistem Manajemen Tugas Sederhana

• Deskripsi Tugas
Anda diminta untuk membuat sebuah sistem manajemen tugas sederhana untuk membantu
siswa mengorganisir tugas-tugas mereka. Program ini harus memiliki fitur-fitur berikut:
a. Menambah tugas baru
b. Menampilkan daftar tugas
c. Menandai tugas sebagai selesai
d. Menghapus tugas

40
 e. Mencari tugas berdasarkan kata kunci
f. Menampilkan statistik tugas (jumlah total, selesai, belum selesai)
• Persyaratan
a. Gunakan fungsi untuk setiap operasi utama.
b. Implementasikan setidaknya satu fungsi rekursif (misalnya, untuk pencarian).
c. Gunakan variabel global untuk menyimpan daftar tugas.
d. Terapkan konsep parameter by value dan by reference.
e. Manfaatkan fungsi bawaan Python yang relevan.
f. Buat program modular dengan memisahkan fungsionalitas ke dalam minimal dua
modul.

41
 BAB V
KOLEKSI DATA DAN MATRIKS
5.1 Pengantar

Pada bab sebelumnya mengenai fungsi dan prosedur, telah dijelaskan bagaimana komponen-
komponen tersebut dapat digunakan untuk mengorganisir dan mengelola kode secara lebih efektif.
Fungsi dan prosedur memungkinkan pemrogram untuk menyusun kode dalam blok-blok yang
dapat digunakan kembali dan mudah dipahami. Dalam konteks koleksi data, pemahaman tentang
bagaimana data dikelompokkan dan diakses sangat penting, karena hal ini mempengaruhi cara
fungsi dan prosedur beroperasi pada data tersebut.

Bab ini akan membahas koleksi data dan konsep matriks sebagai jenis struktur data yang
penting. Koleksi data merupakan elemen fundamental dalam pengelolaan dan manipulasi
informasi dalam pemrograman, menyediakan berbagai struktur seperti list, tuple, dictionary, dan
set yang memungkinkan pengelompokan dan pengorganisasian data secara efisien. Struktur ini
mendukung berbagai operasi seperti penyimpanan, akses, dan modifikasi data yang
memungkinkan pemrogram untuk menangani informasi dalam berbagai konteks.

Selain itu, bab ini juga akan mengeksplorasi matriks, yaitu struktur data berbentuk tabel yang
terdiri dari baris dan kolom. Matriks merupakan bentuk koleksi data yang khusus digunakan untuk
menyimpan data dalam format dua dimensi, dan seringkali digunakan dalam aplikasi yang
memerlukan representasi data dalam bentuk grid atau tabel, seperti dalam pengolahan citra, aljabar
linier, dan perhitungan numerik. Pembahasan mengenai matriks akan mencakup cara
mendefinisikan, mengakses, serta melakukan operasi dasar seperti perkalian dan penjumlahan
matriks, sehingga memberikan pemahaman yang lebih mendalam tentang bagaimana matriks
dapat diterapkan dalam berbagai situasi pemrograman.

5.2 Koleksi data

Koleksi data dalam konteks pemrograman merujuk pada struktur atau objek yang digunakan
untuk menyimpan dan mengelola sekelompok data yang biasanya memiliki tipe atau fungsi yang
serupa. Koleksi data memungkinkan pengelompokan beberapa item, sehingga mereka dapat
diakses, dimodifikasi, dan diproses secara efisien. Koleksi data sangat penting dalam

42
pemrograman karena membantu dalam organisasi dan manipulasi data yang kompleks dengan cara
yang lebih mudah dan terstruktur.

Koleksi data digunakan dalam berbagai konteks pemrograman, seperti menyimpan data pengguna
dalam sebuah aplikasi, mengelola data yang dihasilkan dari hasil pencarian yang berasal dari mesin
pencari, dan menganalisis data dalam bentuk tabel atau matriks. Beberapa jenis koleksi data di
Python adalah list, tuple, dictionary, dan set.

5.3 List, tuple, dictionary, dan set

5.3.1 List
List adalah struktur data yang menyimpan koleksi terurut setiap elemennya. Definisi list di
Python menggunakan tanda kurung siku []. Setelah suatu list terdefinisi, list tersebut dapat
ditambah, dihapus, atau dicari elemen list tersebut.

daftar_belanja = ['Apel', 'Mangga', 'Jeruk', 'Pisang']

print('Terdapat %d barang dalam daftar belanja saya.' %
(len(daftar_belanja)))
print('Barang-barang tersebut adalah ')
for barang in daftar_belanja:
print(barang)

print('Saya juga harus membeli beras.')

daftar_belanja.append('Beras')
print('Daftar belanja saya sekarang menjadi ', daftar_belanja)
print('Saya harus mengurutkan daftar saya sebelum mulai belanja')
daftar_belanja.sort()
print('Saya mulai belanja dengan urutan daftar berikut',
daftar_belanja)
barang_dibeli = daftar_belanja[0]
del(daftar_belanja[0])
print('Barang pertama ', barang_dibeli, 'sudah terbeli.')
print('Barang yang masih harus dibeli adalah ', daftar_belanja)

5.3.2 Tuple
Tuple mirip dengan list, hanya saja memiliki sifat immutable serupa dengan String yaitu
tidak bisa mengubah datanya. Definisi tuple di Python menggunakan tanda kurung biasa ().
Sebagai contoh adalah argumen masukan dari fungsi print().

43
 daftar_siswa = ('Andi', 'Budi', 'Citra', 'Dani')
print('Nama siswa yang sering dipakai adalah ')
for siswa in daftar_siswa:
print(siswa)
print('Siswa paling populer di kelas adalah ', siswa[1])
# [Link]('Endah') # error
# del(siswa[0]) # error

print('Tiga angka pertama adalah %d, %d, dan %d.' % (1,2,3))

5.3.3 Dictionary
Dictionary serupa dengan kamus dimana suatu key berasosiasi dengan value. Key dalam
dictionary harus bersifat unik dimana hanya terdapat tepat satu key sehingga tidak
membingungkan dalam pengaksesan koleksi tersebut. Definisi dictionary di Python menggunakan
tanda kurung kurawal {}. Pasangan key dan value dideklarasikan dengan notasi d =
{key1: value1, key2: value2} dengan catatan bahwa setiap pasangan tidak memiliki urutan dalam
suatu dictionary.

kota_asal_siswa = {'Andi': 'Malang',

'Budi': 'Surabaya',
'Citra': 'Blitar',
'Dani': 'Jakarta'
}
print('Terdapat %d data siswa dan kota asalnya.' % (len(kota_asal_siswa)))
print('Data tersebut adalah sebagai berikut.')
for siswa, kota in kota_asal_siswa.items():
print('%s berasal dari %s.' % (siswa, kota))

5.3.4 Set
Set adalah koleksi data yang tidak berurutan dan tidak mengizinkan elemen duplikat (bersifat
unik). Dalam set, urutan elemen tidak diperhatikan dan setiap elemen harus unik. Karena elemen
tidak berurutan, maka tidak dapat mengakses elemen menggunakan indeks seperti yang bisa
dilakukan pada list atau tuple. Set juga sangat efisien untuk melakukan operasi seperti
penggabungan, perbedaan, dan irisan.

44
# Membuat set
set_a = {1, 2, 3}
set_b = {3, 4, 5}

# Menampilkan set
print("Set A:", set_a)
print("Set B:", set_b)

# Menambahkan elemen ke set

set_a.add(4)
print("\nSet A setelah menambahkan 4:", set_a)

# Menghapus elemen dari set

set_a.remove(1)
print("Set A setelah menghapus 1:", set_a)

# Operasi union (gabungan)

union_set = set_a.union(set_b)
print("\nUnion Set (Set A | Set B):", union_set)

# Operasi intersection (irisan)

intersection_set = set_a.intersection(set_b)
print("Intersection Set (Set A & Set B):", intersection_set)

Struktur data Perbedaan utama Manfaat

List Bersifat mutable, bisa dimodifikasi Cocok untuk kumpulan item

setelah dibuat. yang perlu diubah.

Tuple Bersifat immutable, tidak bisa Berguna untuk data yang tidak
dimodifikasi setelah dibuat. boleh berubah, seperti koordinat.

Dictionary Menyimpan pasangan key-value Efisien untuk pencarian

dan tidak berurutan. berdasarkan key.

Set Tidak berurutan, bersifat mutable, Berguna untuk menyimpan data

dan tidak mengizinkan duplikat dengan label, menyimpan
(bersifat unik). informasi terkait dalam struktur
yang terorganisir.

45
5.4 Matriks

Matriks adalah array dua dimensi yang terdiri dari baris dan kolom. Setiap elemen dalam
matriks diidentifikasi oleh dua indeks, yaitu indeks baris dan indeks kolom. Matriks digunakan
dalam berbagai bidang seperti matematika, ilmu komputer, fisika, dan teknik untuk memodelkan
data dan melakukan perhitungan yang kompleks. Pada lingkup Python, matriks biasanya
direpresentasikan menggunakan list of lists. Setiap elemen dalam list utama adalah list lain yang
merepresentasikan baris dari matriks.

# Matriks 2x3 (2 baris, 3 kolom)

matrix = [
[1, 2, 3],
[4, 5, 6]
]

Untuk mengeluarkan output matriks dalam bentuk yang terstruktur, seperti matriks pada
umumnya digunakan loop untuk menampilkan setiap baris matriks secara terpisah.

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

# Tampilkan matriks
for baris in matriks:
print(baris)

Sehingga output dari kode program di atas berupa:

[1, 2, 3]

[4, 5, 6]

[7, 8, 9]
5.4.1 Membuat matriks dari kosong
Dalam pemrograman, sering kali diperlukan untuk membuat sebuah matriks kosong yang
kemudian dapat diisi atau dimodifikasi sesuai kebutuhan. Matriks kosong dapat diinisialisasi
dengan ukuran tertentu, tetapi semua elemennya diatur ke nilai awal, seperti nol. Proses ini dikenal

46
sebagai inisialisasi matriks. Setelah matriks diinisialisasi, elemen-elemennya dapat diubah atau
diperbarui sesuai dengan operasi atau data yang ingin dimasukkan.

1. Inisialisasi matriks
Inisialisasi matriks berarti membuat sebuah matriks dengan ukuran tertentu dan
mengatur semua elemennya ke nilai awal, misalnya 0. Dalam Python, inisialisasi matriks
dapat dilakukan dengan menggunakan list comprehension atau menggunakan pustaka
numpy untuk efisiensi dan kemudahan. Berikut adalah contoh inisialisasi matriks 3x3
menggunakan list comprehension yang menghasilkan matriks 3x3 dengan seluruh elemen
bernilai 0.
# Inisialisasi matriks 3x3 dengan elemen nol
matriks = [[0 for _ in range(3)] for _ in range(3)]

# Menampilkan matriks yang telah diinisialisasi

for baris in matriks:
print(baris)

Pada kode di atas, terdapat variabel underscore (“_”) digunakan sebagai

placeholder dalam Python ketika nilai atau hasilnya tidak penting. Baris for _ in
range(3) mengulangi blok kode sebanyak tiga kali. Karena nilai indeks dari perulangan
tidak digunakan di dalam loop, “_” digunakan sebagai nama variabel untuk menunjukkan
bahwa iterasi tersebut hanya diperlukan untuk melakukan perulangan tanpa
memperhatikan nilainya.
2. Mengubah elemen matriks
Setelah matriks diinisialisasi, elemen-elemennya dapat diubah dengan
mengaksesnya menggunakan indeks baris dan kolom. Sebagai contoh, jika ingin mengubah
elemen pada baris pertama dan kolom kedua dari matriks yang telah diinisialisasi di atas,
kode berikut dapat digunakan.
# Mengubah elemen pada baris pertama, kolom kedua menjadi 5
matriks[0][1] = 5

# Menampilkan matriks setelah perubahan

for baris in matriks:
print(baris)

47
 Setelah mengubah elemen, matriks akan menjadi seperti berikut ini.

[0, 5, 0]

[0, 0, 0]

[0, 0, 0]

3. Inisialisasi Matriks Menggunakan Numpy

Selain menggunakan list comprehension, inisialisasi matriks dan mengubah elemen
juga dapat dilakukan dengan menggunakan pustaka numpy yang lebih efisien untuk operasi
matriks, terutama ketika menangani data berukuran besar.
import numpy as np

# Inisialisasi matriks 3x3 dengan elemen nol menggunakan numpy

matriks = [Link]((3, 3))

# Menampilkan matriks yang telah diinisialisasi

print(matriks)

# Mengubah elemen pada baris pertama, kolom kedua menjadi 5

matriks[0][1] = 5

# Menampilkan matriks setelah perubahan

print(matriks)

5.4.2 Operasi dasar matriks

1. Penjumlahan matriks
Penjumlahan matriks adalah operasi di mana dua matriks yang memiliki dimensi
yang sama dijumlahkan dengan menjumlahkan elemen-elemen yang bersesuaian dari
kedua matriks tersebut.

48
 # Matriks A dan B
A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]

# Penjumlahan matriks
C = [[A[i][j] + B[i][j] for j in range(2)] for i in range(2)]

# Tampilkan hasil
for baris in C:
print(baris)

2. Perkalian matriks
Perkalian matriks adalah salah satu operasi matematika dasar yang sering digunakan
dalam berbagai aplikasi, mulai dari grafika komputer hingga analisis data. Dua bentuk
utama dari operasi perkalian yang sering dibahas dalam konteks matriks adalah dot product
(hasil kali titik) dan cross product (hasil kali silang). Keduanya memiliki kegunaan yang
berbeda dan berlaku dalam konteks yang berbeda pula.
a. Dot product (Hasil Kali Titik)

Dot product adalah operasi yang dilakukan pada dua vektor dengan panjang
yang sama, di mana setiap elemen yang bersesuaian dikalikan, kemudian hasil-hasil
tersebut dijumlahkan. Dalam konteks matriks, dot product dapat digunakan untuk
menghitung elemen dari hasil kali matriks dengan mengalikan baris dari matriks
pertama dengan kolom dari matriks kedua.

Jika terdapat dua vektor A dan B masing-masing dengan elemen 𝑎1 , 𝑎2 , 𝑎3

dan 𝑏1 , 𝑏2 , 𝑏3 , maka rumusnya dideskripsikan sebagai berikut.

𝐷𝑜𝑡 𝑃𝑟𝑜𝑑𝑢𝑐𝑡 = 𝐴. 𝐵 = 𝑎1 × 𝑏1 + 𝑎2 × 𝑏2 + 𝑎3 × 𝑏3

49
 # Definisikan dua vektor
vektor_a = [1, 2, 3]
vektor_b = [4, 5, 6]

# Inisialisasi hasil dot product

dot_product = 0

# Hitung dot product secara manual

for i in range(len(vektor_a)):
dot_product += vektor_a[i] * vektor_b[i]

# Tampilkan hasil
print(dot_product)

Pada kode program di atas, iterasi dilakukan melalui setiap elemen dari
kedua vektor, mengalikan elemen yang bersesuaian, dan menjumlahkannya untuk
mendapatkan hasil akhir.
b. Cross product (hasil kali silang)
Cross product berlaku untuk dua vektor dalam ruang tiga dimensi dan
menghasilkan sebuah vektor baru yang tegak lurus terhadap kedua vektor asli. Jika
ada dua vektor A dan B dengan komponen 𝑎1 , 𝑎2 , 𝑎3 dan 𝑏1 , 𝑏2 , 𝑏3 , maka cross
product 𝐶 = 𝐴 × 𝐵 adalah:

𝐶1 = 𝑎2 × 𝑏3 − 𝑎3 × 𝑏2 , 𝐶2 = 𝑎3 × 𝑏1 − 𝑎1 × 𝑏3 , 𝐶3 = 𝑎1 × 𝑏2 − 𝑎2 × 𝑏1.

# Definisikan dua v dalam 3D

v_a = [1, 2, 3]
v_b = [4, 5, 6]

# Inisialisasi hasil cross product

cross_product = [0, 0, 0]

# Hitung cross product secara manual

cross_product[0] = v_a[1] * v_b[2] - v_a[2] * v_b[1]
cross_product[1] = v_a[2] * v_b[0] - v_a[0] * v_b[2]
cross_product[2] = v_a[0] * v_b[1] - v_a[1] * v_b[0]

# Tampilkan hasil
print(cross_product)

50
 Cross product dihitung dengan menggunakan rumus determinan,
menghasilkan sebuah vektor yang baru dengan elemen-elemen yang dihitung dari
komponen-komponen kedua vektor asli.
Jika ingin menghitung cross product dengan cara yang lebih mudah dan
lebih aman dari kesalahan manual, maka dapat menggunakan pustaka NumPy
seperti berikut ini.
import numpy as np

# Definisikan dua vektor A dan B

vektor_a = [Link]([1, 2, 3])
vektor_b = [Link]([4, 5, 6])

# Hitung cross product dengan NumPy

cross_product = [Link](vektor_a, vektor_b)

# Tampilkan hasil
print("Cross product:", cross_product)

3. Transposisi matriks
Transposisi matriks dilakukan dengan menukar baris dan kolom dari matriks.
# Matriks A
A = [[1, 2], [3, 4]]

# Transposisi matriks
A_T = [[A[j][i] for j in range(2)] for i in range(2)]

# Tampilkan hasil
for baris in A_T:
print(baris)

5.4.3 Jenis-jenis matriks

1. Matriks identitas
Matriks identitas adalah matriks persegi di mana semua elemen diagonal utama
adalah 1 dan elemen lainnya adalah 0. Matriks identitas sering digunakan dalam operasi
perkalian matriks karena sifatnya yang tidak mengubah matriks lain yang dikalikan
dengannya.

51
 # Matriks identitas 2x2
identitas_2x2 = [[1 if i == j else 0 for j in range(2)] for i in range(2)]

# Tampilkan hasil
for baris in identitas_2x2:
print(baris)

# Matriks identitas 3x3

identitas_3x3 = [[1 if i == j else 0 for j in range(3)] for i in range(3)]

# Tampilkan hasil
for baris in identitas_3x3:
print(baris)

2. Matriks nol
Matriks nol adalah matriks di mana semua elemen adalah 0. Matriks ini digunakan
dalam berbagai operasi sebagai elemen identitas untuk penjumlahan matriks.
# Matriks nol 2x2
zero_2x2 = [[0 for _ in range(2)] for _ in range(2)]

# Tampilkan hasil
for baris in zero_2x2:
print(baris)

# Matriks nol 3x3

zero_3x3 = [[0 for _ in range(3)] for _ in range(3)]

# Tampilkan hasil
for baris in zero_3x3:
print(baris)

5.4.4 Representasi matriks dengan nested list

Dalam Python, matriks biasanya direpresentasikan menggunakan nested list (list dalam list).
Pendekatan ini memanfaatkan fleksibilitas struktur data list Python untuk membuat struktur dua
dimensi yang mudah dipahami dan dimanipulasi. Setiap elemen dalam list utama mewakili satu
baris matriks, sementara elemen-elemen dalam list tersebut mewakili kolom-kolom dalam baris
tersebut. Metode representasi ini memungkinkan akses cepat ke elemen-elemen individual
menggunakan indeks ganda, seperti matrix[row][column].

52
 # Definisikan matriks 3x3 menggunakan nested list
matriks_3x3 = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Menjumlahkan dua matriks 3x3
matriks_a = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
matriks_b = [
[9, 8, 7],
[6, 5, 4],
[3, 2, 1]
]
# Penjumlahan matriks
matriks_c = [
[matriks_a[i][j] + matriks_b[i][j] for j in range(3)]
for i in range(3)
]
# Tampilkan hasil penjumlahan matriks
print("\nHasil Penjumlahan Matriks:")
for baris in matriks_c:
print(baris)

5.4.5 Menggunakan NumPy untuk operasi matriks

NumPy adalah library Python yang sangat efisien untuk operasi numerik, termasuk operasi
matriks. Keunggulan utama NumPy terletak pada kemampuannya untuk melakukan operasi vektor
dan matriks dengan kecepatan yang jauh melebihi Python standar, berkat implementasinya yang
sebagian besar ditulis dalam bahasa C. NumPy tidak hanya mempercepat komputasi, tetapi juga
menyederhanakan kode dengan menyediakan fungsi-fungsi bawaan untuk operasi aljabar linear,
transformasi Fourier, dan berbagai operasi statistik.

53
import numpy as np

# Definisikan matriks 3x3 menggunakan NumPy

matriks_a = [Link]([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])

matriks_b = [Link]([
[9, 8, 7],
[6, 5, 4],
[3, 2, 1]
])
# Penjumlahan matriks
matriks_c = matriks_a + matriks_b

# Tampilkan hasil penjumlahan matriks

print("\nHasil Penjumlahan Matriks:")
print(matriks_c)

# Perkalian matriks
matriks_d = [Link](matriks_a, matriks_b)

# Tampilkan hasil perkalian matriks

print("\nHasil Perkalian Matriks:")
print(matriks_d)

5.4.6 Aplikasi matriks

1. Grafik komputer
Matriks dapat digunakan untuk transformasi gambar seperti rotasi, skala, dan translasi.
2. Pemrosesan Citra
Operasi seperti filtering, edge detection, dan image transformation menggunakan matriks.
3. Algoritma Machine Learning
Matriks digunakan untuk komputasi gradien, pembaruan bobot, dan representasi data.
4. Matematika
Matriks digunakan untuk solusi sistem persamaan linear, operasi aljabar linear, dan analisis
data.

54
5.5 Latihan

1) Buatlah sebuah fungsi yang menerima list bilangan bulat dan mengembalikan semua
sublist kontinu dengan panjang ganjil, di mana jumlah elemen-elemennya sama dengan
median sublist tersebut dikalikan dengan panjang sublist.
2) Buatlah program yang menerima dua matriks berukuran 3x3 dari pengguna. Program harus
menghitung penjumlahan dan perkalian kedua matriks, serta menampilkan transposisi dari
hasil penjumlahan matriks.
3) Buat suatu matriks 𝑛 × 𝑛 yang menuliskan 𝑛2 bilangan prima pertama. Dengan 𝑛 masukan
dari pengguna.
5.6 Tugas

Studi kasus mengenai Pengolahan Data Penjualan Produk

• Deskripsi kasus
Anda adalah seorang analis data yang bekerja untuk perusahaan retail yang baru-baru ini
meluncurkan beberapa produk baru. Perusahaan ingin menganalisis data penjualan untuk
menentukan kinerja produk di berbagai lokasi dan waktu. Data penjualan disimpan dalam
bentuk matriks yang mencatat jumlah penjualan produk per bulan di beberapa lokasi. Anda
diminta untuk menganalisis data penjualan produk. Data penjualan disimpan dalam bentuk
matriks, di mana setiap baris mewakili produk dan setiap kolom mewakili bulan. Berikut
merupakan data penjualannya.
Produk A: [120, 150, 130, 170, 200, 190]
Produk B: [80, 100, 90, 110, 130, 120]
Produk C: [200, 210, 190, 180, 220, 210]

• Tugas
a. Hitung total penjualan untuk setiap produk.
b. Temukan bulan dengan penjualan tertinggi dan terendah untuk setiap produk.
c. Identifikasi produk yang memiliki lonjakan penjualan yang tidak biasa dibandingkan
dengan rata-rata penjualan bulanan mereka.
• Tantangan
a. Gunakan operasi dasar matriks untuk melakukan perhitungan.
b. Tentukan ambang batas untuk mengidentifikasi lonjakan penjualan.

55
 BAB VI
FILE DALAM PYTHON
6.1 Pengantar

Pada bab sebelumnya, kita telah membahas berbagai koleksi data penting dalam Python,
termasuk list, tuple, dictionary, dan matriks. Konsep-konsep ini memberikan dasar yang kuat
dalam pengelolaan dan manipulasi data, memungkinkan kita untuk menyimpan dan mengorganisir
informasi dengan efisien. Memahami cara kerja koleksi data ini adalah langkah awal yang penting
sebelum melanjutkan ke topik berikutnya yang membahas pengelolaan file.

Pada awal bab ini, kita akan mempelajari konsep dasar mengenai file handler, yang merupakan
komponen penting dalam menangani file dalam Python. Selanjutnya, bab ini akan menguraikan
teknik-teknik untuk membaca data dari file, termasuk metode membaca seluruh isi file, membaca
baris per baris, dan membaca beberapa baris sekaligus. Di bagian akhir, kita akan membahas cara
menulis data ke file, baik dalam format teks maupun biner, serta berbagai mode operasi yang
tersedia untuk menulis dan menambah data ke file. Dengan memahami dan menerapkan konsep-
konsep ini, Anda diharapkan dapat mengelola file dengan efektif dan efisien dalam berbagai
aplikasi pemrograman.

6.2 File handler

File handler dalam Python adalah objek yang digunakan untuk mengelola operasi file seperti
membaca, menulis, dan menutup file. File handler diperoleh melalui fungsi open() yang
mengembalikan objek file yang kemudian dapat digunakan untuk berbagai operasi file.
Pemahaman tentang file handler sangat penting karena file adalah salah satu cara utama untuk
menyimpan data secara permanen dalam aplikasi.
6.2.1 Membuka file
Untuk membuka file dalam Python, kita menggunakan fungsi open(). Fungsi ini
membutuhkan setidaknya satu argumen, yaitu nama file, dan opsi kedua opsional yang
menunjukkan mode operasi file. Mode operasi file menunjukkan bagaimana file akan diakses:
apakah akan dibaca, ditulis, atau ditambahkan. Beberapa mode operasi yang umum digunakan
adalah:

56
 1. Membuka file dalam mode membaca (r)
Mode ini digunakan untuk membuka file yang sudah ada dan membacanya. Jika
file tidak ada, maka akan terjadi error.
# Membuka file untuk membaca
file = open('[Link]', 'r')
# Membaca isi file
content = [Link]()
print(content)
[Link]()

2. Membuka File dalam Mode Menulis (w)

Mode ini digunakan untuk menulis ke file. Jika file sudah ada, isinya akan ditimpa.
Jika file belum ada, file baru akan dibuat.
# Membuka file untuk menulis
file = open('[Link]', 'w')
# Menulis ke file
[Link]('Hello, World!')
[Link]()

3. Membuka File dalam Mode Menambahkan (a)

Mode ini digunakan untuk menambahkan data ke akhir file. Jika file belum ada,
file baru akan dibuat.
# Membuka file untuk menambahkan data
file = open('[Link]', 'a')
# Menambahkan data ke file
[Link]('\nHello again!')
[Link]()

6.2.2 Menutup file

Setelah operasi pada file selesai, penting untuk menutup file menggunakan metode close().
Menutup file memastikan bahwa semua perubahan yang dibuat pada file disimpan dengan benar
dan sumber daya yang digunakan oleh file dilepaskan.

57
 # Membuka file untuk membaca
file = open('[Link]', 'r')
# Melakukan operasi baca pada file
content = [Link]()
print(content)
# Menutup file
[Link]()

6.2.3 Menggunakan context manager

Mengelola file secara manual dengan open() dan close() dapat rentan terhadap kesalahan
jika pengguna lupa menutup file. Python menyediakan cara yang lebih aman dan efisien untuk
menangani file dengan menggunakan statement with. Statement ini secara otomatis mengurus
membuka dan menutup file.

# Membuka file menggunakan with statement

with open('[Link]', 'r') as file:
content = [Link]()
print(content)
# File secara otomatis ditutup setelah block with selesai

Penggunaan with tidak hanya membuat kode lebih bersih tetapi juga memastikan bahwa file
selalu ditutup dengan benar, bahkan jika terjadi kesalahan selama operasi file.
6.2.4 Mode operasi lainnya
Selain mode dasar, Python juga mendukung mode operasi biner untuk membaca dan menulis
file biner seperti gambar atau file eksekusi. Mode biner ditandai dengan menambahkan 'b' setelah
mode utama, misalnya:

• 'rb': Membuka file untuk membaca dalam mode biner.

• 'wb': Membuka file untuk menulis dalam mode biner.
• 'ab': Membuka file untuk menambahkan data dalam mode biner.

# Membuka file biner untuk membaca

with open('[Link]', 'rb') as image_file:
image_data = image_file.read()
print(type(image_data)) # Output: <class 'bytes'>

# Membuka file biner untuk menulis

with open('[Link]', 'wb') as binary_file:
binary_file.write(b'\x00\x01\x02\x03')

58
Mode biner dalam Python digunakan untuk membaca dan menulis file dalam bentuk byte mentah,
tanpa melakukan proses encoding atau decoding, yang berbeda dari mode teks yang secara
otomatis mengubah data biner menjadi string (teks) sesuai dengan encoding tertentu seperti UTF-
8. Mode biner ('rb', 'wb', 'ab') diperlukan ketika bekerja dengan file non-teks seperti gambar, video,
atau file eksekusi, di mana data harus dipertahankan dalam bentuk aslinya tanpa ada konversi,
sementara mode teks lebih cocok untuk file yang berisi teks biasa (artikel, CSV, atau log) yang
perlu diinterpretasikan sebagai karakter.

6.3 Membaca dari file

Membaca dari file adalah salah satu operasi dasar yang sering dilakukan dalam pemrograman.
Python menyediakan berbagai cara untuk membaca file yang memungkinkan fleksibilitas dalam
bagaimana data diakses dan diproses. Metode-metode utama yang digunakan untuk membaca file
termasuk read(), readline(), dan readlines(). Setiap metode memiliki kegunaan spesifik tergantung
pada kebutuhan aplikasi.
6.3.1 Membaca seluruh isi file dengan read()
Metode read() digunakan untuk membaca seluruh isi file sekaligus. Ini berguna ketika ingin
memproses atau menganalisis seluruh konten file dalam satu langkah. Namun, metode ini kurang
efisien untuk file yang sangat besar karena seluruh isi file akan dimuat ke dalam memori.

# Membaca seluruh isi file

with open('[Link]', 'r') as file:
content = [Link]()
print(content)

6.3.2 Membaca baris per baris dengan readline()

Metode readline() membaca file satu baris pada satu waktu. Ini sangat berguna untuk
memproses file yang sangat besar karena hanya satu baris yang dimuat ke dalam memori pada satu
waktu.

# Membaca file baris per baris

with open('[Link]', 'r') as file:
line = [Link]()
while line:
print([Link]()) # Menghapus karakter newline
line = [Link]()

59
6.3.3 Membaca semua baris sekaligus dengan readlines()
Metode readlines() membaca seluruh file dan mengembalikan daftar yang berisi setiap baris
sebagai elemen. Ini memudahkan untuk iterasi dan manipulasi baris individu.

# Membaca semua baris sekaligus

with open('[Link]', 'r') as file:
lines = [Link]()
for line in lines:
print([Link]())

6.3.4 Membaca dalam jumlah tertentu dengan read(n)

Metode read(n) memungkinkan kita untuk membaca sejumlah karakter tertentu dari file. Ini
berguna ketika kita hanya membutuhkan bagian dari file atau ketika memproses data biner.

# Membaca sejumlah karakter tertentu

with open('[Link]', 'r') as file:
content = [Link](10) # Membaca 10 karakter pertama
print(content)

6.3.5 Menggunakan context manager (with statement)

Penggunaan with statement sangat dianjurkan karena memastikan file ditutup dengan benar
setelah selesai digunakan, bahkan jika terjadi error.

# Membaca file menggunakan with statement untuk memastikan penutupan file

otomatis
with open('[Link]', 'r') as file:
content = [Link]()
print(content)

Contoh Penggunaan dalam Berbagai Skenario

1. Membaca Log File

Biasanya dilakukan baris per baris untuk memproses entri log terbaru.
2. Membaca Data Konfigurasi
Seluruh file biasanya dibaca sekaligus untuk memuat pengaturan aplikasi.
3. Membaca File Biner
Dibaca dalam blok-blok kecil untuk memproses data gambar atau audio.

60
6.4 Menulis ke file

Menulis ke file adalah operasi dasar dalam pemrograman yang memungkinkan aplikasi untuk
menyimpan data secara permanen. Python menyediakan berbagai cara untuk menulis ke file, baik
untuk menulis data teks maupun biner. Metode utama yang digunakan untuk menulis ke file
termasuk write() dan writelines(). Setiap metode memiliki kegunaan spesifik tergantung pada
kebutuhan aplikasi.
6.4.1 Menulis data teks dengan write()
Metode write() digunakan untuk menulis string ke file. Jika file dibuka dalam mode
penulisan (w), isi file yang sudah ada akan ditimpa. Jika file dibuka dalam mode penambahan (a),
data baru akan ditambahkan ke akhir file.

# Menulis data teks ke file

with open('[Link]', 'w') as file:
[Link]('Hello, World!\n')
[Link]('This is a test.\n')

6.4.2 Menulis beberapa baris dengan writelines()

Metode writelines() digunakan untuk menulis daftar string ke file. Setiap elemen dalam
daftar ditulis ke file tanpa menambahkan karakter newline secara otomatis, sehingga perlu
memastikan bahwa setiap string diakhiri dengan karakter newline jika diperlukan.

# Menulis beberapa baris ke file

lines = ['First line\n', 'Second line\n', 'Third line\n']
with open('[Link]', 'w') as file:
[Link](lines)

6.4.3 Menambahkan data ke file dengan mode penambahan (a)

Mode penambahan (a) digunakan untuk menambahkan data baru ke akhir file tanpa
menimpa isi yang sudah ada. Ini berguna ketika kita perlu menambah log atau data baru secara
berkelanjutan.

# Menambahkan data ke file yang sudah ada

with open('[Link]', 'a') as file:
[Link]('Adding a new line.\n')
[Link]('Appending more data.\n')

61
6.4.4 Menulis data biner
Untuk menulis data biner seperti gambar atau file audio, maka menggunakan mode biner
(wb atau ab). Data yang ditulis harus dalam bentuk bytes.

# Menulis data biner ke file

binary_data = b'\x00\x01\x02\x03\x04\x05\x06\x07'
with open('[Link]', 'wb') as file:
[Link](binary_data)

6.4.5 Menggunakan context manager (with statement)

Penggunaan with statement sangat dianjurkan karena memastikan file selalu ditutup dengan
benar setelah selesai digunakan, bahkan jika terjadi error. Ini membuat manajemen file lebih aman
dan efisien.

# Menulis data teks ke file menggunakan with statement

with open('[Link]', 'w') as file:
[Link]('Hello, World!\n')
[Link]('This is written using with statement.\n')

6.5 Latihan

1) Buat sebuah program yang meminta pengguna untuk memasukkan beberapa baris teks dan
menyimpannya ke dalam file. Kemudian, baca kembali isi file tersebut dan tampilkan di
layar.
2) Buat sebuah program yang membaca isi dari file teks dan menghitung jumlah kata yang
ada di dalamnya.
3) Buat sebuah program yang menyalin isi dari satu file biner ke file biner lainnya.

6.6 Tugas

Studi kasus Sistem Pengelolaan Data Mahasiswa

• Deskripsi
Buat sebuah program yang mengelola data mahasiswa. Program ini harus mampu
menambahkan, menghapus, dan menampilkan data mahasiswa yang disimpan dalam file.
Setiap mahasiswa memiliki atribut, berupa NIM (Nomor Induk Mahasiswa), nama, dan
jurusan.

62
• Instruksi
• Buat sebuah menu yang menawarkan opsi berikut:
a. Tambah Data Mahasiswa
b. Hapus Data Mahasiswa
c. Tampilkan Data Mahasiswa
d. Keluar
e. Data mahasiswa harus disimpan dalam file [Link] dengan format CSV
(Comma-Separated Values).
f. Implementasikan setiap fungsi sesuai dengan opsi di menu.

63
 BAB VII
MASALAH SEDERHANA DsAN SOLUSI ALGORITMA
7.1 Pengantar

Pada bab ini membahas berbagai masalah sederhana yang sering dijumpai dalam pemrograman
serta penerapan solusi algoritmik untuk menyelesaikannya secara efisien. Fokus utama bab ini
adalah penggunaan metode algoritma dasar untuk menangani masalah sehari-hari yang
memerlukan pemahaman mendalam tentang struktur data dan teknik algoritmik. Melalui contoh-
contoh praktis, Anda akan diperkenalkan pada cara-cara efektif untuk menyelesaikan masalah
seperti menentukan kembalian dengan jumlah koin minimal dan menghitung hasil perpangkatan
yang besar.

Sebagai kelanjutan dari bab sebelumnya yang membahas dasar-dasar algoritma dan
pemrograman menggunakan Python, bab ini bertujuan untuk memberikan pemahaman yang lebih
mendalam tentang penerapan algoritma dalam konteks yang lebih praktis. Teknik-teknik seperti
Dynamic Programming dan Algoritma Greedy akan dibahas untuk menemukan solusi optimal
serta memahami batasan-batasan yang mungkin dihadapi dalam implementasi algoritma. Dengan
pendekatan ini, Anda diharapkan dapat mengembangkan keterampilan pemrograman yang lebih
kuat dan mempersiapkan diri untuk menghadapi tantangan yang lebih kompleks di masa depan.

7.2 Soal dan Pembahasan

7.2.1 Soal 1
Pak Doni mempunyai seekor ayam yang bernama Gajah (namanya memang aneh). Pada suatu
hari, Pak Doni mengadakan acara yang mengundang N orang. Pak Doni mempunyai daftar N
orang tersebut. Akan tetapi, saat menghubungi orang-orang tersebut, Pak Doni kebingungan
karena namanya terlalu acak-acakan (tidak terurut). Karena itu, si Gajah, yang juga dijadikan
asisten Pak Doni, dimintai Pak Doni untuk mengurutkan nama-nama dari N orang tersebut, agar
dapat menghubungi dengan lebih mudah.

Dalam pengurutannya, kata-kata diurutkan berdasarkan banyaknya hurufnya, dari yang paling
sedikit ke yang paling banyak. Jika banyak hurufnya sama, maka kemudian diurutkan membesar
secara leksikografis.

64
Walaupun Gajah merupakan seekor ayam yang pintar, akan tetapi ia kesulitan karena nama-
namanya sangat banyak. Gajah meminta bantuan Anda untuk mengurutkannya. Bantulah Gajah!
Format Masukan Format Keluaran
Baris pertama berisi sebuah bilangan bulat N. N buah baris berisi nama-nama yang sudah
N baris berikutnya masing-masing berisi diurutkan berdasarkan aturan pada deskripsi.
sebuah nama.

Contoh Masukan Contoh Keluaran

6 man
angela budi
budi didi
didi sani
man andri
andri angela
sani

Batasan

• 1 ≤ N ≤ 500
• Setiap nama terdiri atas karakter-karakter 'a' - 'z'.
• Setiap nama terdiri atas 1 sampai dengan 10 karakter, inklusif.

Penyelesaian

Untuk menyelesaikan masalah di atas, kita perlu mengurutkan nama-nama berdasarkan dua
aturan utama, yaitu panjang nama dan letak leksikografis. Panjang nama yaitu mengurutkan nama-
nama berdasarkan panjangnya, dari yang paling pendek ke yang paling panjang. Sedangkan, letak
leksikografis adalah jika ada beberapa nama yang memiliki panjang yang sama, urutkan nama-
nama tersebut berdasarkan urutan alfabetis.

Pendekatan untuk menyelesaikan masalah ini adalah sebagai berikut.

1. Membaca jumlah N dan kemudian membaca N nama dari input.

65
 2. Mengurutkan daftar nama tersebut menggunakan dua kriteria, yaitu berdasarkan panjang
nama dan jika panjangnya sama diurutkan secara leksikografis.
3. Setelah pengurutan selesai, maka cetak nama-nama yang sudah terurut sesuai dengan
kriteria.

Berikut adalah kode Python untuk mengimplementasikan logika tersebut:

# Membaca jumlah orang

N = int(input())

# Membaca daftar nama

names = [input().strip() for _ in range(N)]

# Mengurutkan nama berdasarkan panjang dan leksikografis

sorted_names = sorted(names, key=lambda x: (len(x), x))

# Menampilkan nama yang sudah diurutkan

for name in sorted_names:
print(name)

Penjelasan kode diatas sebagai berikut.

• names = [input().strip() for _ in range(N)] : Mengumpulkan semua nama ke dalam

sebuah daftar.
• sorted(names, key=lambda x: (len(x), x)): Mengurutkan daftar nama menggunakan
dua kunci; panjang dan urutan leksikografis.
• for name in sorted_names: : Melakukan iterasi pada nama-nama yang sudah diurutkan
dan mencetaknya satu per satu.

7.2.2 Soal 2
Pak Budi memberikan Anda dua buah pecahan dalam bentuk A/B dan C/D. Hitunglah A/B + C/D,
lalu cetak hasilnya dalam bentuk yang paling sederhana. Bentuk paling sederhana dari suatu
pecahan adalah ketika FPB dari pembilang dan penyebutnya adalah 1.
Format Masukan Format Keluaran
Baris pertama berisi dua buah bilangan bulat A Sebuah baris berisi dua buah bilangan bulat,
dan B. Baris kedua berisi dua buah bilangan yaitu E dan F, di mana E/F = A/B + C/D dan
bulat C dan D. E/F adalah bentuk yang paling sederhana.

66
 Contoh Masukan Contoh Keluaran
23 22 15
45

Penyelesaian

Dalam menyelesaikan masalah ini, kita perlu menjumlahkan dua pecahan dan kemudian
menyederhanakan hasilnya. Langkah-langkah yang harus diikuti adalah sebagai berikut:

1. Menentukan penjumlah pecahan

Untuk menentukan dua pecahan, harus memiliki penyebut yang sama. Jika pecahan
pertama adalah A/B dan pecahan kedua adalah C/D, maka kita dapat menjumlahkan
keduannya dengan formula:

𝐴×𝐷+𝐵×𝐶
𝐻𝑎𝑠𝑖𝑙 𝑃𝑒𝑛𝑗𝑢𝑚𝑙𝑎ℎ𝑎𝑛 =
𝐵×𝐷

Pembilang dari hasil penjumlahan adalah (𝐴 × 𝐷) + (𝐶 × 𝐵) dan penyebutnya adalah

𝐵 × 𝐷.
2. Menyederhanakan pecahan
Setelah menghitung pembilang dan penyebut dari hasil penjumlahan, kita harus
menyederhanakan pecahan tersebut. Untuk menyederhanakan pecahan, kita membagi
pembilang dan penyebut dengan Faktor Persekutuan Terbesar (FPB) dari kedua angka
tersebut.
3. Menggunakan Python
Kita akan menggunakan fungsi ’[Link]’ pada Python untuk menemukan FPB dan
menyederhanakan pecahan

Berikut adalah kode Python untuk mengimplementasikan beberapa langkah tersebut:

67
 import math

# Membaca input pecahan pertama

A, B = map(int, input().split())

# Membaca input pecahan kedua

C, D = map(int, input().split())

# Menghitung pembilang dan penyebut hasil penjumlahan

pembilang = A * D + C * B
penyebut = B * D

# Mencari FPB dari pembilang dan penyebut

fpb = [Link](pembilang, penyebut)

# Menyederhanakan pecahan dengan membagi pembilang dan penyebut

dengan FPB
pembilang_sederhana = pembilang // fpb
penyebut_sederhana = penyebut // fpb

# Mencetak hasil akhir dalam bentuk paling sederhana

print(pembilang_sederhana, penyebut_sederhana)

Penjelasan kode di atas sebagai berikut.

• A, B = map(int, input().split()): Membaca pecahan pertama.

• C, D = map(int, input().split()): Membaca pecahan kedua.
• Pembilang = A ∗ D + C ∗ B: Menghitung pembilang hasil penjumlahan pecahan.
• penyebut = B ∗ D: Menghitung penyebut hasil penjumlahan pecahan.
• fpb = [Link](pembilang, penyebut) : Menemukan FPB untuk menyederhanakan
pecahan.
• pembilang_sederhana = pembilang // fpb dan penyebut_sederhana = penyebut // fpb:

Menyederhanakan pecahan.
• print(pembilang_sederhana, penyebut_sederhana): Mencetak hasil dalam bentuk paling

sederhana.

68
7.2.3 Soal 3
Bu Sinta memberikan Anda dua buah matriks berukuran N × N. Periksalah apakah kedua matriks
tersebut identik, atau identik refleksional, atau tidak identik sama sekali. Dua matriks disebut
identik tentu jika kedua matriks persis sama. Dua matriks disebut identik refleksional jika jika
salah satu adalah pencerminan dari matriks yang lain. Pencerminan bisa dengan sumbu vertikal
(|), dengan sumbu horisontal (—), dengan sumbu diagonal ke kiri bawah (/), atau dengan sumbu
diagonal ke kanan bawah (\).

Misalnya:
Matriks pertama adalah dan matriks kedua adalah
123 789
456 456
789 123

Kedua matriks adalah identik refleksional dengan sumbu horisontal (—).

Misalnya:
Matriks pertama adalah dan matriks kedua adalah
123 321
456 654
789 987

Kedua matriks adalah identik refleksional dengan sumbu vertikal (|).

Misalnya:
Matriks pertama adalah dan matriks kedua adalah
123 147
456 258
789 369

Kedua matriks adalah identik refleksional dengan sumbu diagonal ke kanan bawah (\).

69
Misalnya:
Matriks pertama adalah dan matriks kedua adalah
123 963
456 852
789 741

Kedua matriks adalah identik refleksional dengan sumbu diagonal ke kiri bawah (/).
Format Masukan Format Keluaran
Baris pertama berisi dua buah bilangan bulat N Sebuah baris berisi tidak identik jika kedua
dan N. N baris berikutnya berisi N buah matriks tidak identik refleksional,
bilangan bulat yaitu elemen-elemen dari atau identik jika kedua matriks benar-benar
matriks pertama. Baris berikutnya berisi dua identik, atau salah satu
buah bilangan bulat N dan N. N baris dari vertikal, horisontal, diagonal kanan
berikutnya berisi N buah bilangan bulat yaitu bawah, diagonal kiri bawah, yaitu jenis
elemen-elemen dari matriks kedua. refleksinya. Dijamin hanya ada satu
kemungkinan jawaban.

Contoh Masukan Contoh Keluaran

33 diagonal kiri bawah
123
456
789
33
963
852
741
33 identik
123
456
789
33

70
 123
456
789

Penyelesaian

Dalam memeriksa apakah dua matriks identik, identik refleksional, atau tidak identik sama
sekali, kita perlu membandingkan kedua matriks tersebut dengan beberapa transformasi
refleksional. Berikut adalah cara untuk melakukannya:

1. Identik: Dua matriks disebut identik jika semua elemen pada posisi yang sama adalah sama
dalam kedua matriks.
2. Refleksi Vertikal (|): Dua matriks disebut identik refleksional vertikal jika salah satu
matriks adalah pencerminan vertikal dari matriks lainnya.
3. Refleksi Horizontal (—): Dua matriks disebut identik refleksional horizontal jika salah satu
matriks adalah pencerminan horizontal dari matriks lainnya.
4. Refleksi Diagonal Kanan Bawah (\): Dua matriks disebut identik refleksional diagonal
kanan bawah jika salah satu matriks adalah pencerminan diagonal dari kiri atas ke kanan
bawah dari matriks lainnya.
5. Refleksi Diagonal Kiri Bawah (/): Dua matriks disebut identik refleksional diagonal kiri
bawah jika salah satu matriks adalah pencerminan diagonal dari kiri bawah ke kanan atas
dari matriks lainnya.

Algoritma penyelesaian yaitu pertama, cek apakah kedua matriks identik. Jika tidak identik,
cek apakah mereka identik setelah diterapkan refleksi vertikal, horizontal, diagonal kanan bawah,
atau diagonal kiri bawah. Jika semua pengecekan ini gagal, maka kedua matriks tidak identik.

Berikut adalah kode Python untuk mengimplementasikan logika tersebut:

71
 def are_identical(matrix1, matrix2):
return matrix1 == matrix2

def reflect_vertical(matrix):
return [row[::-1] for row in matrix]

def reflect_horizontal(matrix):
return matrix[::-1]

def reflect_diagonal_right(matrix, N):

return [[matrix[j][i] for j in range(N)] for i in range(N)]

def reflect_diagonal_left(matrix, N):

return [[matrix[N-1-j][N-1-i] for j in range(N)] for i in range(N)]

# Input matriks pertama

N, _ = map(int, input().split())
matrix1 = [list(map(int, input().split())) for _ in range(N)]

# Input matriks kedua

_, _ = map(int, input().split())
matrix2 = [list(map(int, input().split())) for _ in range(N)]

# Cek apakah kedua matriks identik

if are_identical(matrix1, matrix2):
print("identik")
elif are_identical(reflect_vertical(matrix1), matrix2):
print("vertikal")
elif are_identical(reflect_horizontal(matrix1), matrix2):
print("horisontal")
elif are_identical(reflect_diagonal_right(matrix1, N), matrix2):
print("diagonal kanan bawah")
elif are_identical(reflect_diagonal_left(matrix1, N), matrix2):
print("diagonal kiri bawah")
else:
print("tidak identik")

Penjelasan kode di atas sebagai berikut.

• are_identical: Fungsi membandingkan apakah kedua matriks identik.

• reflect_vertical: Fungsi mencerminkan matriks secara vertikal.
• reflect_horizontal: Fungsi mencerminkan matriks secara horizontal.
• reflect_diagonal_right: Fungsi mencerminkan matriks pada diagonal kanan bawah (\).

72
 • reflect_diagonal_left: Fungsi mencerminkan matriks pada diagonal kiri bawah (/).
• Setelah memeriksa semua kemungkinan refleksi, kode akan mencetak hasil yang sesuai.

7.2.4 Soal 4
Soal ini pada dasarnya adalah soal perpangkatan sederhana. Anda diberikan dua buah bilangan
bulat A dan B, hitunglah berapa AB.
Format Masukan Format Keluaran
Sebuah baris berisi dua buah bilangan bulat A Sebuah baris berisi nilai dari AB. Jika bilangan
dan B. tersebut lebih besar dari 999.999, cukup cetak
6 digit terakhir dari bilangan tersebut.

Contoh Masukan Contoh Keluaran

38 6561
99 420489

Batasan

• 1 ≤ A, B ≤ [Link]

Penyelesaian

Untuk menyelesaikan soal, kita perlu menghitung hasil perpangkatan dua bilangan bulat A
dan B, kemudian menentukan apakah hasilnya lebih besar dari 999.999. Jika hasilnya lebih besar,
kita hanya perlu mencetak enam digit terakhir dari hasil tersebut. Langkah-langkah
penyelesaiannya adalah sebagai berikut.

1. Gunakan operasi perpangkatan untuk menghitung AB.

2. Jika hasilnya lebih besar dari 999.999, ambil enam digit terakhir dari hasil tersebut. Jika
hasilnya kurang dari atau sama dengan 999.999, cetak hasil tersebut apa adanya.
3. Jika enam digit terakhir adalah angka dengan kurang dari 6 digit (misalnya, 1234), kita
perlu menambahkan nol di depan sehingga hasilnya selalu terdiri dari 6 digit (misalnya,
001234).

Berikut adalah kode Python untuk mengimplementasikan logika tersebut:

73
 # Membaca input
A, B = map(int, input().split())

# Menghitung hasil perpangkatan

result = pow(A, B)

# Cek apakah hasil lebih besar dari 999999

if result > 999999:
# Ambil 6 digit terakhir
result = result % 1000000
# Format output agar selalu 6 digit dengan angka depan nol jika diperlukan
print(f'{result:06}')
else:
print(result)

Penjelasan kode di atas sebagai berikut.

• pow(A, B): Menghitung AB.

• result % 1000000: Mengambil enam digit terakhir dari hasil dengan operasi modulo
1000000.
• f'{result:06}': Memastikan output selalu memiliki 6 digit, menambahkan nol di depan
jika perlu.

7.2.5 Soal 5
Koin kembalian adalah persoalan yang umum ditemukan dimana-mana. Saat Anda membayar
belanjaan, jika uang Anda tidak pas, tentu Anda mengharapkan kembalian bukan? Dan secara
umum, biasanya Anda mengharapkan kembalian dengan koin sesedikit mungkin supaya kantong
Anda tidak menjadi berat. Secara spesifik, saat ini Anda diminta untuk menuliskan sebuah program
yang dapat mencari kemungkinan kembalian dengan banyak koin sesedikit mungkin.

74
 Format Masukan Format Keluaran
Baris pertama berisi sebuah bilangan bulat N Sebuah bilangan bulat yang merupakan
yang menyatakan banyaknya jenis koin yang banyak koin minimal yang dapat digunakan
dapat digunakan. Baris kedua berisi N buah untuk menyatakan kembalian yang diinginkan.
bilangan bulat dipisahkan spasi yang Jika ternyata, dengan jenis koin yang tersedia,
merupakan nilai dari masing-maing jenis koin Anda tidak dapat menyatakan kembalian
tersebut. Baris terakhir berisi sebuah bilangan dengan tepat, keluarkan -1 (misalnya
bulat K yang menyatakan besar uang kembalian seharusnya 5 namun hanya ada satu
kembalian. jenis koin yakni 2).

Contoh Masukan Contoh Keluaran

4 2
1256
10

Batasan
• 1 ≤ N ≤ 500
• Masing-masing jenis koin memiliki nilai tertentu yang berbeda satu sama lain di antara 1
sampai dengan 500.
• Stok dari masing-masing jenis koin dianggap tidak terbatas.
• 1 ≤ K ≤ 50.000

Penyelesaian

Dalam menyelesaikan masalah ini, kita dapat menggunakan teknik Dynamic Programming
(DP). Pendekatan ini efisien dalam mencari solusi optimal untuk masalah "minimum coin change".
Pendekatan tersebut terdiri dari:

1. Mendefinisikan array DP
Buat array dp dengan ukuran K+1 di mana dp[i] menyimpan jumlah minimum koin yang
dibutuhkan untuk mendapatkan nilai iii. Inisialisasi semua elemen dp dengan nilai yang
sangat besar (misalnya ∞), kecuali dp[0] yang diset menjadi 0, karena tidak dibutuhkan
koin untuk mendapatkan nilai 0.

75
 2. Iterasi untuk setiap koin
Untuk setiap koin yang tersedia, perbarui nilai di dp dengan memeriksa apakah
menggunakan koin tersebut bisa menghasilkan solusi dengan lebih sedikit koin untuk
setiap nilai hingga K.
3. Hasil akhir
Setelah iterasi selesai, jika dp[K] masih bernilai ∞, maka keluarkan -1, yang berarti tidak
mungkin memberikan kembalian yang tepat dengan jenis koin yang tersedia. Jika tidak,
keluarkan nilai dp[K] sebagai hasilnya.
Berikut adalah kode Python untuk menyelesaikan masalah ini:
# Membaca input
coins = list(map(int, input().split()))
K = int(input())

# Inisialisasi DP array dengan nilai tak terhingga

dp = [float('inf')] * (K + 1)
dp[0] = 0

# Mengisi DP array
for coin in coins:
for i in range(coin, K + 1):
dp[i] = min(dp[i], dp[i - coin] + 1)

# Mengecek hasil akhir

if dp[K] == float('inf'):
print(-1)
else:
print(dp[K])

Penjelasan kode di atas adalah sebagai berikut.

• dp[i]: Menyimpan jumlah minimum koin yang diperlukan untuk membuat nilai 𝑖.
• Inisialisasi: dp[0] diinisialisasi dengan 0 karena tidak diperlukan koin untuk mencapai nilai
0. Nilai lainnya diinisialisasi dengan ∞ sebagai representasi bahwa pada awalnya tidak
mungkin mencapai nilai tersebut.
• Iterasi Koin: Untuk setiap koin, kita mencoba memperbarui solusi untuk setiap nilai mulai
dari nilai koin tersebut hingga 𝐾.

76
 • dp[i] = min(dp[i], dp[i - coin] + 1): Ini adalah langkah utama DP di mana kita
membandingkan apakah menggunakan koin saat ini menghasilkan solusi yang lebih baik
(lebih sedikit koin) dibandingkan solusi yang sudah ada.

7.3 Latihan
7.3.1 Soal 1
Perusahaan A adalah sebuah perusahaan baju. Terdapat N buah baju yang telah diproduksi pada
tahun sebelumnya. Setiap baju memiliki nilai kualitasnya masing-masing. Perusahaan A ingin
menggunakan nilai median dari nilai-nilai kualitas produksi tahun sebelumnya sebagai indikator
keberhasilan pada tahun ini. Nilai median adalah nilai yang berada tepat di tengah data diurutkan.
Jika banyaknya data adalah genap, maka nilai median dari data tersebut adalah rata-rata kedua
bilangan yang ada di tengah. Bantulah perusahaan A untuk membuat program yang dapat
menentukan nilai median dari data produksi tahun sebelumnya, sehingga dapat langsing digunakan
untuk indikator keberhasilan produksi tahun ini.
Format Masukan Format Keluaran
Baris pertama berisi sebuah bilangan bulat N. Sebuah baris berisi nilai median, dalam
N baris berikutnya masing-masing berisi ketelitian tepat satu angka di belakang koma.
sebuah nilai kualitas baju.

Contoh Masukan Contoh Keluaran

5 3.0
1
1
3
4
6

Batasan

• 1 ≤ N ≤ 100.000
• 1 (setiap nilai kualitas) ≤ 100

77
7.3.2 Soal 2
Desa Pak Budi sering kedatangan para pedagang dari berbagai daerah. Pedagang-pedagang ini
datang mengunjungi desa Pak Budi secara periodik dalam beberapa hari sekali. Setiap pedagang
mempunyai perioda masing-masing (mungkin ada pedagang yang menetapkan perioda yang sama
walaupun pada umumnya berbeda). Akibatnya, bisa terjadi, semua pedagang datang di hari yang
bersamaan. Saat itulah sebuah pasar besar digelar dengan sebutan Pasar Rakyat. Pak Budi sangat
suka belanja dan selalu menantikan datangnya Pasar Rakyat. Kebetulan, hari ini Pasar Rakyat
kembali digelar dan hampir mencapai penghujungnya. Pak Budi yang tidak sabar menunggu,
mulai sibuk menghitung, berapa hari lagikah pasar rakyat akan kembali digelar?
Format Masukan Format Keluaran
Baris pertama masukan berisi sebuah bilangan Keluarkanlah jumlah hari berikutnya dimana
N (2 ≤ N ≤ 20) yang menyatakan jumlah Pasar Rakyat akan diadakan apabila hari ini
pedagang yang mengunjungi desa Pak Doni. N adalah hari penyelenggaraan Pasar Rakyat.
baris berikutnya masing-masing berisi sebuah Keluaran dijamin tidak akan lebih dari
bilangan 𝐷𝑖 (1 ≤ 𝐷𝑖 ≤ 100.000) yang 100.000.
menyatakan frekuensi kunjungan pedagang
ke-i.

Contoh Masukan Contoh Masukan

3 3
2 2
4 4
5 5

7.3.3 Soal 3
Bu Santi sering berpikir apakah mungkin sebuah grup Piala Dunia berakhir dengan konfigurasi
skor tertentu. Misalnya, sebuah grup bisa berakhir dengan skor 7-4-4-1 atau 9-4-3-1. Namun, grup
tidak bisa berakhir dengan skor 9-6-6-1, atau 9-9-9-9, dan masih banyak konfigurasi mustahil
lainnya. Dalam sebuah grup, setiap pasang tim bermain tepat sekali. Tim yang menang mendapat
skor 3, sedangkan tim yang kalah mendapat skor 0. Apabila terjadi seri, maka kedua tim masing-

78
masing mendapat skor 1. Pada Piala Dunia tahun ini, setiap grupnya terdiri atas N tim. Diberikan
tebakan total skor akhir masing-masing tim, tentukan apakah tebakan tersebut mungkin terjadi.
Format Masukan Format Keluaran
Baris pertama berisi sebuah bilangan bulat T buah baris, masing-masing
T yaitu jumlah tebakan Pak Doni. T baris berisi YES apabila tebakan tersebut mungkin,
berikutnya masing-masing berisi sebuah atau NO jika tidak mungkin.
bilangan bulat N, dilanjutkan dengan N buah
bilangan bulat yaitu skor-skor akhir pada grup
tersebut.

Contoh Masukan Contoh Keluaran

2 NO
49661 YES
47441

Batasan

• 1≤T≤8
• 2≤N≤5
• Skor-skor adalah bilangan bulat antara 0 sampai dengan 100.

7.3.4 Soal 4
Pada suatu hari Pak Ganesh mengadakan pesta ulang tahunnya. Beliau mengundang semua
gajahnya untuk menghadiri pesta tersebut. Untuk menarik para gajah agar menghadiri pesta
tersebut, Pak Ganesh akan memberikan hadiah khusus bagi salah satu gajah yang beruntung.

Cara mengetahui gajah yang mana yang akan mendapat hadiah adalah sebagai berikut. Pak Ganesh
akan memilih 3 bilangan A, B, dan C. Setiap gajah yang hadir akan mendapat nomor yang
menunjukkan nomor urut kedatangannya. Setelah diketahui ada N gajah yang hadir, gajah yang
𝐶
mendapat hadiah adalah gajah yang membawa nomor 𝐴𝐵 mod N + 1. Pak Ganesh akan memilih

79
 𝐶
bilangan A, B, dan C sedemikian sehingga perhitungan 𝐴𝐵 pasti terdefinisi sebagai bilangan
bulat.

Karena setiap gajah ingin mendapatkan hadiah tersebut (terutama karena mereka belum tahu
seperti apa hadiahnya), bisa dipastikan tidak ada gajah yang pulang sebelum acara pemberian
hadiah. Namun sayangnya saat Pak Ganesh akan menghitung bilangan tersebut, kalkulatornya
rusak. Karena lokasi pesta jauh dari toko kalkulator dan tidak ada gajah yang membawa kalkulator,
beliau meminta bantuan anda untuk menghitung bilangan tersebut.
Format Masukan Format Keluaran
Baris pertama berisi empat buah bilangan bulat Sebuah baris berisi nilai dari 𝐴𝐵𝐶 mod N + 1.
A, B, C, dan N.

Contoh Masukan Contoh Keluaran

345 3

Batasan

• 0 ≤ A ≤ 1 × 103
• 0 ≤ B ≤ 2 × 104
• 0 ≤ C ≤ 3 × 105
• 1 ≤ N ≤ 107

7.3.5 Soal 5
Palindrom adalah suatu string yang bila dibalik, akan sama dengan string tersebut sebelum dibalik,
contohnya aba, ada, kasurrusak. Suatu string yang bukan palindrom, bisa saja diubah menjadi suatu
palindrom dengan cara menghapus 0 atau lebih karakternya. Sebagai contoh, dari string abca dapat
dibentuk palindrom aba melalui penghapusan karakter c. Diberikan suatu string, tentukan panjang
palindrom terpanjang yang bisa dibentuk dengan metode yang disebutkan di atas.
Format Masukan Format Keluaran
Baris pertama berisi suatu bilangan yaitu Terdiri dari N baris, masing-masing terdiri dari
N yang menyatakan jumlah kasus. N baris suatu bilangan yang menyatakan panjang

80
 berikutnya masing-masing berisi tepat suatu palindrom terpanjang yang bisa dibentuk dari
string. string yang diinput dengan memakai aturan
yang disebutkan di atas.

Contoh Masukan Contoh Keluaran

5 5
wewewe 3
pelatnas 1
kedua 1
di 3
jogja

Batasan

• 1 ≤ N ≤ 50
• Panjang string antara 1 sampai dengan 50 karakter
• Setiap string hanya terdiri dari karakter a-z

81