Program Studi Bisnis Digital • FEB UNDIP

Algoritma dan Pemrograman

Pertemuan 5 — Text Files dan Penanganan Eksepsi

Bagaimana program Anda menyimpan data ke luar memori sementara, dan bagaimana program tetap berjalan aman ketika terjadi kesalahan tak terduga.

RPS minggu 5 · 2x50 menit

Selamat datang kembali, Anda semua, di pertemuan kelima Algoritma dan Pemrograman. Sejauh ini Anda sudah menguasai variabel, kontrol seleksi-perulangan, dan string — semua itu masih hidup di dalam memori komputer selama program berjalan, lalu hilang begitu program ditutup. Hari ini kita naik satu level: bagaimana caranya data yang Anda olah, misalnya daftar transaksi toko online kecil-kecilan, bisa disimpan permanen ke dalam file teks agar tidak hilang setiap kali program berhenti. Kita juga akan belajar hal yang sama pentingnya — apa yang terjadi kalau file yang dicari tidak ada, atau pengguna mengetik huruf padahal diminta angka, dan bagaimana Anda mencegah program Anda "mati mendadak" karena kesalahan semacam itu. Siapkan laptop Anda, karena kita akan banyak mencoba kode secara langsung hari ini.

Tujuan Pembelajaran Hari Ini

Empat capaian yang harus Anda kuasai setelah pertemuan ini, sejalan dengan Sub-CPMK minggu 5.

Sub-CPMK 5.1

Menjelaskan konsep file teks dan fungsi open() beserta mode akses r, w, dan a.

Sub-CPMK 5.2

Mempraktikkan cara menulis dan membaca file teks memakai Python, termasuk pola with open().

Sub-CPMK 5.3

Mengidentifikasi jenis eksepsi (exception) umum dan memahami mengapa program bisa berhenti mendadak.

Sub-CPMK 5.4

Menerapkan try-except-else-finally untuk membuat program yang tangguh terhadap kesalahan.

Mari kita lihat dulu apa yang akan Anda kuasai secara konkret hari ini. Pertama, Anda perlu paham konsep file teks sebagai tempat penyimpanan data di luar program, lengkap dengan tiga mode akses dasar. Kedua, Anda akan langsung berlatih menulis dan membaca isi file menggunakan pola aman bernama context manager, yaitu blok with open(). Ketiga, Anda akan belajar mengenali jenis-jenis kesalahan yang sering muncul saat program berjalan, misalnya ketika file yang dicari tidak ditemukan atau pengguna salah mengetik input. Terakhir, dan ini paling penting untuk Anda sebagai calon pengelola sistem bisnis digital, Anda akan bisa menulis kode yang tetap berjalan dengan baik meskipun terjadi kesalahan, bukan langsung crash di depan pelanggan Anda.

Mengapa Ini Penting bagi Bisnis Digital?

Bayangkan Anda mengelola sistem pencatatan transaksi untuk sebuah UMKM di Tokopedia. Dua masalah nyata akan segera Anda temui.

Masalah 1 — Data hilang. Setiap kali program Python ditutup, semua variabel di memori ikut hilang. Kalau daftar transaksi hanya disimpan di variabel, besok pagi semuanya kosong lagi. Anda butuh file teks agar data tersimpan permanen di penyimpanan komputer (disk).

Masalah 2 — Program berhenti mendadak. Kalau pelanggan mengetik huruf padahal diminta jumlah barang, atau file catatan stok belum ada, program Python tanpa penanganan akan langsung crash — berhenti total di tengah transaksi. Anda butuh penanganan eksepsi agar hal itu tidak terjadi.

Bagian 1 dari 3

Membaca & Menulis Text File

Bagaimana program Python menyimpan dan mengambil kembali data dari luar memori — ke dalam file teks di disk komputer Anda.

Kita mulai bagian pertama hari ini dari fondasi paling dasar: bagaimana Python berbicara dengan file yang tersimpan di komputer Anda. Anda akan belajar fungsi pembuka pintu ke dunia file, yaitu open(), lengkap dengan tiga mode akses yang menentukan apakah Anda ingin membaca, menulis baru, atau menambahkan data. Konsep ini akan langsung Anda praktikkan dengan contoh nyata mencatat transaksi penjualan sebuah toko online kecil, persis seperti yang mungkin kelak Anda bangun sendiri. Perhatikan baik-baik pola penulisan kodenya, karena pola ini akan terus Anda pakai di hampir semua program yang berhubungan dengan data.

Fungsi open(): Pintu Masuk ke File

Python menyediakan fungsi bawaan open() untuk membuka file teks. Fungsi ini butuh nama file dan mode akses — cara Anda ingin memakai file itu.

Contoh: open("penjualan.txt", "r") membuka file penjualan.txt khusus untuk dibaca.

Anggap fungsi open() ini seperti membuka pintu ke sebuah buku catatan fisik di toko Anda. Mode "r", singkatan dari read atau baca, artinya Anda hanya ingin membaca isi buku itu tanpa mengubahnya, dan buku itu wajib sudah ada sebelumnya. Mode "w", singkatan dari write atau tulis, artinya Anda mengambil buku baru dan menulis dari halaman kosong — hati-hati, kalau bukunya sudah ada isinya, semua isi lama akan terhapus dan tertimpa. Mode "a", singkatan dari append atau tambah, artinya Anda membuka buku yang sama lalu menambahkan catatan baru di halaman terakhir tanpa menghapus apa pun yang sudah ada. Untuk kasus mencatat transaksi harian sebuah UMKM, misalnya, Anda hampir selalu memakai mode "a" agar catatan kemarin tidak hilang setiap kali toko buka lagi.

Pola Aman: Blok with open()

Python menyediakan pola context manager (pengelola konteks) via kata kunci with agar file otomatis tertutup setelah selesai dipakai — tanpa Anda harus mengetik close() manual.

Langkah 1 — Tanpa with (rawan lupa)

file = open("penjualan.txt", "r") isi = file.read() print(isi) file.close() # mudah terlupa!

Langkah 2 — Dengan with (disarankan)

with open("penjualan.txt", "r") as file: isi = file.read() print(isi) # file otomatis tertutup di sini

Perhatikan dua langkah ini baik-baik. Langkah pertama menunjukkan cara lama: Anda membuka file, membacanya, lalu wajib memanggil file.close() secara manual untuk menutupnya kembali — persis seperti menutup pintu lemari arsip setelah selesai memakainya. Masalahnya, kalau ada error di tengah proses sebelum baris close() tercapai, pintu itu bisa tertinggal terbuka, yang di dunia nyata berarti file tetap "terkunci" dipakai program dan bisa menyebabkan masalah lain. Langkah kedua adalah solusinya: blok with open(...) as file akan otomatis menutup file begitu blok selesai dijalankan, apa pun yang terjadi di dalamnya, termasuk kalau terjadi error. Karena itu, mulai hari ini, biasakan Anda selalu memakai pola with setiap kali bekerja dengan file — ini adalah standar praktik yang dipakai programmer profesional di Indonesia maupun dunia.

Menulis ke File: write() dan writelines()

Setelah file terbuka dalam mode "w" atau "a", Anda memakai write() untuk satu baris teks, atau writelines() untuk beberapa baris sekaligus dari sebuah list.

Langkah 1 — write() satu per satu

with open("catatan.txt", "a") as f: f.write("Kopi Susu - Rp18000\n") f.write("Roti Bakar - Rp15000\n")

Tanda \n = pindah baris baru; kalau lupa, semua teks akan menyambung jadi satu baris.

Langkah 2 — writelines() dari list

item = ["Kopi Susu\n", "Roti Bakar\n"] with open("catatan.txt", "a") as f: f.writelines(item)

Cocok kalau data Anda sudah berbentuk kumpulan (list) baris teks.

Sekarang mari kita praktikkan menulis. Langkah pertama menggunakan write(), yang menulis satu potong teks setiap kali dipanggil — bayangkan Anda mencatat satu transaksi kedai kopi UMKM setiap kali ada pesanan masuk. Perhatikan tanda \n di akhir setiap teks; itu adalah kode khusus yang berarti "pindah ke baris baru", dan kalau Anda lupa menambahkannya, semua transaksi akan menyatu jadi satu baris panjang yang sulit dibaca ulang nanti. Langkah kedua menggunakan writelines(), yang cocok saat Anda sudah punya kumpulan data dalam bentuk list dan ingin menuliskannya sekaligus dalam satu perintah, misalnya menyalin seluruh daftar produk baru ke file katalog. Kedua cara ini sama-sama valid; pilihannya tergantung apakah data Anda datang satu-satu secara langsung, atau sudah terkumpul dulu dalam list.

Tiga Cara Membaca File

Setelah file dibuka dalam mode "r", Python punya tiga metode baca dengan hasil yang berbeda.

read()

Satu String

Membaca seluruh isi file sekaligus jadi satu string panjang, termasuk semua tanda \n di dalamnya.

readline()

Satu Baris

Membaca satu baris saja setiap kali dipanggil — cocok dipakai berulang dalam loop while.

readlines()

List Baris

Membaca semua baris sekaligus, dikembalikan sebagai list — tiap elemen adalah satu baris teks.

Cara paling umum membaca baris demi baris: for baris in file: — Python otomatis mengiterasi file baris per baris tanpa perlu readlines() dulu.

Anda punya tiga pilihan cara membaca file, dan pilihannya tergantung kebutuhan. Metode read() cocok kalau Anda ingin menampilkan seluruh isi file sekaligus, misalnya menampilkan seluruh isi nota transaksi ke layar. Metode readline() membaca satu baris saja setiap kali dipanggil, mirip Anda membaca buku catatan satu baris lalu berhenti sejenak sebelum lanjut ke baris berikutnya — ini berguna kalau Anda ingin memproses data sedikit demi sedikit. Metode readlines() mengembalikan seluruh baris sebagai list, sehingga Anda bisa memakai indeks atau perulangan for untuk mengolah tiap baris data pelanggan UMKM satu per satu. Yang paling sering dipakai programmer, dan akan sering Anda lihat di kode nyata, adalah langsung menulis for baris in file: tanpa memanggil metode apa pun — Python cukup pintar untuk membaca file baris demi baris secara otomatis.

Hitung dari Nol: Total Penjualan dari File

File penjualan.txt milik Kedai Kopi Anira berisi 4 baris angka transaksi (Rupiah). Program membaca tiap baris dan menjumlahkannya.

150000 200000 175000 300000

Langkah	Perhitungan	Nilai
Baca baris 1	total = 0 + 150.000	Rp 150.000
Baca baris 2	total = 150.000 + 200.000	Rp 350.000
Baca baris 3	total = 350.000 + 175.000	Rp 525.000
Baca baris 4	total = 525.000 + 300.000	Rp 825.000

TOTAL PENJUALAN

Rp 825.000

dari 4 transaksi tercatat

total = 0 with open("penjualan.txt") as f: for baris in f: total += int(baris)

Sekarang mari kita hitung bersama, langkah demi langkah, persis seperti yang akan dilakukan Python di dalam program. File penjualan.txt ini berisi empat baris angka, masing-masing mewakili satu transaksi harian Kedai Kopi Anira, sebuah UMKM di Semarang. Program membaca baris pertama, mengubahnya dari teks menjadi angka memakai int(), lalu menambahkannya ke variabel total yang awalnya nol — hasilnya Rp150.000. Begitu seterusnya untuk baris kedua, ketiga, dan keempat, sampai akhirnya total mencapai Rp825.000. Perhatikan kode di sebelah kanan: pola for baris in f inilah yang membuat Python otomatis membaca file baris demi baris tanpa Anda perlu menulis readline() berulang kali secara manual.

Bagian 2 dari 3

Eksepsi: Ketika Program Berhenti

Mengenali jenis-jenis kesalahan yang membuat program Python berhenti mendadak (crash) di tengah jalan.

Kita masuk ke bagian kedua hari ini, yang sedikit berbeda nuansanya karena kita akan membahas kesalahan — hal yang sering dihindari pemula, padahal justru penting untuk dikuasai. Anda akan belajar istilah eksepsi, yaitu kesalahan yang muncul saat program sedang berjalan, bukan kesalahan penulisan kode. Kita akan lihat beberapa jenis eksepsi paling umum yang pasti akan Anda temui, dan simulasi nyata bagaimana sebuah program toko online bisa berhenti total hanya karena satu baris kode tidak siap menghadapi kejutan. Bagian ini adalah fondasi sebelum kita masuk ke solusinya di bagian ketiga: try-except.

Apa Itu Eksepsi (Exception)?

Definisi Kerja

Eksepsi (exception) adalah kesalahan yang terjadi saat program sedang berjalan (runtime), bukan kesalahan penulisan kode (syntax error) yang terdeteksi sebelum program dijalankan. Tanpa penanganan, eksepsi membuat program berhenti total (crash).

Jenis Eksepsi	Kapan Muncul	Contoh Kasus
`FileNotFoundError`	File yang dicari tidak ada	`open("stok.txt")` padahal file belum dibuat
`ValueError`	Nilai salah tipe/format	`int("sepuluh")` — teks bukan angka
`ZeroDivisionError`	Pembagian dengan nol	`total / jumlah_item` saat item = 0
`KeyError`	Kunci tidak ditemukan	Mencari data pelanggan dengan ID yang tak ada

Penting sekali Anda pahami perbedaan ini: kesalahan penulisan kode, atau syntax error, terdeteksi Python bahkan sebelum program mulai berjalan sama sekali — misalnya Anda lupa tanda titik dua setelah if. Eksepsi berbeda; ia muncul justru ketika program sudah berjalan mulus, lalu tiba-tiba bertemu situasi yang tidak bisa ditanganinya, seperti mencari file yang ternyata belum dibuat, atau mengubah kata "sepuluh" menjadi angka yang jelas tidak mungkin. Tabel ini menunjukkan empat jenis eksepsi paling sering Anda temui: file tidak ditemukan, nilai salah format, pembagian dengan nol, dan kunci data yang tidak ada dalam dictionary. Ingat baik-baik nama-nama ini, karena Anda akan memakainya langsung untuk menangkap kesalahan secara spesifik di bagian berikutnya.

Simulasi: Program Tanpa Penanganan Eksepsi

Bayangkan sistem kasir sederhana untuk toko online kecil menghitung harga per unit. Tanpa penanganan eksepsi, satu input salah bisa menghentikan seluruh program.

Langkah 1 — Kode berjalan normal

total_harga = 100000 jumlah_item = int(input("Jumlah item: ")) harga_satuan = total_harga / jumlah_item print(harga_satuan)

Kasir mengetik 4 → program mencetak 25000.0, semua lancar.

Langkah 2 — Kasir salah ketik

Jumlah item: empat Traceback (most recent call last): File "kasir.py", line 2 ValueError: invalid literal for int() with base 10: 'empat'

Program berhenti total (crash) — transaksi pelanggan yang sedang antre pun ikut terganggu.

Mari kita simulasikan skenario yang sangat mungkin terjadi di dunia nyata. Pada langkah pertama, semuanya berjalan lancar: kasir mengetik angka empat, program membagi total harga dengan jumlah item, dan hasilnya tercetak rapi. Tapi pada langkah kedua, bayangkan kasir yang kelelahan di jam sibuk salah mengetik kata "empat" alih-alih angka 4 — mungkin karena buru-buru melayani antrean pelanggan Tokopedia yang datang mengambil pesanan. Python langsung menghentikan seluruh program dengan pesan error teknis yang sama sekali tidak ramah bagi kasir awam, dan seluruh transaksi yang sedang berjalan pun ikut terhenti. Inilah persis masalah yang akan kita selesaikan mulai bagian berikutnya: bagaimana caranya program tetap "menangkap" kesalahan semacam ini dan memberi pesan yang sopan, alih-alih berhenti mendadak begitu saja.

Bagian 3 dari 3

try-except: Menjaga Program Tetap Berjalan

Struktur kode yang menangkap eksepsi sebelum ia sempat menghentikan program Anda secara paksa.

Sekarang kita masuk ke bagian solusi. Anda akan belajar struktur try-except, cara Python menandai "coba jalankan kode ini, dan kalau ada masalah, tangkap masalahnya di sini alih-alih membiarkan program berhenti total". Kita akan mulai dari struktur paling dasar, lalu berkembang ke penanganan beberapa jenis eksepsi sekaligus, sampai pola lengkap dengan else dan finally. Di akhir bagian ini Anda akan mampu menulis program kasir atau pencatat data pelanggan yang tetap berjalan mulus meskipun penggunanya sesekali salah mengetik data.

Struktur Dasar try-except

Kode di dalam blok try "dicoba" dijalankan; kalau muncul eksepsi, Python langsung lompat ke blok except yang sesuai, tanpa menghentikan program.

Langkah 1 — Tulis blok try

try: jumlah_item = int(input("Jumlah item: ")) harga = 100000 / jumlah_item print(harga)

Langkah 2 — Tangkap dengan except

except ValueError: print("Input harus berupa angka!")

Sekarang kasir mengetik "empat" → program mencetak pesan sopan, tidak crash.

Perhatikan bagaimana struktur ini bekerja langkah demi langkah. Pada langkah pertama, Anda menuliskan kode yang berisiko error di dalam blok try — di sini, mengubah input kasir menjadi angka lalu membaginya. Python akan "mencoba" menjalankan blok ini seperti biasa. Pada langkah kedua, Anda menambahkan blok except ValueError tepat setelahnya; kalau terjadi kesalahan jenis ValueError persis seperti yang kita lihat di simulasi kasir tadi, Python tidak lagi menghentikan program, melainkan langsung menjalankan kode di dalam blok except ini. Hasilnya, kasir yang salah ketik cukup melihat pesan ramah "Input harus berupa angka!", dan program tetap hidup untuk mencoba transaksi berikutnya. Inilah inti dari penanganan eksepsi: mengubah kegagalan mendadak menjadi respons yang terkendali.

Menangani Beberapa Jenis Eksepsi Sekaligus

Satu blok try boleh diikuti beberapa blok except, masing-masing untuk jenis eksepsi yang berbeda.

try: jumlah_item = int(input("Jumlah item: ")) harga_satuan = total_harga / jumlah_item print(f"Harga satuan: Rp{harga_satuan}") except ValueError: print("Input harus berupa angka, bukan huruf.") except ZeroDivisionError: print("Jumlah item tidak boleh nol.")

Kasir ketik "lima" → ditangkap oleh except ValueError.

Kasir ketik 0 → ditangkap oleh except ZeroDivisionError.

Kadang satu baris kode berisiko gagal dengan lebih dari satu cara, dan di sinilah Anda perlu beberapa blok except sekaligus. Contoh di slide ini menghitung harga satuan dengan membagi total harga dengan jumlah item — ada dua kemungkinan kegagalan berbeda. Kalau kasir mengetik teks seperti "lima" alih-alih angka, Python akan menangkapnya lewat except ValueError karena gagal mengubah teks jadi angka. Tapi kalau kasir mengetik angka 0 karena memang belum ada item terpilih, kesalahannya berbeda sama sekali — pembagian dengan nol — dan Python akan menangkapnya lewat except ZeroDivisionError yang terpisah. Python selalu mencocokkan jenis eksepsi yang muncul dengan blok except yang sesuai secara berurutan dari atas ke bawah, jadi urutan penulisan blok except ini juga penting untuk Anda perhatikan.

Melengkapi Pola: else dan finally

else — kalau TIDAK ada eksepsi

Kode di blok else hanya berjalan kalau blok try berhasil tanpa eksepsi sama sekali — dipisah dari try agar lebih jelas mana kode "inti" dan mana kode "risiko".

finally — SELALU berjalan

Kode di blok finally selalu dijalankan, baik terjadi eksepsi maupun tidak — cocok untuk membersihkan sumber daya, misalnya menutup file.

try: f = open("stok.txt", "r") except FileNotFoundError: print("File stok.txt tidak ditemukan.") else: print("File berhasil dibuka.") finally: print("Pengecekan stok selesai.")

Dua kata kunci ini melengkapi pola try-except supaya kode Anda lebih rapi dan terkendali. Blok else hanya dijalankan kalau blok try berhasil sepenuhnya tanpa masalah — ini membantu Anda memisahkan dengan jelas mana kode yang berisiko gagal, dan mana kode lanjutan yang seharusnya hanya berjalan kalau semuanya lancar. Blok finally berbeda lagi: ia akan selalu dijalankan, apa pun yang terjadi, entah try berhasil, entah except tertangkap. Bayangkan Anda membuka file stok gudang UMKM setiap pagi; apa pun hasilnya — file ditemukan atau tidak — Anda tetap ingin mencetak pesan "pengecekan stok selesai" sebagai penanda proses sudah tuntas. Pola finally ini sangat berguna untuk memastikan langkah pembersihan, seperti menutup koneksi atau file, selalu terjadi.

Hitung dari Nol: Rata-Rata Belanja dengan Penanganan Eksepsi

Kedai Kopi Anira mencatat 3 transaksi pelanggan di file belanja.txt: Rp120.000, Rp95.000, Rp130.000. Program menghitung rata-rata per transaksi.

Langkah	Perhitungan	Nilai
Jumlahkan 3 transaksi	120.000 + 95.000 + 130.000	Rp 345.000
Hitung n (jumlah baris)	len(daftar_transaksi)	3
Bagi total dengan n (try)	345.000 ÷ 3	Rp 115.000
Simulasi file kosong (except)	345.000 ÷ 0 → ditangkap	"Data kosong, rata-rata Rp0"

RATA-RATA PER TRANSAKSI

Rp 115.000

kondisi normal, 3 transaksi

try: rata2 = total / len(daftar) except ZeroDivisionError: rata2 = 0 print("Data kosong")

Mari hitung bersama sekali lagi, kali ini sambil melihat bagaimana try-except melindungi perhitungan ini. Program pertama-tama membaca tiga transaksi dari file, menjumlahkannya menjadi Rp345.000, lalu menghitung berapa baris data yang ada, yaitu tiga. Pada kondisi normal, di dalam blok try, total dibagi dengan jumlah transaksi menghasilkan rata-rata Rp115.000 per transaksi — inilah angka yang berguna bagi pemilik Kedai Kopi Anira untuk memahami pola belanja pelanggannya. Tapi bayangkan suatu hari file belanja.txt ternyata kosong karena belum ada transaksi masuk; pembagian 345.000 dengan 0 transaksi akan memicu ZeroDivisionError, dan berkat blok except, program tidak crash melainkan mencetak pesan "Data kosong" dengan rata-rata diset ke 0. Pola inilah yang membuat laporan otomatis tetap berjalan setiap hari, bahkan di hari sepi tanpa transaksi sama sekali.

Praktik Terbaik: Gabungkan with dan try-except

Pola paling aman untuk bekerja dengan file: bungkus with open() di dalam try, agar file otomatis tertutup dan eksepsi tetap tertangkap.

try: with open("data_pelanggan.txt", "r") as f: data = f.readlines() print(f"{len(data)} baris berhasil dibaca") except FileNotFoundError: print("File data_pelanggan.txt belum ada di folder ini.")

Sekarang kita gabungkan dua hal yang sudah Anda pelajari hari ini menjadi satu pola praktik terbaik. Perhatikan diagram alurnya: blok try membungkus blok with open — jadi kalau file berhasil dibuka dan diproses, ia otomatis tertutup begitu selesai, persis seperti yang kita pelajari di awal. Tapi kalau file itu ternyata tidak ada, misalnya karena karyawan baru belum sempat membuat file data_pelanggan.txt, Python akan melompat ke blok except dan menampilkan pesan yang sopan, bukan pesan error teknis yang membingungkan. Pola gabungan with dan try-except inilah yang akan Anda pakai di hampir semua program nyata yang berhubungan dengan file, karena ia menjaga dua hal sekaligus: kebersihan sumber daya sistem, dan ketahanan program terhadap kesalahan yang tak terduga.

Latihan Kelas: Sistem Pencatat Transaksi UMKM

Kerjakan berpasangan (10 menit), lalu satu pasangan akan diminta mendemonstrasikan hasilnya.

Instruksi

Buat file transaksi.txt memakai mode "a", tulis 3 transaksi contoh (nama produk & harga)
Baca kembali file itu, hitung total seluruh harga memakai perulangan
Bungkus proses pembacaan dengan try-except FileNotFoundError
Uji coba: hapus/ganti nama file lalu jalankan lagi — pastikan program tidak crash

Tantangan tambahan (opsional): Tambahkan penanganan ValueError untuk kasus harga yang tersimpan sebagai teks tidak valid, misalnya baris kosong di dalam file.

Ringkasan & Pertemuan Berikutnya

Yang Sudah Anda Kuasai

open() dengan mode r / w / a, dan pola aman with open()
Menulis file dengan write() dan writelines()
Membaca file dengan read() / readline() / readlines()
try-except-else-finally untuk menangkap eksepsi dengan tenang

Pertemuan 6 — Fungsi dalam Pemrograman. Kita akan belajar membungkus kode berulang (seperti perhitungan total & validasi input hari ini) ke dalam fungsi bernama, lengkap dengan parameter dan nilai kembali (return), agar kode Anda lebih rapi dan bisa dipakai berulang kali.

Mari kita rangkum perjalanan kita hari ini. Anda sekarang sudah bisa membuka file dengan mode yang tepat, memakai pola with open yang aman, menuliskan data ke file dengan write dan writelines, serta membaca kembali datanya dengan tiga metode berbeda sesuai kebutuhan. Yang tidak kalah penting, Anda sekarang paham cara menangkap eksepsi dengan try-except-else-finally, sehingga program yang Anda bangun tidak lagi mudah berhenti mendadak hanya karena satu kesalahan kecil dari pengguna. Minggu depan, di pertemuan keenam, kita akan belajar fungsi — cara membungkus kode yang sering Anda tulis berulang, seperti perhitungan total transaksi atau validasi input yang kita praktikkan hari ini, ke dalam satu blok kode bernama yang bisa dipanggil kapan saja. Sebelum itu, pastikan Anda menyelesaikan latihan tadi dan mencoba variasi kasusnya sendiri di rumah, karena kemampuan file dan eksepsi ini akan terus kita pakai di hampir semua pertemuan berikutnya.