Dalam artikel ini, anda akan belajar mengenai kata kunci global, pemboleh ubah global dan kapan menggunakan kata kunci global.
Sebelum membaca artikel ini, pastikan anda mempunyai beberapa asas Python Global, Local dan Nonlocal Variables.
Apakah kata kunci global
Dalam Python, global
kata kunci membolehkan anda mengubah pemboleh ubah di luar skop semasa. Ia digunakan untuk membuat pemboleh ubah global dan membuat perubahan pada pemboleh ubah dalam konteks tempatan.
Peraturan Kata Kunci global
Peraturan asas untuk global
kata kunci dalam Python adalah:
- Apabila kita membuat pemboleh ubah di dalam fungsi, ia secara tempatan secara lalai.
- Apabila kita menentukan pemboleh ubah di luar fungsi, secara global secara default. Anda tidak perlu menggunakan
global
kata kunci. - Kami menggunakan
global
kata kunci untuk membaca dan menulis pemboleh ubah global di dalam fungsi. - Penggunaan
global
kata kunci di luar fungsi tidak memberi kesan.
Penggunaan Kata Kunci global
Mari kita ambil contoh.
Contoh 1: Mengakses Pembolehubah global Dari Dalam Fungsi
c = 1 # global variable def add(): print(c) add()
Apabila kita menjalankan program di atas, outputnya adalah:
1
Namun, kita mungkin mempunyai beberapa senario di mana kita perlu mengubah pemboleh ubah global dari dalam fungsi.
Contoh 2: Mengubah Pembolehubah Global Dari Dalam Fungsi
c = 1 # global variable def add(): c = c + 2 # increment c by 2 print(c) add()
Semasa kita menjalankan program di atas, output menunjukkan ralat:
UnboundLocalError: pemboleh ubah tempatan 'c' dirujuk sebelum tugasan
Ini kerana kita hanya dapat mengakses pembolehubah global tetapi tidak dapat mengubahnya dari dalam fungsi.
Penyelesaian untuk ini adalah dengan menggunakan global
kata kunci.
Contoh 3: Menukar Pembolehubah Global Dari Dalam Fungsi menggunakan global
c = 0 # global variable def add(): global c c = c + 2 # increment by 2 print("Inside add():", c) add() print("In main:", c)
Apabila kita menjalankan program di atas, outputnya adalah:
Inside add (): 2 In main: 2
Dalam program di atas, kami mendefinisikan c sebagai kata kunci global di dalam add()
fungsi.
Kemudian, kita menambah pemboleh ubah c dengan 1
, iaitu c = c + 2
. Selepas itu, kami memanggil add()
fungsi. Akhirnya, kami mencetak pemboleh ubah global c.
Seperti yang kita dapat lihat, perubahan juga berlaku pada pembolehubah global di luar majlis itu, c = 2
.
Pemboleh ubah Global Di Seluruh Modul Python
Di Python, kami membuat satu modul config.py
untuk menyimpan pemboleh ubah global dan berkongsi maklumat di seluruh modul Python dalam program yang sama.
Inilah cara kami dapat berkongsi pemboleh ubah global merentasi modul python.
Contoh 4: Kongsi Modul Python Pembolehubah global
Buat config.py
fail, untuk menyimpan pemboleh ubah global
a = 0 b = "empty"
Buat update.py
fail, untuk mengubah pemboleh ubah global
import config config.a = 10 config.b = "alphabet"
Buat main.py
fail, untuk menguji perubahan nilai
import config import update print(config.a) print(config.b)
Apabila kita menjalankan main.py
fail, output akan menjadi
10 abjad
Di atas, kami telah mencipta tiga fail: config.py
, update.py
, dan main.py
.
Modul config.py
menyimpan pemboleh ubah global a dan b. Dalam update.py
fail, kami mengimport config.py
modul dan mengubah nilai a dan b. Begitu juga dalam main.py
fail, kami mengimport kedua config.py
- duanya dan update.py
modul. Akhirnya, kami mencetak dan menguji nilai pemboleh ubah global sama ada ia berubah atau tidak.
Global dalam Fungsi Bersarang
Inilah cara anda boleh menggunakan pemboleh ubah global dalam fungsi bersarang.
Contoh 5: Menggunakan Pembolehubah Global dalam Fungsi Bersarang
def foo(): x = 20 def bar(): global x x = 25 print("Before calling bar: ", x) print("Calling bar now") bar() print("After calling bar: ", x) foo() print("x in main: ", x)
Keluarannya adalah:
Sebelum memanggil bar: 20 Panggilan bar sekarang Selepas memanggil bar: 20 x utama: 25
Dalam program di atas, kami menyatakan pemboleh ubah global di dalam fungsi bersarang bar()
. Dalam foo()
fungsi, x tidak mempunyai kesan kata kunci global.
Sebelum dan selepas memanggil bar()
, pemboleh ubah x mengambil nilai pemboleh ubah tempatan iaitu x = 20
. Di luar foo()
fungsi, pemboleh ubah x akan mengambil nilai yang ditentukan dalam bar()
fungsi iaitu x = 25
. Ini kerana kami telah menggunakan global
kata kunci dalam x untuk membuat pemboleh ubah global di dalam bar()
fungsi (skop tempatan).
Sekiranya kita membuat perubahan di dalam bar()
fungsi, perubahan itu muncul di luar skop tempatan, yaitu foo()
.