Python Functions dan Struktur Data: List, Tuple, Dict, dan Set

Setelah paham variabel, tipe data, conditional, dan loop, langkah berikutnya adalah membuat kode lebih rapi. Di sinilah function dan struktur data mulai terasa penting.

Function membantu kamu memberi nama pada logic. Struktur data membantu kamu menyimpan banyak nilai dengan bentuk yang sesuai. Kalau dua hal ini dipakai dengan benar, script Python yang awalnya berantakan bisa berubah menjadi program yang lebih mudah dibaca, dites, dan dikembangkan.

Cara membacanya sederhana: function menjawab “pekerjaan apa yang dilakukan?”, sedangkan struktur data menjawab “nilai seperti apa yang sedang disimpan?”. Jangan memilih struktur data karena namanya terdengar canggih. Pilih berdasarkan apakah urutan, perubahan, key, atau keunikan nilai memang penting untuk kasusmu.

Cara berpikir sebelum menulis kode

Sebelum membuat function, tulis dulu input dan output-nya. Contohnya, calculate_total(items) menerima kumpulan harga dan mengembalikan satu angka. Batas seperti ini membuat function lebih mudah diuji karena kita tahu apa yang boleh masuk dan apa yang diharapkan keluar.

Bedakan return dan print(). return menyerahkan data kepada kode pemanggil, sedangkan print() hanya menampilkan teks ke terminal. Function yang memakai return biasanya lebih fleksibel karena hasilnya dapat dihitung lagi, dibandingkan, disimpan, atau dikirim ke UI.

Untuk struktur data, tanyakan tiga hal: apakah data punya urutan, apakah data perlu diubah, dan bagaimana kamu akan mencari satu nilai? List cocok untuk kumpulan berurutan yang bisa berubah. Tuple cocok untuk kelompok nilai kecil yang tidak perlu dimodifikasi. Dictionary cocok saat setiap nilai punya nama key. Set cocok saat urutan tidak penting dan duplikasi harus dibuang.

Recap singkat

Di artikel sebelumnya, kita sudah menulis kode seperti ini:

# File: 01-recap-grade-checker.py
name = input("Name: ")
score = int(input("Score: "))

if score >= 80:
    result = "pass"
else:
    result = "review again"

print(f"{name}: {result}")

Kode itu berjalan, tapi kalau logic penilaian dipakai di banyak tempat, kita akan mengulang kondisi yang sama berkali-kali. Function membantu menghindari pengulangan seperti itu.

Membuat function dengan def

Function dibuat dengan def.

# File: 02-get-result.py
def get_result(score):
    if score >= 80:
        return "pass"

    return "review again"

print(get_result(85))
print(get_result(60))

return mengirim nilai keluar dari function. Setelah return dijalankan, function selesai.

Function yang baik biasanya punya nama yang menjelaskan tujuan. get_result() lebih jelas daripada process() jika tugasnya memang menentukan hasil nilai.

Parameter dan return value

Parameter adalah input untuk function.

# File: 03-greet.py
def greet(name):
    return f"Hello, {name}"

message = greet("Ayu")
print(message)

Function bisa punya lebih dari satu parameter:

# File: 04-calculate-total.py
def calculate_total(price, quantity):
    return price * quantity

total = calculate_total(25_000, 3)
print(total)

Gunakan return value jika hasilnya perlu dipakai lagi. Gunakan print() hanya saat kamu benar-benar ingin menampilkan sesuatu ke user.

Default parameter

Default parameter berguna saat ada nilai yang sering sama.

# File: 05-default-parameter.py
def format_price(amount, currency="IDR"):
    return f"{currency} {amount}"

print(format_price(50000))
print(format_price(50000, "USD"))

Hindari default parameter mutable seperti list kosong. Ini terlihat kecil, tapi bisa membuat bug yang sulit dilacak.

# File: 06-safe-list-default.py
def add_item(item, items=None):
    if items is None:
        items = []

    items.append(item)
    return items

Pola None seperti ini lebih aman untuk nilai default yang berupa list atau dictionary.

Scope sederhana

Variabel yang dibuat di dalam function disebut local variable.

# File: 07-local-scope.py
def calculate_tax(price):
    tax = price * 0.1
    return tax

print(calculate_tax(100_000))

Variabel tax hanya hidup di dalam function. Ini bagus, karena function tidak mengotori bagian lain program.

Hindari terlalu sering mengubah global variable dari dalam function. Lebih mudah membaca function yang menerima input lewat parameter dan mengembalikan output lewat return.

List untuk kumpulan data berurutan

List dipakai saat kamu punya banyak item dan urutannya penting.

# File: 08-list-indexing.py
scores = [80, 90, 85]

print(scores[0])
print(scores[-1])

Index dimulai dari 0. scores[0] mengambil item pertama, sedangkan scores[-1] mengambil item terakhir.

Kamu bisa menambah item dengan append():

# File: 09-list-append.py
scores.append(95)
print(scores)

Untuk memproses semua item, gunakan loop:

# File: 10-loop-list.py
for score in scores:
    print(score)

Tuple untuk data yang tidak perlu berubah

Tuple mirip list, tapi isinya tidak bisa diubah setelah dibuat.

# File: 11-tuple-coordinate.py
coordinate = (-6.2, 106.8)
latitude = coordinate[0]
longitude = coordinate[1]

print(latitude, longitude)

Gunakan tuple untuk data kecil yang sifatnya tetap, misalnya koordinat, pasangan nilai, atau hasil function yang memang tidak perlu dimodifikasi.

Dictionary untuk data key-value

Dictionary menyimpan data dengan pasangan key dan value.

# File: 12-student-dictionary.py
student = {
    "name": "Ayu",
    "scores": [80, 90, 85],
    "active": True,
}

print(student["name"])
print(student["scores"])

Dictionary cocok untuk merepresentasikan object sederhana: user, product, order, config, dan sebagainya.

Untuk menghindari error saat key belum tentu ada, gunakan get():

# File: 13-dictionary-get.py
nickname = student.get("nickname", "-")
print(nickname)

Set untuk nilai unik

Set menyimpan nilai unik dan cocok untuk membership check.

# File: 14-unique-tags.py
tags = {"python", "beginner", "python"}
print(tags)

Walaupun "python" ditulis dua kali, set hanya menyimpannya sekali.

Set juga cepat untuk mengecek apakah nilai ada:

# File: 15-membership-check.py
allowed_roles = {"admin", "editor"}

if "admin" in allowed_roles:
    print("allowed")

Gunakan set saat urutan tidak penting dan kamu ingin nilai unik.

List comprehension

List comprehension adalah cara ringkas membuat list baru dari list lama.

# File: 16-passed-scores.py
scores = [60, 75, 90, 85]
passed_scores = [score for score in scores if score >= 80]

print(passed_scores)

Gunakan secukupnya. Kalau expression mulai terlalu panjang, loop biasa sering lebih mudah dibaca.

Mini project: rata-rata nilai siswa

Sekarang gabungkan function, list, dan dictionary.

# File: 17-average-student.py
def calculate_average(scores):
    total = sum(scores)
    return total / len(scores)

student = {
    "name": "Ayu",
    "scores": [80, 90, 85],
}

average = calculate_average(student["scores"])
print(student["name"], average)

Versi dengan beberapa siswa:

# File: 18-average-students.py
def calculate_average(scores):
    if len(scores) == 0:
        return 0

    return sum(scores) / len(scores)

students = [
    {"name": "Ayu", "scores": [80, 90, 85]},
    {"name": "Budi", "scores": [70, 75, 78]},
    {"name": "Citra", "scores": [95, 92, 90]},
]

for student in students:
    average = calculate_average(student["scores"])
    print(f"{student['name']}: {average}")

Perhatikan bagaimana function membuat logic rata-rata tidak perlu ditulis ulang.

Kapan memakai struktur data yang mana?

Pakai list saat kamu punya kumpulan item berurutan dan bisa berubah.

Pakai tuple saat data kecil, berurutan, dan tidak perlu berubah.

Pakai dictionary saat kamu butuh nama field, misalnya name, email, atau price.

Pakai set saat kamu butuh nilai unik atau sering mengecek apakah item ada.

Pilihan struktur data yang tepat membuat kode lebih sederhana. Kalau kamu sering bingung, mulai dari list atau dictionary. Nanti refactor ketika kebutuhan lebih jelas.

Kesalahan umum

Kesalahan pertama adalah membuat function yang melakukan terlalu banyak hal.

# File: 19-too-much-work.py
def process_everything():
    # input user
    # hitung total
    # simpan file
    # print laporan
    pass

Lebih baik pecah menjadi function kecil: read_input(), calculate_total(), save_data(), dan print_report().

Kesalahan kedua adalah mutable default argument.

# File: 20-mutable-default-bug.py
def add_score(score, scores=[]):
    scores.append(score)
    return scores

Gunakan None sebagai default, lalu buat list baru di dalam function.

Kesalahan ketiga adalah memilih dictionary untuk semua hal. Dictionary fleksibel, tapi kalau data mulai punya behavior, nanti kamu bisa belajar class dan dataclass di artikel OOP.

Latihan mini

Coba buat:

• Function calculate_total(items) yang menerima list harga dan mengembalikan total.
• Function is_even(number) yang mengembalikan True jika angka genap.
• Dictionary untuk menyimpan data produk: name, price, stock.
• Set untuk menyimpan daftar tag unik dari beberapa artikel.
• List comprehension untuk mengambil angka di atas 50 dari sebuah list.

Ketik semua contoh sendiri. Jangan hanya membaca. Python baru terasa masuk akal saat kamu melihat data berubah dari satu bentuk ke bentuk lain.

Checklist sebelum lanjut

Sebelum pindah ke materi file, coba jelaskan kembali programmu tanpa melihat kode. Function apa yang menerima input? Function mana yang mengembalikan hasil? Data apa yang disimpan sebagai list, dictionary, atau set, dan kenapa?

Uji juga batas sederhana: list kosong, satu item, nilai duplikat, dan input yang tidak sesuai tipe. Jika function gagal pada kasus kosong, tentukan perilaku yang kamu inginkan, misalnya mengembalikan 0, mengembalikan list kosong, atau melempar error yang jelas. Tidak ada jawaban yang selalu benar; yang penting keputusannya sengaja dibuat dan konsisten.

Lanjut ke file, error, dan module

Setelah function dan struktur data, kamu siap membuat script yang membaca file, menangani error, dan memecah kode ke beberapa file. Lanjutkan ke Python Files, Errors, dan Modules.

Kalau ingin mengulang fondasi sebelumnya, buka lagi Python Fundamentals: Variabel, Tipe Data, dan Control Flow.