Memahami Namespace dan Scope Variabel dalam Python

Bahasa pemrograman Python memiliki berbagai konsep dasar yang perlu dipahami untuk menghasilkan program yang terstruktur, mudah dibaca, dan dapat dikembangkan. Salah satu konsep yang berperan penting dalam pengelolaan variabel, fungsi, serta objek adalah *namespace* dan *scope*. Kedua konsep ini berkaitan erat dengan cara Python mengenali nama, menyimpan hubungan antara nama dan objek, serta menentukan bagian program yang dapat mengakses nama tersebut. Pemahaman terhadap namespace dan scope membantu programmer menghindari kesalahan penggunaan variabel, terutama ketika sebuah program terdiri atas banyak fungsi, modul, atau bagian kode yang saling berhubungan.

Sebelum mempelajari materi tentang cara Memahami Namespace dan Scope Variabel dalam Python, terlebih dahulu pelajari materi tentang: Fungsi Anonim dalam Python, Memahami Iterator dalam Python, dan Mengenal Generator dalam Python.

Dalam sebuah program Python, nama digunakan untuk merujuk pada berbagai objek, seperti bilangan, teks, daftar, fungsi, kelas, dan modul. Nama tersebut memungkinkan programmer menggunakan objek tanpa harus berinteraksi langsung dengan cara objek disimpan di dalam memori. Sebagai contoh, pernyataan `nilai = 85` menghubungkan nama `nilai` dengan objek bilangan bulat bernilai 85. Ketika nama `nilai` dipanggil, Python akan mencari objek yang terhubung dengan nama tersebut berdasarkan aturan pencarian nama yang berlaku.

Persoalan mulai muncul ketika program memiliki banyak variabel dengan nama yang sama, tetapi digunakan dalam fungsi atau bagian program yang berbeda. Tanpa mekanisme pengelolaan nama yang tepat, penggunaan nama dapat menimbulkan kebingungan. Python mengatasi persoalan tersebut melalui namespace, yaitu ruang penamaan yang menghubungkan nama dengan objek tertentu. Sementara itu, scope menentukan wilayah program yang dapat mengakses nama secara langsung. Kedua konsep ini menjadi dasar penting dalam memahami perilaku variabel dan fungsi ketika program dijalankan.

Pengertian Namespace dalam Python

Namespace merupakan kumpulan nama yang dipetakan ke objek tertentu. Dalam Python, namespace dapat dipahami sebagai mekanisme yang menghubungkan nama variabel, fungsi, kelas, dan objek lainnya dengan nilai atau objek yang dirujuk. Hubungan tersebut memungkinkan sebuah nama dikenali dalam lingkungan tertentu tanpa harus selalu memiliki nama yang unik di seluruh program.

Sebagai contoh, perhatikan kode berikut:
nama = "Andi"
umur = 17
nilai = 90
print(nama)
print(umur)
print(nilai)

Pada kode tersebut, terdapat tiga nama, yaitu `nama`, `umur`, dan `nilai`. Masing-masing nama terhubung dengan objek yang berbeda. Nama `nama` merujuk pada teks `"Andi"`, nama `umur` merujuk pada bilangan `17`, sedangkan nama `nilai` merujuk pada bilangan `90`. Python menggunakan hubungan tersebut ketika menjalankan pernyataan `print()`.

Namespace tidak hanya berisi nama variabel. Nama fungsi, kelas, modul yang diimpor, dan sejumlah objek lainnya juga dapat menjadi bagian dari namespace. Sebagai contoh, ketika sebuah fungsi didefinisikan menggunakan kata kunci `def`, nama fungsi tersebut dihubungkan dengan objek fungsi yang terbentuk. Demikian pula, ketika sebuah modul diimpor, nama modul dapat digunakan untuk mengakses fungsi, kelas, atau atribut yang disediakan oleh modul tersebut.

Keberadaan namespace memungkinkan nama yang sama digunakan dalam lingkungan yang berbeda. Misalnya, variabel bernama `nilai` dapat berada di tingkat program utama dan juga di dalam sebuah fungsi. Kedua nama tersebut dapat merujuk pada objek yang berbeda karena berada dalam namespace yang berbeda. Dengan demikian, penggunaan nama yang sama tidak selalu menimbulkan benturan selama setiap nama digunakan sesuai dengan lingkungan penamaannya.

Namespace juga berkaitan dengan keteraturan program. Ketika sebuah program dibagi menjadi beberapa modul dan fungsi, setiap bagian memiliki lingkungan penamaan yang sesuai dengan kebutuhannya. Pemisahan tersebut membantu mengurangi kemungkinan terjadinya benturan nama serta mempermudah programmer memahami hubungan antara variabel dan objek yang digunakan.

Jenis-Jenis Namespace dalam Python

Python memiliki beberapa jenis namespace yang terbentuk pada lingkungan berbeda. Jenis-jenis tersebut mencakup namespace bawaan, namespace global, namespace lokal, serta namespace yang berkaitan dengan fungsi bertingkat. Setiap namespace memiliki cakupan dan masa hidup yang berbeda, bergantung pada bagaimana dan kapan namespace tersebut dibuat.

Namespace Bawaan (*Built-in Namespace*)

Namespace bawaan merupakan namespace yang menyediakan nama-nama yang telah tersedia dalam Python. Nama tersebut dapat digunakan tanpa perlu didefinisikan terlebih dahulu oleh programmer. Namespace ini tersedia ketika interpreter Python berjalan dan pada umumnya tetap tersedia selama interpreter tersebut aktif.

Contoh nama bawaan Python adalah `print()`, `len()`, `sum()`, `max()`, `min()`, `type()`, dan `range()`. Fungsi-fungsi tersebut memiliki kegunaan masing-masing. Fungsi `print()` digunakan untuk menampilkan informasi, `len()` digunakan untuk mengetahui jumlah elemen atau panjang suatu objek tertentu, sedangkan `sum()` digunakan untuk menjumlahkan nilai dalam objek yang dapat dijumlahkan.

Perhatikan contoh berikut:
data = [10, 20, 30, 40]
print("Jumlah elemen:", len(data))
print("Total nilai:", sum(data))
print("Nilai terbesar:", max(data))

Hasil program tersebut adalah:
Jumlah elemen: 4
Total nilai: 100
Nilai terbesar: 40

Pada contoh tersebut, `print()`, `len()`, `sum()`, dan `max()` dapat langsung digunakan karena merupakan nama bawaan Python. Programmer tidak perlu membuat definisi fungsi sendiri untuk memperoleh kemampuan dasar tersebut.

Meskipun demikian, nama bawaan sebaiknya tidak digunakan kembali sebagai nama variabel apabila tidak diperlukan. Misalnya, penggunaan `sum = 100` dapat menutupi akses terhadap fungsi bawaan `sum()` dalam lingkungan penamaan yang bersangkutan. Akibatnya, pemanggilan `sum(data)` berikutnya dapat menimbulkan kesalahan karena nama `sum` tidak lagi merujuk pada fungsi bawaan, melainkan pada bilangan `100`.

Oleh karena itu, memahami namespace bawaan membantu programmer menggunakan fasilitas Python secara tepat dan menghindari penamaan yang berpotensi mengganggu fungsi bawaan.

Namespace Global (*Global Namespace*)

Namespace global merupakan lingkungan penamaan yang berkaitan dengan suatu modul. Ketika sebuah berkas Python dijalankan, nama-nama yang didefinisikan pada tingkat modul akan ditempatkan dalam namespace global modul tersebut. Variabel yang didefinisikan di luar fungsi dan kelas umumnya termasuk dalam lingkungan ini.

Sebagai contoh, perhatikan kode berikut:
sekolah = "SMA Nusantara"
tahun_ajaran = 2026

def tampilkan_sekolah():
print(sekolah)
print(tahun_ajaran)

tampilkan_sekolah()

Hasil program tersebut adalah:
SMA Nusantara
2026

Variabel `sekolah` dan `tahun_ajaran` didefinisikan di luar fungsi `tampilkan_sekolah()`. Oleh karena itu, keduanya merupakan nama global pada modul tersebut. Ketika fungsi dijalankan, Python dapat mencari dan menemukan kedua nama tersebut dalam namespace global karena tidak terdapat variabel lokal dengan nama yang sama.

Namespace global berguna untuk menyimpan informasi yang diperlukan oleh beberapa fungsi dalam satu modul. Sebagai contoh, sebuah program dapat memiliki variabel yang menyimpan nama aplikasi, nilai batas tertentu, atau konfigurasi umum yang dibutuhkan oleh sejumlah fungsi.

Namun, penggunaan variabel global secara berlebihan dapat menyulitkan pemeliharaan program. Apabila banyak fungsi mengubah nilai global yang sama, perubahan perilaku program menjadi lebih sulit ditelusuri. Karena itu, variabel global sebaiknya digunakan secara terencana, terutama untuk informasi yang memang perlu tersedia pada tingkat modul.

Perlu dipahami bahwa istilah global tidak selalu berarti satu nama berlaku secara mutlak untuk seluruh berkas dalam sebuah proyek. Setiap modul memiliki namespace globalnya sendiri. Nama yang didefinisikan dalam satu modul tidak otomatis menjadi nama global dalam modul lain. Modul lain perlu mengimpor modul tersebut atau menggunakan mekanisme akses yang sesuai untuk memanfaatkan nama yang disediakannya.

Namespace Lokal (*Local Namespace*)

Namespace lokal merupakan lingkungan penamaan yang terbentuk ketika suatu fungsi dipanggil. Nama variabel dan parameter yang didefinisikan di dalam fungsi biasanya berada dalam lingkungan lokal fungsi tersebut. Nama-nama itu dapat digunakan secara langsung di dalam fungsi, tetapi tidak otomatis tersedia di luar fungsi.

Perhatikan contoh berikut:
def hitung_luas():
panjang = 8
lebar = 5
luas = panjang * lebar
print("Luas:", luas)
hitung_luas()

Hasil program tersebut adalah:
Luas: 40

Variabel `panjang`, `lebar`, dan `luas` didefinisikan di dalam fungsi `hitung_luas()`. Ketiganya merupakan nama lokal yang dapat digunakan selama pelaksanaan fungsi tersebut. Ketika fungsi dipanggil, Python menyediakan lingkungan yang diperlukan untuk mengelola nama-nama lokalnya.

Jika programmer mencoba mengakses variabel `luas` dari luar fungsi, seperti pada kode berikut, program akan mengalami kesalahan.
def hitung_luas():
panjang = 8
lebar = 5
luas = panjang * lebar
print(luas)
hitung_luas()
print(luas)

Pemanggilan `print(luas)` di luar fungsi menimbulkan `NameError` apabila tidak ada nama global `luas` yang dapat ditemukan. Hal itu terjadi karena variabel `luas` hanya didefinisikan dalam lingkungan lokal fungsi `hitung_luas()`.

Apabila hasil perhitungan perlu digunakan kembali di luar fungsi, programmer dapat mengembalikan hasil tersebut menggunakan `return`.
def hitung_luas():
panjang = 8
lebar = 5
luas = panjang * lebar
return luas
hasil = hitung_luas()
print("Luas:", hasil)

Hasilnya adalah:
Luas: 40

Dalam contoh tersebut, nilai yang dikembalikan oleh fungsi disimpan ke dalam variabel `hasil`. Variabel `hasil` berada dalam lingkungan tempat pemanggilan fungsi dilakukan, sedangkan variabel `luas` tetap menjadi nama lokal fungsi. Pendekatan ini membuat fungsi lebih mudah digunakan kembali tanpa harus membuka akses langsung terhadap seluruh variabel internalnya.

Namespace pada Fungsi Bertingkat

Python memungkinkan sebuah fungsi didefinisikan di dalam fungsi lainnya. Struktur ini disebut fungsi bertingkat (*nested function*). Setiap fungsi memiliki lingkungan penamaan yang berkaitan dengan pelaksanaan fungsinya. Oleh sebab itu, fungsi bagian dalam dapat memiliki nama lokal sendiri sekaligus mengakses nama tertentu dari fungsi luar sesuai dengan aturan scope.

Contoh berikut memperlihatkan hubungan tersebut:
def fungsi_luar():
pesan_luar = "Pesan dari fungsi luar"

def fungsi_dalam():
pesan_dalam = "Pesan dari fungsi dalam"
print(pesan_luar)
print(pesan_dalam)

fungsi_dalam()
fungsi_luar()

Hasil program tersebut adalah:
Pesan dari fungsi luar
Pesan dari fungsi dalam

Variabel `pesan_luar` didefinisikan di dalam `fungsi_luar()`, sedangkan `pesan_dalam` didefinisikan di dalam `fungsi_dalam()`. Fungsi bagian dalam dapat membaca `pesan_luar` karena nama tersebut berada pada lingkungan fungsi yang melingkupinya. Sebaliknya, variabel `pesan_dalam` tidak otomatis dapat digunakan langsung oleh fungsi luar karena nama itu berada dalam lingkungan lokal fungsi bagian dalam.

Konsep ini penting ketika membuat fungsi yang memerlukan informasi dari fungsi pembungkusnya. Fungsi bertingkat sering digunakan dalam pembuatan fungsi pembantu, pengelolaan keadaan tertentu, dan teknik pemrograman lanjutan seperti *closure*.

Pengertian Scope dalam Python

Scope atau ruang lingkup adalah wilayah program tempat suatu nama dapat diakses secara langsung. Jika namespace menjelaskan hubungan antara nama dan objek, scope menjelaskan tempat nama tersebut dapat ditemukan dan digunakan. Dengan kata lain, namespace berkaitan dengan pengelolaan nama, sedangkan scope berkaitan dengan jangkauan akses terhadap nama.

Sebuah nama yang tersedia dalam suatu scope belum tentu dapat diakses secara langsung dari semua bagian program. Sebagai contoh, variabel lokal yang didefinisikan dalam sebuah fungsi umumnya tidak dapat diakses dari luar fungsi. Sebaliknya, nama global pada sebuah modul dapat dibaca dari dalam fungsi yang berada di modul tersebut, selama tidak ada aturan penamaan lain yang menghalangi atau mengubah cara nama itu diakses.

Python menggunakan aturan pencarian nama yang memungkinkan interpreter menentukan objek yang dimaksud ketika sebuah nama digunakan. Dalam fungsi, pencarian nama mengikuti urutan lingkungan lokal, lingkungan fungsi yang melingkupi jika ada, lingkungan global modul, kemudian lingkungan bawaan. Urutan ini sering diringkas dengan istilah LEGB, yaitu *Local*, *Enclosing*, *Global*, dan *Built-in*.

Local Scope

Local scope merupakan ruang lingkup yang berkaitan dengan fungsi yang sedang dijalankan. Nama lokal biasanya mencakup parameter fungsi dan variabel yang ditetapkan di dalam fungsi tersebut. Nama lokal digunakan untuk mengelola data yang hanya diperlukan dalam pelaksanaan fungsi.

Contohnya sebagai berikut:
def sapa():
nama = "Dina"
print("Halo,", nama)
sapa()

Hasilnya:
Halo, Dina

Nama `nama` dapat digunakan di dalam fungsi `sapa()`. Namun, nama tersebut tidak otomatis tersedia di luar fungsi. Pembatasan ini membantu mencegah variabel internal suatu fungsi memengaruhi bagian program lainnya secara tidak sengaja.

Enclosing Scope

Enclosing scope merupakan ruang lingkup fungsi luar yang melingkupi fungsi bagian dalam. Ruang lingkup ini muncul ketika sebuah fungsi didefinisikan di dalam fungsi lainnya. Fungsi bagian dalam dapat membaca nama yang didefinisikan pada fungsi luar, selama nama tersebut dapat dijangkau melalui aturan pencarian nama Python.

Contohnya adalah sebagai berikut:
def fungsi_luar():
pesan = "Belajar Python"
def fungsi_dalam():
print(pesan)
fungsi_dalam()
fungsi_luar()

Hasilnya:
Belajar Python

Variabel `pesan` berada pada enclosing scope bagi `fungsi_dalam()`. Oleh karena itu, fungsi bagian dalam dapat membaca nilainya tanpa harus mendefinisikan ulang variabel tersebut.

Jika fungsi bagian dalam perlu mengubah pengikatan nama pada fungsi luar, penggunaan `nonlocal` dapat diperlukan. Kata kunci ini dijelaskan lebih lanjut pada bagian berikutnya.

Global Scope

Global scope merupakan ruang lingkup pada tingkat modul. Nama yang didefinisikan pada tingkat ini dapat dibaca oleh fungsi dalam modul yang sama, kecuali apabila ada nama lokal atau nama dari enclosing scope yang lebih dekat dan menggunakan nama identik.

Perhatikan contoh berikut:
pesan = "Selamat belajar"
def tampilkan_pesan():
print(pesan)
tampilkan_pesan()

Hasilnya:
Selamat belajar

Fungsi `tampilkan_pesan()` dapat membaca variabel global `pesan` karena tidak memiliki variabel lokal dengan nama yang sama. Contoh tersebut menunjukkan bahwa sebuah fungsi tidak harus mendefinisikan ulang seluruh informasi yang dibutuhkan apabila informasi itu memang tersedia pada tingkat global.

Built-in Scope

Built-in scope merupakan ruang lingkup yang menyediakan nama bawaan Python. Nama-nama seperti `print()`, `len()`, `str()`, dan `int()` tersedia melalui lingkungan ini. Ketika nama tidak ditemukan dalam local, enclosing, atau global scope, Python dapat melanjutkan pencarian ke built-in scope.

Sebagai contoh:
data = [2, 4, 6, 8]
def tampilkan_jumlah():
jumlah = len(data)
print("Banyak data:", jumlah)
tampilkan_jumlah()

Hasilnya:
Banyak data: 4

Dalam contoh tersebut, `data` ditemukan pada global scope, sedangkan `len` ditemukan pada built-in scope. Pemahaman terhadap urutan pencarian ini membantu menjelaskan bagaimana satu baris kode dapat menggunakan nama yang berasal dari lingkungan berbeda.

Memahami Aturan LEGB dalam Pencarian Nama

Aturan LEGB menjelaskan urutan pencarian nama yang digunakan Python ketika suatu nama dipanggil dalam sebuah fungsi. LEGB merupakan singkatan dari *Local*, *Enclosing*, *Global*, dan *Built-in*. Urutan ini membantu Python menentukan objek yang dirujuk apabila nama yang sama muncul dalam beberapa lingkungan penamaan.

Pertama, Python mencari nama pada local scope, yaitu lingkungan fungsi yang sedang berjalan. Jika nama tidak ditemukan, pencarian dilanjutkan ke enclosing scope apabila fungsi tersebut berada di dalam fungsi lain. Setelah itu, Python mencari nama pada global scope modul. Jika nama tetap tidak ditemukan, pencarian terakhir dilakukan pada built-in scope.

Contoh berikut memperlihatkan pengaruh urutan tersebut:
nilai = 100
def tampilkan_nilai():
nilai = 75
print(nilai)
tampilkan_nilai()
print(nilai)

Hasil program tersebut adalah:
75
100

Ketika `print(nilai)` dijalankan di dalam fungsi `tampilkan_nilai()`, Python menemukan nama `nilai` pada local scope. Oleh karena itu, nilai yang ditampilkan adalah `75`. Sementara itu, pernyataan `print(nilai)` di luar fungsi mengacu pada variabel global yang bernilai `100`.

Contoh tersebut memperlihatkan bahwa dua nama identik dapat merujuk pada objek berbeda apabila berada dalam lingkungan penamaan yang berbeda. Variabel lokal tidak otomatis mengubah variabel global yang memiliki nama sama. Pemisahan ini merupakan salah satu mekanisme yang membuat fungsi dapat bekerja secara mandiri.

Aturan LEGB juga menjelaskan mengapa fungsi dapat menggunakan nama bawaan Python selama nama tersebut tidak tertutupi oleh nama lain yang lebih dekat dalam urutan pencarian. Jika programmer mendefinisikan variabel bernama `len`, misalnya, nama itu dapat menutupi fungsi bawaan `len()` ketika pencarian dilakukan pada lingkungan tempat variabel tersebut berlaku.

Dengan memahami LEGB, programmer dapat menelusuri asal suatu nama, menghindari kesalahan akibat nama yang tertutupi, serta menentukan tempat yang tepat untuk mendefinisikan variabel.

Perbedaan Namespace dan Scope

Namespace dan scope merupakan dua konsep yang saling berhubungan, tetapi mempunyai fungsi yang berbeda. Namespace mengatur hubungan antara nama dan objek, sedangkan scope menentukan bagian program yang dapat mengakses nama tersebut secara langsung.

Misalnya, sebuah fungsi memiliki variabel lokal bernama `total`. Nama `total` dihubungkan dengan objek tertentu dalam namespace lokal fungsi tersebut. Namun, nama itu tidak otomatis dapat digunakan dari luar fungsi karena jangkauan aksesnya dibatasi oleh local scope.

Perbedaan ini dapat dipahami melalui tabel berikut:

Aspek	Namespace	Scope
Pengertian	Lingkungan yang menghubungkan nama dengan objek.	Wilayah program tempat nama dapat diakses.
Fokus utama	Pengelolaan dan pemetaan nama.	Jangkauan akses terhadap nama.
Contoh	Nama nilai terhubung dengan bilangan 90.	Variabel nilai dapat digunakan langsung dalam fungsi tempat nama tersebut didefinisikan.
Bentuk umum	Built-in, global, dan lokal.	Local, enclosing, global, dan built-in.
Tujuan	Mengelola nama agar dapat dibedakan berdasarkan lingkungannya.	Menentukan tempat nama dapat ditemukan dan digunakan.
Hubungan	Menyediakan lingkungan penamaan yang menghubungkan nama dengan objek.	Menentukan jangkauan akses dan membantu proses pencarian nama dalam program.

Perbedaan tersebut menunjukkan bahwa namespace dan scope tidak dapat dipisahkan sepenuhnya dalam pemahaman perilaku variabel. Namespace menjelaskan tempat nama dikelola, sedangkan scope membantu menentukan apakah nama tersebut dapat ditemukan dari suatu bagian program.

Penggunaan Kata Kunci `global` dalam Python

Secara bawaan, pemberian nilai pada nama di dalam fungsi akan membuat atau menggunakan nama lokal sesuai dengan aturan Python, kecuali jika nama tersebut telah dinyatakan menggunakan mekanisme seperti `global` atau `nonlocal`. Karena itu, ketika sebuah fungsi perlu menetapkan ulang variabel global, kata kunci `global` dapat digunakan untuk menyatakan bahwa nama yang dimaksud merujuk pada lingkungan global modul.

Perhatikan contoh berikut:
jumlah = 10
def ubah_jumlah():
global jumlah
jumlah = 30
print(jumlah)
ubah_jumlah()
print(jumlah)

Hasil program tersebut adalah:
10
30

Sebelum fungsi dipanggil, variabel global `jumlah` bernilai `10`. Di dalam fungsi `ubah_jumlah()`, pernyataan `global jumlah` menyatakan bahwa nama `jumlah` yang ditetapkan ulang merujuk pada nama global modul, bukan variabel lokal baru. Ketika fungsi dijalankan, nilai variabel global tersebut berubah menjadi `30`.

Tanpa kata kunci `global`, pemberian nilai kepada nama `jumlah` di dalam fungsi akan membuat nama tersebut diperlakukan sebagai lokal. Hal ini dapat menimbulkan hasil yang berbeda atau bahkan kesalahan apabila nama lokal dibaca sebelum diberi nilai.

Contoh berikut memperlihatkan persoalan tersebut:
jumlah = 10
def ubah_jumlah():
jumlah = 30
print("Dalam fungsi:", jumlah)
ubah_jumlah()
print("Di luar fungsi:", jumlah)

Hasilnya:
Dalam fungsi: 30
Di luar fungsi: 10

Variabel `jumlah` di dalam fungsi merupakan nama lokal yang berbeda dari variabel global `jumlah`. Perubahan nilai lokal tidak mengubah nilai global. Perilaku ini berguna untuk menjaga agar fungsi tidak mengubah keadaan program di luar fungsi secara tidak sengaja.

Kata kunci `global` sebaiknya digunakan secara bijaksana. Dalam program sederhana, penggunaannya dapat membantu menjelaskan perubahan terhadap keadaan global. Namun, pada program yang lebih besar, terlalu banyak fungsi yang mengubah variabel global dapat membuat alur data sulit dilacak. Sebagai alternatif, fungsi dapat menerima nilai melalui parameter dan mengembalikan hasil melalui `return`. Cara tersebut sering membuat fungsi lebih mudah diuji dan digunakan kembali.

Penggunaan Kata Kunci `nonlocal`

Selain `global`, Python menyediakan kata kunci `nonlocal` untuk menangani nama yang berasal dari fungsi luar dalam struktur fungsi bertingkat. Kata kunci `nonlocal` digunakan ketika fungsi bagian dalam perlu menetapkan ulang nama yang sudah didefinisikan pada enclosing scope, bukan membuat nama lokal baru dan bukan pula mengubah nama global.

Perhatikan contoh berikut:
def fungsi_luar():
jumlah = 10

def fungsi_dalam():
nonlocal jumlah
jumlah = 25
print("Dalam fungsi dalam:", jumlah)

fungsi_dalam()
print("Dalam fungsi luar:", jumlah)
fungsi_luar()

Hasil program tersebut adalah:
Dalam fungsi dalam: 25
Dalam fungsi luar: 25

Variabel `jumlah` didefinisikan dalam `fungsi_luar()`. Ketika `fungsi_dalam()` dijalankan, pernyataan `nonlocal jumlah` menunjukkan bahwa nama yang akan diubah berada pada enclosing scope. Akibatnya, perubahan nilai menjadi `25` terlihat ketika fungsi luar mencetak nilai `jumlah`.

Apabila kata kunci `nonlocal` tidak digunakan, pernyataan `jumlah = 25` di dalam fungsi bagian dalam akan membuat nama lokal `jumlah` yang berbeda. Dalam kondisi itu, nilai `jumlah` pada fungsi luar tetap `10`.

Perbedaan antara `global` dan `nonlocal` terletak pada lingkungan yang dituju. Kata kunci `global` merujuk pada nama dalam namespace global modul, sedangkan `nonlocal` merujuk pada nama yang berada dalam fungsi luar yang melingkupi fungsi saat ini. Kata kunci `nonlocal` tidak digunakan untuk merujuk pada nama global.

Kedua kata kunci tersebut membantu programmer mengendalikan penetapan ulang nama secara lebih jelas. Meskipun demikian, penggunaan keduanya harus disesuaikan dengan kebutuhan program agar alur perubahan data tetap mudah dipahami.

Contoh Penerapan Namespace dan Scope dalam Satu Program

Pemahaman terhadap namespace dan scope akan lebih kuat apabila diterapkan dalam program yang menggabungkan variabel global, variabel lokal, dan fungsi bertingkat. 

Contoh berikut menggunakan data nilai siswa untuk memperlihatkan hubungan antarruang lingkup:
nama_sekolah = "SMA Nusantara"
batas_kelulusan = 75

def periksa_nilai(nama, nilai):
keterangan = "Lulus" if nilai >= batas_kelulusan else "Belum lulus"

def tampilkan_hasil():
print("Sekolah:", nama_sekolah)
print("Nama siswa:", nama)
print("Nilai:", nilai)
print("Keterangan:", keterangan)

tampilkan_hasil()
periksa_nilai("Alya", 88)

Hasil program tersebut adalah:
Sekolah: SMA Nusantara
Nama siswa: Alya
Nilai: 88
Keterangan: Lulus

Pada contoh tersebut, variabel `nama_sekolah` dan `batas_kelulusan` berada dalam namespace global modul. Keduanya dapat dibaca oleh fungsi `periksa_nilai()` karena tidak terdapat nama lokal yang menutupi nama tersebut.

Parameter `nama` dan `nilai` menjadi bagian dari lingkungan lokal `periksa_nilai()`. Variabel `keterangan` juga didefinisikan di dalam fungsi itu. Ketika fungsi `tampilkan_hasil()` dijalankan, fungsi tersebut dapat membaca `nama`, `nilai`, dan `keterangan` dari enclosing scope. Sementara itu, `nama_sekolah` ditemukan pada global scope.

Contoh tersebut menunjukkan bahwa sebuah fungsi dapat memanfaatkan nama dari beberapa lingkungan sekaligus. Python menentukan objek yang dimaksud berdasarkan aturan pencarian nama. Dengan pengaturan yang tepat, programmer dapat memisahkan konfigurasi umum, data masukan, hasil pengolahan, dan proses penampilan hasil tanpa harus menempatkan semua variabel pada satu lingkungan yang sama.

Pendekatan seperti ini juga membantu pengembangan program yang lebih besar. Informasi umum dapat dikelola pada tingkat modul, data khusus dapat diteruskan melalui parameter, sedangkan hasil perhitungan sementara dapat disimpan dalam variabel lokal. Pemisahan tersebut membuat program lebih mudah dipahami dan mengurangi ketergantungan yang tidak diperlukan antarbagian kode.

Kesalahan Umum dalam Penggunaan Namespace dan Scope

Kesalahan dalam memahami namespace dan scope dapat menyebabkan program menghasilkan nilai yang tidak sesuai harapan atau mengalami kegagalan ketika dijalankan. Salah satu kesalahan yang sering terjadi adalah mencoba mengakses variabel lokal dari luar fungsi. Variabel yang hanya didefinisikan di dalam suatu fungsi tidak otomatis tersedia pada tingkat global. Untuk menggunakan hasilnya di luar fungsi, programmer dapat mengembalikannya melalui `return` atau menyimpannya pada variabel di lingkungan pemanggil.

Kesalahan berikutnya adalah menganggap bahwa perubahan variabel lokal akan mengubah variabel global dengan nama yang sama. Pada kenyataannya, penetapan nilai dalam fungsi umumnya menghasilkan nama lokal, kecuali jika ada deklarasi yang mengubah aturan tersebut. Jika memang diperlukan perubahan terhadap nama global, kata kunci `global` harus digunakan sebelum nama tersebut ditetapkan ulang dalam fungsi.

Penggunaan nama bawaan sebagai nama variabel juga dapat menimbulkan masalah. Misalnya, mendefinisikan variabel bernama `list`, `str`, atau `sum` dapat menutupi nama fungsi bawaan yang bersangkutan. Jika fungsi tersebut kemudian dipanggil, Python mungkin menemukan variabel yang menutupi nama bawaan itu dan menghasilkan kesalahan. Untuk menghindarinya, pilih nama variabel yang deskriptif dan tidak bertabrakan dengan nama fungsi bawaan.

Kesalahan lain adalah mengabaikan urutan pencarian nama. Ketika nama yang sama terdapat pada local scope dan global scope, Python akan menggunakan nama lokal terlebih dahulu. Programmer yang tidak memahami aturan LEGB mungkin mengira bahwa nilai global selalu digunakan, padahal nama lokal dengan nama identik dapat menjadi pilihan pertama.

Dalam fungsi bertingkat, kesalahan juga dapat muncul ketika programmer ingin mengubah variabel pada fungsi luar tetapi tidak menggunakan `nonlocal`. Tanpa deklarasi tersebut, penetapan nilai di fungsi bagian dalam akan menciptakan nama lokal baru. Akibatnya, nilai pada fungsi luar tidak berubah sesuai harapan.

Cara mengurangi kesalahan tersebut adalah dengan memberikan nama variabel yang jelas, menjaga fungsi agar memiliki tanggung jawab yang terarah, menggunakan parameter untuk menerima data, serta memanfaatkan `return` untuk menghasilkan keluaran. Kata kunci `global` dan `nonlocal` sebaiknya digunakan ketika kebutuhan program memang mengharuskan perubahan terhadap nama pada lingkungan yang lebih luas atau lingkungan fungsi luar.

Manfaat Memahami Namespace dan Scope

Pemahaman terhadap namespace dan scope memberikan sejumlah manfaat dalam pengembangan program Python. Manfaat pertama adalah mengurangi benturan nama. Variabel yang menggunakan nama serupa dapat dikelola dalam lingkungan berbeda, sehingga program dapat memiliki struktur yang lebih tertata.

Manfaat kedua adalah meningkatkan keterbacaan kode. Ketika programmer memahami letak suatu variabel dan wilayah penggunaannya, hubungan antara bagian program menjadi lebih mudah ditelusuri. Nama global dapat dikenali sebagai informasi tingkat modul, sedangkan nama lokal menunjukkan data yang digunakan oleh fungsi tertentu.

Manfaat ketiga adalah membantu pengendalian perubahan data. Variabel lokal membatasi pengaruh perubahan pada bagian program tertentu. Dengan demikian, fungsi dapat dibuat agar bekerja berdasarkan parameter dan menghasilkan nilai melalui `return`, sehingga ketergantungan terhadap keadaan global dapat dikurangi.

Manfaat keempat adalah mempermudah pencarian kesalahan. Apabila suatu nama tidak ditemukan, programmer dapat memeriksa apakah nama tersebut sudah didefinisikan, apakah berada dalam scope yang dapat dijangkau, atau apakah tertutupi oleh nama lain. Pemahaman terhadap aturan LEGB menjadi pedoman untuk menelusuri masalah tersebut secara sistematis.

Manfaat kelima adalah mendukung pembelajaran konsep Python yang lebih lanjut. Namespace dan scope menjadi landasan untuk memahami fungsi bertingkat, *closure*, modul, kelas, serta berbagai mekanisme pengelolaan objek. Konsep tersebut juga membantu programmer memahami mengapa nama yang tampak sama dapat berperilaku berbeda ketika ditempatkan pada lingkungan yang berbeda.

Kesimpulan

Namespace dan scope merupakan konsep mendasar dalam bahasa pemrograman Python yang berkaitan dengan pengelolaan nama dan jangkauan akses terhadap nama tersebut. Namespace menghubungkan nama dengan objek, sedangkan scope menentukan bagian program yang dapat mengakses nama secara langsung. Kedua konsep ini bekerja bersama untuk membantu Python menemukan objek yang dimaksud ketika sebuah nama digunakan dalam program.

Python memiliki namespace bawaan, global, dan lokal. Dalam struktur fungsi bertingkat, terdapat pula lingkungan fungsi luar yang menjadi enclosing scope bagi fungsi bagian dalam. Sementara itu, aturan LEGB menjelaskan urutan pencarian nama berdasarkan local, enclosing, global, dan built-in scope. Pemahaman terhadap urutan ini membantu programmer mengetahui mengapa suatu variabel dapat ditemukan atau mengapa nama tertentu menutupi nama lainnya.

Kata kunci `global` digunakan ketika fungsi perlu menetapkan ulang nama pada lingkungan global modul, sedangkan `nonlocal` digunakan untuk menetapkan ulang nama yang berada pada fungsi luar yang melingkupi fungsi saat ini. Keduanya memiliki fungsi berbeda dan sebaiknya diterapkan secara terencana. Untuk banyak kebutuhan pemrograman, penggunaan parameter, variabel lokal, dan nilai balik melalui `return` dapat membantu menghasilkan program yang lebih terstruktur dan mudah diuji.

Dengan memahami namespace dan scope, programmer dapat mengelola variabel secara lebih tepat, mengurangi benturan nama, menghindari kesalahan akses, serta menyusun fungsi yang lebih mandiri. Penguasaan konsep ini menjadi bekal penting untuk mempelajari topik Python yang lebih lanjut dan membangun program yang lebih teratur, jelas, dan mudah dipelihara.

Artikel ini akan dibaca oleh: Fatma Dian Ferrari, Febrian Restu Andhika, Firza Tegar Febrian, Gadis Lolalita, dan Gustaf Bintang Prayoga.

Location: Semarang, Kota Semarang, Jawa Tengah, Indonesia

Berbagi :