Skop Pembolehubah Python: Panduan Komprehensif untuk Pemula

Helo di sana, yang berhasrat untuk menjadi Pythonista! ? Adakah anda sudah bersedia untuk kongsikan dunia yang menarik skop pembolehubah Python? Jangan khawatir jika ia terdengar menakutkan; pada akhir tutorial ini, anda akan menjadi seorang master skop! Mari kita bersama-sama wujudkan perjalanan yang menarik ini.

Jenis-jenis Skop untuk Pembolehubah di Python

Sebelum kita mendepani perincian, mari kita faham apa yang dimaksudkan dengan "skop" di Python. Bayangkan anda berada di atas rumah besar dengan beberapa bilik yang berlainan. Setiap bilik memiliki aturan dan item mereka sendiri. Di Python, bilik-bilik ini seperti skop yang berlainan, dan item-item adalah pembolehubah kami.

Python memiliki tiga jenis utama skop pembolehubah:

1. Skop Lokal
2. Skop Global
3. Skop Bukan Lokal

Mari kita kongsikan setiap satu daripada ini secara terperinci.

Pembolehubah Lokal

Pembolehubah lokal adalah seperti harta benda pribadi anda di atas rak penyimpanan anda. Mereka hanya boleh diakses di dalam fungsi atau blok kod yang spesifik.

def ucapan_pengguna():
nama = "Alice"  # Ini adalah pembolehubah lokal
print(f"Helo, {nama}!")

ucapan_pengguna()  # Output: Helo, Alice!
print(nama)  # Ini akan melibatkanRalat Nama

Dalam contoh ini, nama adalah pembolehubah lokal di atas fungsi ucapan_pengguna(). Ia seperti tag nama Alice yang hanya wujud di atas rak penyimpanan fungsi. Apabila kita cuba untuk mengaksesnya di luar fungsi, Python akan katakan, "Maaf, saya tidak tahu apa-apa 'nama' di sini!"

Pembolehubah Global

Pembolehubah global adalah seperti aturan rumah yang dipaparkan di atas rak penyimpanan - mereka boleh diakses dari mana-mana di atas program.

nama_rumah = "Python Palace"  # Ini adalah pembolehubah global

def ucapan_sambutan():
print(f"Selamat datang ke {nama_rumah}!")

ucapan_sambutan()  # Output: Selamat datang ke Python Palace!
print(nama_rumah)  # Output: Python Palace

Di sini, nama_rumah adalah pembolehubah global kami. Ia adalah seperti nama rumah kami yang semua orang boleh lihat dan gunakan, sama ada mereka berada di atas dapur, ruang tamu, atau mana-mana fungsi di atas program kami.

Tapi apa jika kita ingin mengubah suai pembolehubah global di atas fungsi? Itulah di mana kata kunci global menjadi berguna:

counter = 0  # Pembolehubah global

def tambah_counter():
global counter
counter += 1
print(f"Counter sekarang: {counter}")

tambah_counter()  # Output: Counter sekarang: 1
tambah_counter()  # Output: Counter sekarang: 2

Dengan menggunakan global counter, kita memberitahu Python, "Hei, saya mahu menggunakan counter rumah, bukan membuat satu baru di atas rak penyimpanan ini!"

Pembolehubah Bukan Lokal

Sekarang, bayangkan anda berada di atas bilik tetamu di atas rak penyimpanan master. Anda boleh mengakses perkara di atas bilik tetamu (skop lokal) dan beberapa perkara dari rak penyimpanan master (skop bukan lokal), tetapi tidak semua dari seluruh rumah (skop global).

def fungsi_luar():
x = "luar"

def fungsi_dalam():
nonlocal x
x = "dalam"
print("Dalam:", x)

fungsi_dalam()
print("Luar:", x)

fungsi_luar()
# Output:
# Dalam: dalam
# Luar: dalam

Di atas senario fungsi bersarang, nonlocal x membenarkan fungsi dalaman untuk mengubah pembolehubah dari rak penyimpanan luar (yang mengelilinginya).

Namespace dan Skop Pembolehubah Python

Fikirkan namespace sebagai kamus besar di mana Python menyimpan semua pembolehubah mereka. Setiap skop memiliki namespace mereka sendiri.

x = 10  # Namespace global

def luar():
y = 20  # namespace luar()

def dalaman():
z = 30  # namespace dalaman()
print(x, y, z)

dalaman()

luar()  # Output: 10 20 30

Contoh ini menunjukkan bagaimana Python mencari pembolehubah di atas namespace yang berlainan, bermula dari skop terdalam dan bergerak ke luar.

Fungsi globals() Python

Fungsi globals() adalah seperti cermin ajaib yang menunjukkan semua pembolehubah global di atas program anda.

x = 10
y = "hello"

print(globals())
# Output: {..., 'x': 10, 'y': 'hello', ...}

Ia mengembalikan kamus yang mengandungi semua pembolehubah global. Ia sangat membantu untuk penyahpepijatan!

Fungsi locals() Python

Berikut juga, locals() menunjukkan semua pembolehubah lokal di atas skop semasa.

def tunjukkan_lokals():
a = 5
b = "dunia"
print(locals())

tunjukkan_lokals()
# Output: {'a': 5, 'b': 'dunia'}

Fungsi ini adalah伟大的 untuk melihat apa pembolehubah yang tersedia di atas "bilik" anda.

Konflik Namespace di Python

Bila-bila masa, pembolehubah di atas skop yang berlainan mungkin memiliki nama yang sama, membawa kepada konflik namespace. Python menyelesaikan ini menggunakan aturan LEGB: Lokal, Mengelilingi, Global, Dibangun Masuk.

x = "global"

def luar():
x = "luar"

def dalaman():
x = "dalam"
print("Dalam x:", x)

dalaman()
print("Luar x:", x)

luar()
print("Global x:", x)

# Output:
# Dalam x: dalam
# Luar x: luar
# Global x: global

Dalam contoh ini, setiap skop memiliki x mereka sendiri, dan Python menggunakan yang paling dekat dengan tempat ia dipanggil.

Berikut adalah jadual yang ringkaskan fungsi utama yang kita kongsikan:

Fungsi	Keterangan	Contoh
globals()	Kembalikan kamus pembolehubah global	print(globals())
locals()	Kembalikan kamus pembolehubah lokal	print(locals())
global	Deklarasikan pembolehubah global di atas fungsi	global x
nonlocal	Deklarasikan pembolehubah bukan lokal di atas fungsi bersarang	nonlocal y

Ingat, untuk memahami skop pembolehubah adalah seperti untuk belajar bentangan rumah baru. Ia mungkin terdengar mengelirukan pada awalnya, tetapi dengan latihan, anda akan menavigasi "bilik" ini seperti profesional! Teruskan untuk mengkod, teruskan untuk menjelajah, dan jangan ragu untuk untuk membuat percubaan.毕竟, cara terbaik untuk belajar Python adalah dengan melakukan. Happy coding! ?✨

Credits: Image by storyset