Kata Kunci global dalam Python

Dalam Python, `global` merupakan kata kunci yang digunakan untuk memberitahukan bahwa sebuah variabel yang berada di dalam fungsi merupakan variabel global. 

Sebelum lebih lanjut mempelajari materi tentang Kata Kunci global dalam Python, terlebih dahulu pelajari materi tentang: Fungsi dalam Python, Argumen Fungsi dalam Python, dan Variabel Global, Lokal, dan Nonlocal dalam Python.

Variabel global adalah variabel yang dibuat di luar fungsi sehingga berada pada ruang lingkup utama program.

Contoh:
nilai = 80
def tampilkan():
print(nilai)
tampilkan()

Pada contoh tersebut, fungsi `tampilkan()` dapat membaca variabel `nilai` karena `nilai` dibuat di luar fungsi.

Namun, terdapat perbedaan antara **membaca** dan **mengubah** variabel global. Untuk membaca variabel global, kata kunci `global` tidak selalu diperlukan. Untuk mengubah variabel global dari dalam fungsi, kata kunci `global` dapat digunakan.

Membuat Variabel Global

Variabel global dibuat di luar fungsi.

Contoh:
nama = "Budi"
umur = 16
print(nama)
print(umur)

Hasil:
Budi
16

Variabel `nama` dan `umur` dapat digunakan pada bagian utama program. Variabel global juga dapat dibaca dari dalam fungsi.
nama = "Budi"
def tampilkan():
print(nama)
tampilkan()

Hasil:
Budi

Membaca Variabel Global Tanpa global

Jika hanya ingin membaca nilai variabel global dari dalam fungsi, kata kunci `global` tidak diperlukan.

Contoh:
angka = 100
def tampilkan():
print(angka)
tampilkan()

Hasil:
100

Pada program tersebut, fungsi hanya membaca nilai `angka`. Tidak ada perubahan terhadap variabel tersebut. Karena itu, penggunaan `global` tidak diperlukan.

Mengubah Variabel Global dari Dalam Fungsi

Masalah muncul ketika sebuah fungsi ingin memberikan nilai baru kepada variabel global.

Contoh:
angka = 10
def ubah():
angka = 20
ubah()
print(angka)

Hasil:
10

Nilai global tetap `10`.

Karena Python menganggap `angka = 20` yang terdapat di dalam fungsi sebagai pembuatan variabel lokal. Dengan kata lain, terdapat dua variabel berbeda:

• angka global = 10
• angka lokal = 20

Menggunakan Kata Kunci global
Untuk mengubah variabel global dari dalam fungsi, gunakan kata kunci `global`.

Contoh:
angka = 10
def ubah():
global angka
angka = 20
ubah()
print(angka)

Hasil:
20

Perhatikan bagian:
global angka

Baris tersebut memberi tahu Python bahwa `angka` yang digunakan di dalam fungsi adalah variabel global.

Cara Kerja global

Perhatikan program berikut:
nilai = 50
def ubah_nilai():
global nilai
nilai = 100
ubah_nilai()
print(nilai)

Prosesnya dapat dipahami melalui beberapa langkah:

1. Variabel `nilai` dibuat di luar fungsi.
2. Nilai awalnya adalah `50`.
3. Fungsi `ubah_nilai()` dibuat.
4. Kata `global nilai` menyatakan bahwa `nilai` di dalam fungsi adalah variabel global.
5. Nilai `nilai` diubah menjadi `100`.
6. Setelah fungsi selesai, variabel global tetap memiliki nilai `100`.
7. Nilai tersebut kemudian ditampilkan.

Hasil:
100

Contoh Mengubah Nilai Global

Contoh lain:
jumlah = 0
def tambah():
global jumlah
jumlah = jumlah + 1
tambah()
print(jumlah)

Hasil:
1

Fungsi `tambah()` mengubah variabel global `jumlah`. Jika fungsi dipanggil beberapa kali:
tambah()
tambah()
tambah()
print(jumlah)

Hasil:
3

Setiap pemanggilan fungsi meningkatkan nilai variabel global.

Operator Perubahan Nilai dan global

Kata kunci `global` juga diperlukan ketika variabel global diubah menggunakan operator seperti:

• `+=`
• `-=`
• `*=`
• `/=`

Contoh:
nilai = 10
def tambah():
global nilai
nilai += 5
tambah()
print(nilai)

Hasil:
15

Tanpa `global`, Python dapat menganggap `nilai` sebagai variabel lokal ketika digunakan untuk operasi perubahan nilai tersebut.

global dengan Beberapa Variabel

Satu fungsi dapat menggunakan lebih dari satu variabel global.

Contoh:
nama = "Budi"
umur = 16
def ubah_data():
global nama, umur
nama = "Siti"
umur = 17
ubah_data()
print(nama)
print(umur)

Hasil:
Siti
17

Kedua variabel berhasil diubah karena sudah dinyatakan sebagai variabel global.

global Tidak Membuat Variabel Menjadi Global

Kata kunci `global` digunakan untuk merujuk kepada variabel global yang sudah ada atau yang akan dibuat pada ruang lingkup global.

Contoh:
def buat_variabel():
global angka
angka = 100
buat_variabel()
print(angka)

Hasil:
100

Pada contoh tersebut, `angka` dibuat sebagai variabel global melalui fungsi karena menggunakan kata kunci `global`. Hal ini menunjukkan bahwa `global` dapat digunakan untuk membuat atau mengubah variabel pada ruang lingkup global.

Perbedaan Variabel Lokal dan global

Perhatikan dua program berikut.

Tanpa global

Berikut adalah contoh variabel tanpa global.
nilai = 50
def ubah():
nilai = 100
ubah()
print(nilai)

Hasil:
50

Variabel `nilai` di dalam fungsi merupakan variabel lokal.

Dengan global

Bertikut adalah contoh variabel dengan global.
nilai = 50
def ubah():
global nilai
nilai = 100
ubah()
print(nilai)

Hasil:
100

Dengan `global`, fungsi mengubah variabel yang berada di ruang lingkup global.

Contoh global dalam Program Penghitung

Berikut contoh program penghitung sederhana:
jumlah = 0
def tambah():
global jumlah
jumlah += 1
def kurangi():
global jumlah
jumlah -= 1
tambah()
tambah()
tambah()
kurangi()
print("Jumlah:", jumlah)

Hasil:
Jumlah: 2

Prosesnya:

• Nilai awal `jumlah` adalah `0`.
• Pemanggilan pertama `tambah()` menghasilkan `1`.
• Pemanggilan kedua menghasilkan `2`.
• Pemanggilan ketiga menghasilkan `3`.
• `kurangi()` mengubah nilai menjadi `2`.
• Hasil akhir adalah `2`.

Contoh global dalam Program Nilai

Variabel global juga dapat digunakan untuk menyimpan nilai yang dipakai oleh beberapa fungsi.
nilai = 0
def masukkan_nilai():
global nilai
nilai = 85
def tampilkan_nilai():
print("Nilai:", nilai)
masukkan_nilai()
tampilkan_nilai()

Hasil:
Nilai: 85

Fungsi `masukkan_nilai()` mengubah nilai global, sedangkan `tampilkan_nilai()` membaca nilai tersebut.

global dalam Fungsi Bersarang

Kata kunci `global` juga dapat digunakan pada fungsi yang berada di dalam fungsi lainnya.

Contoh:
angka = 10
def luar():
def dalam():
global angka
angka = 50
dalam()
luar()
print(angka)

Hasil:
50

Meskipun `dalam()` berada di dalam `luar()`, kata kunci `global` tetap mengarah kepada variabel pada ruang lingkup global. Hal ini berbeda dengan `nonlocal`.

Perbedaan global dan nonlocal

Kedua kata kunci ini sering membingungkan ketika pertama kali dipelajari.

global

Digunakan untuk mengakses atau mengubah variabel pada ruang lingkup global.
angka = 10
def ubah():
global angka
angka = 20

nonlocal

Digunakan untuk mengubah variabel yang berada pada fungsi luar.
def luar():
angka = 10
def dalam():
nonlocal angka
angka = 20
dalam()
print(angka)
luar()

Perbedaan utama:

• global → menuju ruang lingkup global
• nonlocal → menuju ruang lingkup fungsi luar

Waktu Penggunaan Kata Kunci global

Kata kunci `global` dapat digunakan ketika:

• Sebuah fungsi memang perlu mengubah variabel global.
• Beberapa fungsi harus mengakses keadaan atau nilai yang sama.
• Program mempunyai nilai tertentu yang dikelola secara global.
• Terdapat kebutuhan khusus untuk mempertahankan satu nilai yang digunakan oleh beberapa bagian program.

Contoh sederhana:
status = "Aktif"
def ubah_status():
global status
status = "Tidak Aktif"
ubah_status()
print(status)

Hasil:
Tidak Aktif

Kondisi untuk Menghindari global

Walaupun `global` dapat digunakan, pemakaiannya sebaiknya tidak berlebihan. Program yang terlalu banyak menggunakan variabel global dapat menjadi lebih sulit dipahami. Beberapa masalah yang dapat muncul:

• Nilai dapat diubah dari banyak fungsi.
• Sulit melacak bagian program yang mengubah nilai.
• Risiko perubahan data secara tidak sengaja menjadi lebih besar.
• Fungsi menjadi lebih bergantung kepada keadaan di luar dirinya.
• Pemeliharaan program menjadi lebih sulit.

Contoh:
nilai = 0
def fungsi_satu():
global nilai
nilai = 10
def fungsi_dua():
global nilai
nilai = 20
def fungsi_tiga():
global nilai
nilai = 30

Ketika program menjadi sangat panjang, perubahan nilai `nilai` dapat sulit dilacak.

Menggunakan Parameter sebagai Alternatif

Dalam banyak keadaan, penggunaan parameter dan `return` dapat menjadi alternatif yang lebih terstruktur daripada `global`.

Contoh menggunakan `global`:
nilai = 10
def ubah():
global nilai
nilai = 20
ubah()
print(nilai)

Alternatif menggunakan parameter dan `return`:
def ubah(nilai):
nilai = 20
return nilai
nilai = 10
nilai = ubah(nilai)
print(nilai)

Hasil keduanya:
20

Namun pada contoh kedua, aliran data terlihat lebih jelas karena nilai diberikan kepada fungsi dan hasilnya dikembalikan.

Contoh Program yang Lebih Terstruktur

Berikut contoh pengolahan nilai tanpa menggunakan `global`:
def hitung_rata_rata(nilai1, nilai2, nilai3):
total = nilai1 + nilai2 + nilai3
rata_rata = total / 3
return rata_rata

def tentukan_status(nilai):
if nilai >= 75:
return "Lulus"
return "Belum Lulus"

nilai = hitung_rata_rata(80, 90, 85)
status = tentukan_status(nilai)

print("Nilai rata-rata:", nilai)
print("Status:", status)

Hasil:
Nilai rata-rata: 85.0
Status: Lulus

Program tersebut tidak memerlukan variabel global karena setiap fungsi menerima data melalui parameter dan mengembalikan hasil menggunakan `return`.

Kesalahan yang Sering Terjadi

Berikut dijelaskan beberapa jenis kesalahan yang sering terjadi ketika menggunakan kata kunci global dalam Python.

satu, Mengira variabel lokal mengubah variabel global
angka = 10
def ubah():
angka = 20
ubah()
print(angka)

Hasil:
10

`angka` di dalam fungsi merupakan variabel lokal.

dua, Lupa menggunakan global

Jika sebuah fungsi perlu mengubah variabel global:
angka = 10
def ubah():
global angka
angka = 20

Kata `global` diperlukan untuk menunjukkan bahwa variabel tersebut adalah variabel global.

tiga, Menggunakan global terlalu banyak

Tidak semua data harus dibuat global. Jika sebuah data hanya digunakan dalam fungsi tertentu, lebih baik gunakan variabel lokal.

Contoh:
def hitung_luas(panjang, lebar):
luas = panjang * lebar
return luas

Variabel `luas` tidak perlu menjadi variabel global.

Latihan Pemahaman

Berikut diberikan beberapa contoh latihan pemahaman untuk meningkatkan pemahaman tentang kata kunci global dalam Python.

Latihan 1

Perhatikan kode berikut:
angka = 10
def ubah():
angka = 20
ubah()
print(angka)

Pertanyaan:

• Berapa nilai yang ditampilkan?
• Mengapa nilai global tidak berubah?
• Termasuk jenis variabel apakah `angka` di dalam fungsi?

Latihan 2

Perbaiki program berikut agar nilai global berubah menjadi `100`.
nilai = 50
def ubah():
nilai = 100
ubah()
print(nilai)

Gunakan kata kunci yang tepat.

Latihan 3

Buat program penghitung dengan ketentuan:

• Variabel `jumlah` dimulai dari `0`.
• Fungsi `tambah()` menambah `jumlah` sebanyak `1`.
• Fungsi `kurangi()` mengurangi `jumlah` sebanyak `1`.
• Gunakan `global`.
• Panggil `tambah()` sebanyak lima kali.
• Panggil `kurangi()` sebanyak dua kali.
• Tampilkan hasil akhirnya.

Hasil yang diharapkan:
Jumlah: 3

Ringkasan Materi

Beberapa poin utama yang perlu diingat:

• `global` merupakan kata kunci dalam Python.
• `global` digunakan untuk merujuk kepada variabel pada ruang lingkup global.
• Variabel global biasanya dibuat di luar fungsi.
• Variabel global dapat dibaca dari dalam fungsi tanpa `global`.
• `global` diperlukan ketika fungsi perlu mengubah variabel global.
• Variabel lokal dengan nama yang sama tidak otomatis mengubah variabel global.
• `global` dapat digunakan untuk lebih dari satu variabel.
• `global` dapat digunakan bersama operasi seperti `+=`, `-=`, dan `*=`.
• `global` berbeda dengan `nonlocal`.
• `global` mengarah ke ruang lingkup global.
• `nonlocal` mengarah ke variabel pada fungsi luar.
• Penggunaan `global` secara berlebihan dapat membuat program lebih sulit dikelola.
• Parameter dan `return` sering dapat digunakan sebagai alternatif yang lebih terstruktur.

Kesimpulan

Kata kunci `global` digunakan ketika sebuah fungsi perlu mengakses atau mengubah variabel yang berada pada ruang lingkup global. Tanpa kata kunci tersebut, pemberian nilai baru kepada sebuah nama variabel di dalam fungsi umumnya akan membuat atau mengubah variabel lokal.

Konsep ini penting untuk memahami bagaimana Python mengelola variabel dalam berbagai ruang lingkup. Dengan memahami perbedaan antara variabel lokal dan global, kesalahan dalam pengelolaan data dapat dikurangi.

Namun, `global` sebaiknya digunakan secara bijaksana. Untuk program yang lebih terstruktur, parameter dan `return` sering menjadi pilihan yang lebih baik karena hubungan antara data yang masuk dan hasil yang keluar dari sebuah fungsi dapat terlihat dengan jelas.

Penguasaan kata kunci `global` juga menjadi dasar untuk memahami konsep ruang lingkup variabel yang lebih lanjut, termasuk fungsi bersarang dan kata kunci `nonlocal`.

Artikel ini akan dibaca oleh: Aulia Imroatun Fadlila, Avrilia Charista Asna, Bagus Rahul Ahmad Attaufa, Bimo Chandra, dan Caesarrio Bina Putra.

Location: Kota Semarang, Jawa Tengah, Indonesia

Berbagi :