Belajar Python Module Package

pas project python kalian makin gede, nyimpen semua kode di satu file itu bakal susah dirawat. solusinya, module dan package. sebelumnya, pastikan dulu sudah paham function dan lambda Python, karena module dan package itu sangat membantu buat ngatur fungsi dan class di project yang besar.

saya sendiri ngerasain momen “harus mulai pakai module” pas file script saya udah lebih dari 500 baris, dan nyari satu fungsi di dalemnya butuh waktu berjam-jam. setelah dipecah ke beberapa module, logika, koneksi data, dan tampilan jadi terpisah, kode langsung jauh lebih gampang dirawat. materi ini mungkin keliatan sepele, tapi dampaknya gede di project yang bener-bener dipakai.

1. Apa Itu Module?

module itu file .py yang berisi kode python, misalnya fungsi, class, dan variabel. dengan module, kode bisa diorganisir secara logis.

# utils.py, file module
def sapa(nama):
    return f"Halo {nama}!"

PI = 3.14159

class Kalkulator:
    def tambah(self, a, b):
        return a + b

module ini tinggal di-import di file lain.

2. Import Module

# main.py, file utama
import utils

print(utils.sapa("Andi"))  # Halo Andi!
print(utils.PI)            # 3.14159
k = utils.Kalkulator()
print(k.tambah(5, 3))      # 8

Variasi Import

# Import spesifik
from utils import sapa, PI

# Alias
import utils as ut
ut.sapa("Andi")

# Import semua (tidak disarankan)
from utils import *

# Import class
from utils import Kalkulator

3. Membuat Package

package itu folder yang berisi beberapa module plus file __init__.py.

project/
├── main.py
└── paket/
    ├── __init__.py
    ├── matematika.py
    └── string_utils.py

# paket/matematika.py
def tambah(a, b):
    return a + b

def kali(a, b):
    return a * b

# paket/string_utils.py
def capital(s):
    return s.upper()

def reverse(s):
    return s[::-1]

# main.py
from paket import matematika, string_utils

print(matematika.tambah(5, 3))  # 8
print(string_utils.capital("halo"))  # HALO

init.py

file ini bisa kosong atau berisi inisialisasi package:

# paket/__init__.py
from .matematika import tambah
from .string_utils import capital

# Sekarang di main.py bisa:
from paket import tambah, capital

4. name == “main”

blok ini bikin file bisa dijalankan langsung atau di-import, tergantung kebutuhan:

# kalkulator.py
def tambah(a, b): return a + b
def kurang(a, b): return a - b

if __name__ == "__main__":
    # Kode ini hanya jalan saat file dijalankan langsung
    print("Testing kalkulator...")
    print(tambah(10, 5))
    print(kurang(10, 5))

kalau di-run langsung, python kalkulator.py, bagian testing dijalankan. tapi kalau di-import, import kalkulator, testing tidak ikut jalan.

5. Sub-package

package juga bisa punya sub-package:

project/
├── main.py
└── app/
    ├── __init__.py
    ├── models/
    │   ├── __init__.py
    │   └── user.py
    └── views/
        ├── __init__.py
        └── dashboard.py

# app/models/user.py
class User:
    def __init__(self, nama):
        self.nama = nama

# main.py
from app.models.user import User
u = User("Andi")

6. Mencari Module (sys.path)

python nyari module di direktori yang terdaftar di sys.path:

import sys
print(sys.path)

# Tambah direktori pencarian
sys.path.append("/path/to/folder")

7. Menulis Module yang Baik

1. satu module satu tanggung jawab, matematika.py cuma berisi fungsi matematika
2. pakai if __name__ buat testing pas di-run langsung
3. hindari from module import *, bisa menyebabkan konflik nama. import * ini pernah jadi sumber bug “fungsi tiba-tiba berubah perilaku” yang paling susah saya lacak
4. pakai __all__ buat kontrol ekspor:

# matematika.py
__all__ = ["tambah", "kali"]  # Hanya ini yang di-export saat *

def tambah(a, b): return a + b
def kali(a, b): return a * b
def _private(): pass  # Tidak diekspor

8. Studi Kasus

biar makin kebayang, ini contoh struktur project perpustakaan sederhana:

struktur_project/
├── main.py
└── perpustakaan/
    ├── __init__.py
    ├── anggota.py
    ├── buku.py
    └── peminjaman.py

# perpustakaan/buku.py
class Buku:
    def __init__(self, judul, penulis):
        self.judul = judul
        self.penulis = penulis
    
    def info(self):
        return f"{self.judul} - {self.penulis}"

# perpustakaan/__init__.py
from .buku import Buku
from .anggota import Anggota

__all__ = ["Buku", "Anggota"]

# main.py
from perpustakaan import Buku

buku = Buku("Python 101", "Andi")
print(buku.info())

9. Absolute vs Relative Import: Jangan Sampai Salah Jalankan

pas sudah jadi package, ada dua cara nulis import di dalamnya. ini yang paling sering bikin pemula bingung, dan errornya kedengeran misterius.

Absolute import nulis alamat lengkap dari root project:

# paket/string_utils.py mau pakai fungsi dari paket/matematika.py
from paket.matematika import tambah   # absolute, jelas dari mana

Relative import nulis alamat relatif dari file sekarang:

# masih di paket/string_utils.py
from .matematika import tambah   # titik satu = folder yang sama
from ..app.models.user import User  # titik dua = naik satu folder

kapan pakai yang mana? kalau kalian nulis kode di dalam package yang nantinya di-install atau dijalankan sebagai module, relative import bikin refactoring gampang, pindah folder tidak usah ganti semua import. tapi ada jebakannya.

jika file di dalam package kalian jalankan langsung dengan python paket/string_utils.py, relative import langsung error ImportError: attempted relative import with no known parent package. solusinya, jalankan sebagai module dari root project:

python -m paket.string_utils   # benar, python tahu parent package-nya

saya sendiri pernah menghabiskan sore karena ini, kirain kodenya salah, ternyata cara menjalankannya yang keliru 🙂 jadi biasakan python -m buat ngetes file di dalam package, bukan python path/ke/file.py.

menurut saya, untuk project kecil-menengah, pakai absolute import dulu biar kebaca. begitu struktur sudah stabil dan kalian sering mindahin module antar package, baru pertimbangkan relative.

10. Dua Error yang Paling Sering Bikin Kalian Stuck

ModuleNotFoundError: No module named ‘paket’

ini 90% karena python tidak menemukan folder kalian di sys.path. cek tiga hal berurutan:

1. apakah folder package ada __init__.py? di python 3.3+ memang bisa tanpa, tapi untuk package biasa tetap taruh file kosong biar jelas, dan biar __all__ kepakai.
2. apakah kalian menjalankan dari root project yang benar? kalau main.py di root, import paket baru ketemu. kalau kalian cd ke dalam folder paket lalu import paket, ya tidak ketemu.
3. apakah nama file dan folder tidak bentrok dengan nama library standar? jangan bikin file random.py atau email.py di project, nanti import random malah ngambil file kalian.

debug cepatnya:

import sys, pprint
pprint.pprint(sys.path)   # lihat daftar folder yang dicari python

kalau folder project kalian tidak ada di list, baru sys.path.append, tapi itu obat sementara. yang rapi, jalankan project selalu dari root dengan python -m.

Circular Import

contoh yang bikin pusing:

# a.py
from b import fungsi_b
def fungsi_a(): return "a"
# b.py
from a import fungsi_a
def fungsi_b(): return "b"

begitu import a, python buka a.py, ketemu from b import, buka b.py, ketemu from a import lagi, lingkaran. hasilnya ImportError atau fungsi_a masih None.

solusinya ada dua, dan keduanya pernah saya pakai:

• pindahkan import ke dalam fungsi yang butuh, bukan di atas file, jadi import baru jalan saat fungsi dipanggil, bukan saat file di-load.
• atau refactor, keluarkan bagian yang dipakai bersama ke file ketiga c.py, lalu a dan b sama-sama import dari c.

jangan khawatir kalau belum ketemu kasus ini sekarang, begitu project kalian di atas 10 module, cepat atau lambat pasti ketemu. ingat polanya, jadi tidak ngulik berjam-jam.

Kesimpulan

intinya begini:

• module = file .py, berisi fungsi/class/variabel
• package = folder + __init__.py, berisi module
• import bisa import module, from module import func, atau pake as alias
• __name__ == "__main__", kode yang cuma jalan saat run langsung
• __init__.py, inisialisasi package, kontrol ekspor pakai __all__

belajar python function dan lambda belajar python list tuple set dictionary