# Modul dan paket Python: import, pip, venv dan pustaka dengan bahasa sederhana

URL: https://skillaria.top/id/guides/python/modul-python

Modul di Python adalah berkas .py, paket adalah folder berisi modul, dan pustaka adalah kumpulan paket untuk tugas tertentu; semuanya dimuat dengan perintah import. Pustaka pihak ketiga dipasang dengan pip (atau uv) ke dalam lingkungan virtual venv — folder terisolasi dengan interpreter dan paket milik satu proyek, supaya versi dari proyek yang berbeda tidak saling bentrok.

Modul di Python adalah berkas kode biasa, dan `import` adalah cara mengambil fungsi serta kelas darinya. Dari modul dibangun paket, dari paket dibangun pustaka, dan agar pustaka pihak ketiga dari proyek-proyek berbeda tidak saling mengganggu, pustaka dipasang ke dalam lingkungan virtual venv. Berikut seluruh rangkaiannya: apa yang terjadi saat import, bagaimana paket disusun, cara kerja pip dan venv, serta lazy import yang hadir di Python 3.15.

## Modul, paket, pustaka: apa bedanya

| Istilah | Apa itu | Contoh |
| --- | --- | --- |

| Modul | Satu berkas `.py`; nama modul = nama berkas tanpa ekstensi | `kategori.py` → `import kategori` |

| Paket | Folder berisi modul dan berkas `__init__.py` | `pengeluaran/laporan.py` → `from pengeluaran.laporan import buat` |

| Pustaka | Kumpulan modul dan paket siap pakai untuk suatu tugas | `requests`, `pandas`, `pathlib` bawaan |

| Distribusi (paket PyPI) | Arsip yang dipasang oleh pip | `pip install requests` |

Istilah «pustaka», «paket» dan «modul» sering dicampur dalam percakapan — itu wajar. Yang penting dipahami: secara teknis `import` selalu memuat modul atau paket, sedangkan pip memasang distribusi dari PyPI, dan di dalamnya terdapat paket-paket.

## Cara kerja import di Python

Ada beberapa bentuk import, dan semuanya muncul di kode nyata:

```
import math                    # seluruh modul, dipanggil dengan math.sqrt
from math import sqrt, pi      # nama tertentu saja
import datetime as dt          # dengan alias
from collections import Counter as C

print(math.sqrt(16), sqrt(9), pi)
print(dt.date.today())
```

Alias sudah umum untuk pustaka besar: `import numpy as np`, `import pandas as pd`. Bentuk `from modul import *` sebaiknya dihindari: ia mengotori namespace dan menyembunyikan asal sebuah nama.

### Apa yang sebenarnya dilakukan import

1. Mencari modul di cache `sys.modules`. Jika sudah dimuat, langsung dikembalikan.
2. Jika belum, mencari berkas di daftar folder `sys.path`: folder skrip yang dijalankan, pustaka standar, dan site-packages dari lingkungan.
3. Menjalankan berkas yang ditemukan sepenuhnya dari atas ke bawah.
4. Menyimpan objek modul di cache dan mengaitkannya dengan nama.

Dari sini ada dua kesimpulan praktis. Import ulang modul yang sama hampir tanpa biaya, karena kodenya tidak dijalankan lagi. Dan seluruh kode di tingkat atas modul, termasuk `print` dan perhitungan berat, akan berjalan saat modul diimpor.

```
import sys
for p in sys.path:
    print(p)
print("math" in sys.modules)
```

### if __name__ == "__main__"

Karena import menjalankan berkas, perlu cara untuk membedakan «saya dijalankan sebagai skrip» dan «saya diimpor». Caranya adalah variabel `__name__`: saat berkas dijalankan, nilainya `"__main__"`, saat diimpor, nilainya nama modul.

```
# kategori.py
def tebak(title: str) -> str:
    return "makan" if "kafe" in title.lower() else "lainnya"

if __name__ == "__main__":
    print(tebak("Kafe dekat rumah"))   # hanya dijalankan saat python kategori.py
```

Untuk paket ada alternatif: berkas `__main__.py` di dalamnya dan menjalankannya dengan `python -m pengeluaran`.

## Modul standar Python

Python datang dengan «baterai»: ratusan modul bawaan tersedia tanpa instalasi. Yang paling sering dipakai:

| Modul | Untuk apa |
| --- | --- |

| `os`, `sys`, `pathlib`, `shutil` | Sistem, path, berkas |

| `json`, `csv`, `pickle` | Format data |

| `datetime`, `time`, `calendar` | Tanggal dan waktu |

| `math`, `random`, `statistics`, `fractions` | Bilangan |

| `re`, `string` | Pengolahan teks |

| `collections`, `itertools`, `functools` | Struktur data dan iterator |

| `logging`, `argparse`, `subprocess` | Log, argumen baris perintah, menjalankan program |

| `asyncio`, `threading` | Asinkronisitas dan thread |

Daftar lengkap modul pustaka standar tersimpan di `sys.stdlib_module_names` (Python 3.10+). Isi sebuah modul bisa dilihat dengan `dir(math)` dan `help(math)`.

## Paket sendiri: struktur proyek

Ketika modul sudah banyak, mereka dikelompokkan menjadi paket. Tata letak yang umum dipakai adalah src-layout:

```
pengeluaran-proyek/
├── pyproject.toml
└── src/
    └── pengeluaran/
        ├── __init__.py
        ├── cli.py
        ├── parsing.py
        ├── kategori.py
        └── laporan.py
```

Di dalam paket, modul saling mengimpor lewat nama paket (`from pengeluaran.kategori import tebak`) atau secara relatif (`from .kategori import tebak`). Import relatif hanya berfungsi di dalam paket, tidak di berkas yang dijalankan langsung sebagai skrip.

## pip di Python: memasang pustaka

Pustaka pihak ketiga tersedia di PyPI, dan pemasangannya dilakukan oleh pip yang ikut dengan Python. Paling aman memanggilnya lewat interpreter — dengan begitu pustaka pasti masuk ke Python yang Anda pakai untuk menjalankan kode.

```
python -m pip install requests          # pasang
python -m pip install "pandas>=2.3"     # dengan batas versi
python -m pip install --upgrade requests
python -m pip uninstall requests        # hapus
python -m pip list                      # daftar paket terpasang
python -m pip show requests             # versi dan dependensi
python -m pip freeze > requirements.txt
python -m pip install -r requirements.txt
```

Di Windows sering dipakai launcher `py` alih-alih `python`. Jika pip tidak ditemukan, modul bawaan dapat memasangnya: `python -m ensurepip --upgrade`.

### Pustaka Python yang populer

Paket di PyPI jumlahnya ratusan ribu, tetapi sebagian besar proyek memakai daftar pendek yang sama. Mulailah dari daftar ini, bukan mencari yang eksotis.

| Tugas | Pustaka |
| --- | --- |

| Permintaan HTTP dan API | `requests`, `httpx` |

| Analisis data dan tabel | `pandas`, `numpy` |

| Grafik | `matplotlib` |

| Layanan web | `fastapi`, `django`, `flask` |

| Tes | `pytest` |

| Gambar | `pillow` (diimpor sebagai `PIL`) |

Perhatikan: nama untuk pemasangan dan nama untuk import tidak selalu sama. Dipasang dengan `pip install pillow`, tetapi ditulis `from PIL import Image`; dipasang `opencv-python`, diimpor sebagai `cv2`. Jika `import` gagal segera setelah pemasangan, periksa di dokumentasi paket dengan nama apa ia diimpor.

### Memasang pustaka di Linux

Di Debian dan Ubuntu versi baru, perintah `pip install` ke Python sistem berakhir dengan galat `externally-managed-environment` (PEP 668). Ini perlindungan: Python sistem dimiliki oleh pengelola paket OS, dan pip tidak boleh merusaknya. Solusi yang benar bukan `--break-system-packages`, melainkan lingkungan virtual.

## venv di Python: lingkungan virtual

Lingkungan virtual adalah folder tersendiri dengan salinan interpreter (tautan ke interpreter) dan site-packages sendiri. Pustaka yang dipasang di dalamnya hanya terlihat oleh proyek itu. Dengan begitu, satu proyek bisa memakai Django 4 dan proyek lain Django 5 tanpa konflik.

Modul `venv` sudah termasuk dalam Python, tidak perlu dipasang terpisah (di Debian/Ubuntu kadang diperlukan paket sistem `python3-venv`).

```
# buat lingkungan di folder .venv
python -m venv .venv

# aktifkan: Linux dan macOS
source .venv/bin/activate
# aktifkan: Windows PowerShell
.venv\Scripts\Activate.ps1

# sekarang pip memasang paket ke dalam .venv
python -m pip install requests
python -c "import sys; print(sys.prefix)"

# keluar dari lingkungan
deactivate
```

Setelah diaktifkan, di awal baris terminal muncul `(.venv)`. Folder lingkungan tidak di-commit ke git (tambahkan `.venv/` ke `.gitignore`) dan tidak dipindahkan antarmesin — sebagai gantinya, daftar dependensi disimpan dan lingkungan dibuat ulang. Jika PowerShell menolak menjalankan skrip aktivasi, izinkan untuk pengguna: `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned`.

### uv dan pyproject.toml

Proyek modern mendeskripsikan dependensinya di `pyproject.toml`. Pengelola uv yang dipakai di kursus ini menggabungkan pembuatan lingkungan dan pemasangan: `uv add pandas` mengunduh paket, menuliskannya ke `pyproject.toml`, dan mengunci versi tepatnya di `uv.lock`. Rekan Anda yang mengkloning proyek cukup menjalankan `uv sync` dan mendapatkan lingkungan yang persis sama.

```
[project]
name = "pengeluaran"
version = "0.1.0"
requires-python = ">=3.15"
dependencies = [
    "pandas>=2.3",
]

[project.scripts]
pengeluaran = "pengeluaran.cli:main"
```

## Lazy import di Python 3.15 (PEP 810)

Kebaruan utama 3.15 dalam topik ini adalah kata kunci `lazy`. Pustaka berat dimuat lama: dalam pengukuran kursus pada image `python:3.15-slim`, `import pandas` biasa memakan sekitar 415 md, sedangkan `lazy import pandas` sekitar 13 md. Untuk utilitas CLI yang sering dijalankan hanya untuk `--help`, selisihnya sangat besar.

```
lazy import pandas as pd
lazy from pengeluaran.laporan import buat_laporan

def main() -> None:
    ...
    df = pd.read_csv(path)   # pemuatan pandas yang sebenarnya — terjadi di sini
```

Alih-alih modul, nama diisi objek proksi (`types.LazyImportType`), dan import yang sebenarnya dilakukan saat nama itu pertama kali dipakai. Jika tidak pernah dipakai, waktunya tidak terbuang sama sekali.

### Batasan lazy import

- Hanya diizinkan di tingkat atas modul: di dalam fungsi, kelas, atau `try/except` akan menghasilkan `SyntaxError`.
- `lazy from x import *` tidak diizinkan.
- `ModuleNotFoundError` muncul bukan saat program dimulai, melainkan saat nama pertama kali dipakai.
- Efek samping modul (pendaftaran plugin dan sejenisnya) bergeser waktunya.

Membuat semua import menjadi lazy sekaligus dapat dilakukan dengan flag `-X lazy_imports=all` atau variabel lingkungan `PYTHON_LAZY_IMPORTS=all`, dan pengecualian diatur lewat `sys.set_lazy_imports_filter()`. Untuk kode yang juga harus berjalan di versi lama, ada atribut modul `__lazy_modules__ = ["pandas"]`: Python 3.15 akan menjadikan import yang tercantum lazy, sedangkan versi lama hanya menjalankan import biasa. Di mana waktu habis saat startup bisa dilihat dengan `python -X importtime -c "import pandas"`. Paling diuntungkan adalah program yang sering dijalankan singkat; untuk server yang berjalan lama, hampir tidak ada bedanya.

## Kesalahan umum

- `ModuleNotFoundError: No module named 'requests'` — pustaka dipasang di Python lain, atau lingkungan belum diaktifkan. Periksa dengan `python -m pip show requests` memakai interpreter yang sama.
- Berkas proyek dinamai `json.py`, `random.py`, atau `csv.py` — folder skrip berada pertama di `sys.path` dan menutupi modul standar. Python 3.13+ menyarankan «consider renaming» di pesan error. Ganti nama berkasnya dan hapus `__pycache__`.
- Import sirkular: `a.py` mengimpor `b.py`, dan `b.py` mengimpor `a.py`. Pindahkan bagian bersama ke modul ketiga, atau impor di dalam fungsi.
- Menjalankan `pip` di dalam interpreter (`>>> pip install`) menghasilkan `SyntaxError`. Perintah pip dijalankan di terminal.

## Ringkasan

Modul adalah berkas, paket adalah folder berisi modul, pustaka adalah kumpulan siap pakai; `import` mencari modul di cache dan di `sys.path`, lalu menjalankannya sekali saja. Pustaka pihak ketiga dipasang dengan pip atau uv hanya ke dalam lingkungan virtual venv — dengan begitu proyek tidak saling mengganggu dan lingkungannya mudah direproduksi. Topik ini dipraktikkan dalam kursus Python: pencatat pengeluaran diubah menjadi paket dengan dependensi dan startup cepat berkat lazy import.

## FAQ

**Perlukah membuat venv untuk setiap proyek?**

Ya, itu praktik yang baik: setiap proyek punya versi pustaka sendiri, dan lingkungan terpisah mencegah konflik serta menjaga Python sistem tetap bersih.

**Apa bedanya pip dan uv?**

pip hanya memasang paket, sedangkan uv juga membuat lingkungan, menuliskan dependensi ke pyproject.toml, dan mengunci versi tepat di lock-file; selain itu jauh lebih cepat.

**Bagaimana melihat daftar pustaka Python yang terpasang?**

Jalankan python -m pip list di lingkungan yang tepat; pip freeze menampilkan daftar yang sama dalam format requirements.txt.

**Di mana modul yang terpasang disimpan?**

Di folder site-packages dari lingkungan yang aktif. Lokasi modul tertentu bisa dilihat dari atributnya __file__, misalnya import requests; print(requests.__file__).

**Bisakah folder venv dipindahkan ke komputer lain?**

Tidak, lingkungan terikat pada path dan interpreter mesin tempatnya dibuat. Yang dipindahkan adalah daftar dependensi, lalu lingkungan dibuat ulang.


---
Source: Skillaria.Top (https://skillaria.top)