Panduan Komprehensif mengenai Python Namespaces & Variable Scopes

Pengenalan

Memahami ruang nama, skop, dan tingkah laku pembolehubah dalam fungsi Python adalah penting untuk menulis dengan cekap dan mengelakkan kesilapan runtime atau pengecualian. Dalam artikel ini, kami akan menyelidiki pelbagai aspek ruang nama dan skop pembolehubah Python dan belajar bagaimana Python menguruskan pembolehubah tempatan, global, dan melampirkan secara terperinci.

Kami sudah membincangkan fungsi Python secara terperinci, yang boleh ditemui. Python menggunakan prinsip -prinsip abstraksi untuk menyembunyikan logik yang kompleks dan hanya mendedahkan output yang diperlukan, sementara penguraian mencipta fungsi modular, boleh dibaca, dan boleh diguna semula.

Prinsip -prinsip ini cukup jelas untuk memahami bagaimana Python mengendalikan skop berubah -ubahnya untuk definisi fungsi dan fungsi bersarang, yang akan kita pelajari melalui contoh -contoh terperinci. Menjelang akhir artikel ini, anda harus memahami dengan jelas konsep -konsep ini dan bagaimana untuk menerapkannya dengan berkesan dalam program anda.

Gambaran Keseluruhan

• Ruang nama Python dan skop berubah -ubah adalah penting untuk pencegahan pengekodan dan kesilapan yang cekap.
• Artikel ini meneroka tingkah laku pembolehubah tempatan, global, dan melampirkan 'Python.
• Peraturan Legb menerangkan carian nama pembolehubah Python di seluruh skop yang berbeza.
• Contoh praktikal menunjukkan penggunaan dan pengubahsuaian pembolehubah global dan tempatan.
• Fungsi bersarang dan skop yang dilampirkan dilindungi, menekankan kata kunci nonlocal.

Jadual Kandungan

• Apakah pembolehubah dalam Python?
  • Pembolehubah global
  • Pembolehubah tempatan
• Apakah ruang nama?
• Apakah skop berubah -ubah di Python?
• Apakah Peraturan Legb?
• Bagaimanakah skopel skoper python?
  • 1. Menggunakan pemboleh ubah global dalam skop tempatan
  • 2. Menggunakan pemboleh ubah tempatan dalam skop tempatan
  • 3. Mengubah pemboleh ubah global di dalam skop tempatan
  • 4. Mengubah pemboleh ubah global di dalam skop tempatan menggunakan perisytiharan
  • 5. Mengubah suai skop tempatan VariableInside Global menggunakan fungsi
• Apakah fungsi bersarang?
• Apakah skop pembolehubah yang melekat?
  • 7.Modifikasi pembolehubah global di dalam skop melampirkan tanpa pengisytiharan
  • 8. Mengubah pemboleh ubah bersarang di dalam skop tempatan menggunakan perisytiharan
• Soalan yang sering ditanya

Apakah pembolehubah dalam Python?

Pembolehubah dalam Python adalah bekas yang menyimpan data atau nilai (seperti int, float, str, bool, dan lain -lain). Lokasi memori di mana pembolehubah disimpan dan juga boleh diakses untuk kegunaan masa depan dipanggil thescope pembolehubah.

Terdapat dua jenis pembolehubah dalam Python, iaitu:

Pembolehubah global

• Pembolehubah ini berada di bawah skop program utama.
• Program utama tidak boleh menggunakan pembolehubah tempatan, kerana ia hanya tersedia untuk fungsi tersebut.

Pembolehubah tempatan

• Pembolehubah ini berada di bawah skop fungsi.
• Juga, pembolehubah tempatan boleh menggunakan pembolehubah global di dalam fungsi apabila pembolehubah tempatan tidak ditakrifkan di dalam skop tempatan.

Juga Baca: Mutable vs objek yang tidak berubah di Python

Apakah ruang nama?

Ruang nama Python adalah aspace atau kamus yang memegang pengenal (biasanya dipanggil nama berubah) sebagai kunci dan objek masing -masing sebagai nilai dalam ruang ingatan. Bahasa pengaturcaraan Python mempunyai 4 jenis ruang nama, iaitu:

• Ruang nama terbina dalam
• Ruang nama global
• Melampirkan ruang nama
• Ruang nama tempatan

Kami akan melihat contoh yang berbeza untuk lebih memahami konsep ini. Tetapi sebelum itu, sangat penting untuk memahami skop pembolehubah yang disebutkan di atas.

Apakah skop berubah -ubah di Python?

Di Python, Skop merujuk kepada kawasan program atau rantau teks di mana pembolehubah boleh diakses secara langsung. Pada bila -bila masa semasa pelaksanaan, ada:

• Skop Tempatan : Ini adalah skop paling dalam yang ditakrifkan di dalam fungsi. Untuk skop ini, Python mencari pemboleh ubah tempatan.
• Skop yang melampirkan : Ini adalah skop fungsi bersarang. Mereka mengandungi pembolehubah bukan tempatan yang bukan tempatan atau global.
• Skop Global : Skop ini mengandungi pembolehubah yang ditakrifkan pada tahap modul dan boleh diakses sepanjang modul.

Nota: Anda membuat skop yang ditentukan oleh pengguna dalam program anda untuk menjalankannya dengan cekap. Walau bagaimanapun, pembolehubah terbina dalam Python juga mempunyai skop yang dikenali sebagai skop terbina dalam.

• Skop terbina dalam : Ini adalah skop semua kata kunci atau kaedah yang telah ditetapkan Python untuk menulis kod yang lebih baik. Oleh itu, ini tersedia untuk anda sebaik sahaja penterjemah Python bermula. Juga, ambil perhatian bahawa skop ini tidak pernah dipadam dan boleh diakses sepanjang modul.

Apakah Peraturan Legb?

Sekarang, anda mempunyai pemahaman asas mengenai ruang nama dan skop berubah -ubah. Mari kita menyelam lebih mendalam untuk memahami bagaimana peraturan scoping digunakan dalam bahasa pengaturcaraan Python. Terdapat singkatan biasa, peraturan LEGB, yang menimbulkan forlocal, melampirkan, global, dan dibina.

Peraturan LEGB menyatakan bahawa jurubahasa boleh mencari pengenal dari bahagian dalam, yang bermaksud ia bermula dengan mencari nama atau ruang nama yang berubah -ubah dalam skop tempatan terlebih dahulu. Sekiranya ruang nama tidak hadir di sana, ia akan bergerak ke arah skop program anda. ext, ia memeriksa skop global untuk mencari ruang nama. Akhirnya, jika pengecam masih belum dijumpai, jurubahasa melihat skop terbina dalam yang disediakan oleh Python.

Selain itu, jika jurubahasa tidak menemui nama di mana -mana lokasi ini, maka Python menimbulkan pengecualian ' nameError` , yang bermaksud pembolehubah tidak ditakrifkan dalam program ini.

Juga, sangat penting untuk diingat bahawa anda perlu bergerak ke atas dalam hierarki peraturan LEGB dari skop semasa .

Juga Baca: Panduan Komprehensif untuk Pengaturcaraan Python Lanjutan

Bagaimanakah skopel skoper python?

Sekarang, mari kita pergi satu demi satu melalui semua contoh ini untuk memahami semua konsep ini secara mendalam:

1. Menggunakan pemboleh ubah global dalam skop tempatan

Untuk memahami ini mari kita ambil contoh, di sini fungsi ` g (y) ` bukan sahaja mencetak pembolehubah global ` x` tetapi juga mengubahnya sebagai ` x 1` .

Sekarang, sejak` x `tidak ditakrifkan dalam` g (y) ` , Python mengambil nilai pembolehubah global` x `.

 def g (y):
  Cetak (x)
  Cetak (x 1)

# Kerana x tidak berada dalam skop tempatan, ia akan pergi dan mengambil nilai x dari pembolehubah global
x = 1
g (x) # global di dalam pemboleh ubah tempatan
Cetak (x) # Pembolehubah Global

Output

 1<br><br> 2<br><br> 1

Output menunjukkan nilai ` x` dan ` x 1` mengesahkan bahawa pembolehubah global `x` tetap tidak berubah, tetapi telah digunakan oleh skop tempatan untuk mengeluarkan hasilnya dengan betul.

2. Menggunakan pemboleh ubah tempatan dalam skop tempatan

Sekarang, lihat contoh ini, di sini kita mempunyai definisi fungsi ` g (y) ` dan di dalam fungsi yang diberikan ` g` , nama ` x` ditakrifkan sebagai pemboleh ubah tempatan dan juga diubah suai.

 def g (y):
  x = 10 # pemboleh ubah tempatan
  x = 1
  Cetak (x)


x = 1 # pembolehubah global
g (x)
Cetak (x)

Output

 11<br><br> 1

Sebagai bukti, global ` X` tetap tidak berubah, dan pembolehubah tempatan menggunakan pembolehubah skop tempatan untuk mencetak kenyataan yang menunjukkan 11 sebagai output melalui fungsi dan 1 output oleh skop global, seperti yang diharapkan.

Juga Baca: Panduan Komprehensif untuk Struktur Data Terbina Python

3. Mengubah pemboleh ubah global di dalam skop tempatan

Tetapi adakah mungkin untuk mengubah suai pembolehubah global` x `tanpa mengisytiharkannya sebagai` global `?

Jawapannya tidak! Anda tidak boleh mengubah suai nilai pembolehubah global dari skop tempatan, kerana berbuat demikian akan mengakibatkan kesilapan.

 def h (y):

  Fungsi # boleh menggunakan pemboleh ubah global, jika tidak ada
  x = 10 # tetapi tidak dapat mengubah nilai global di dalam pemboleh ubah tempatan

x = 1
H (x)
Cetak (x)

Output

 Traceback Unboundlocalerror (panggilan terkini terakhir)<br><br> <ipython-input-3-130c677cc9ab> dalam <sel sel:> ()<br><br> 3<br><br> 4 x = 1<br><br> ----> 5 jam (x)<br><br> 6 Cetak (x)<br><br> <ipython-input-3-130c677cc9ab> dalam h (y)<br><br> 1def h (y):<br><br> ----> 2 x = 10<br><br> 3<br><br> 4 x = 1<br><br> 5 jam (x)</ipython-input-3-130c677cc9ab></sel></ipython-input-3-130c677cc9ab>

Unboundlocalerror: pembolehubah tempatan `x` dirujuk sebelum tugasan

Ini mengakibatkan ` unboundlocalerror` kerana Python merawat `x` sebagai pemboleh ubah tempatan kerana operasi tugasan, tetapi ia belum dimulakan secara tempatan. Juga, walaupun pembolehubah tempatan boleh mengakses pembolehubah global, anda tidak boleh membuat perubahan kepada pembolehubah global (anda hanya boleh membaca, tidak menulis).

Juga Baca: Asas Pengaturcaraan Python untuk Pemula

4. Mengubah pemboleh ubah global di dalam skop tempatan menggunakan perisytiharan

Tetapi kerana saya selalu memberitahu anda bahawa Python sebenarnya adalah bahasa yang manis dan walaupun tidak disyorkan untuk melakukan apa -apa pengubahsuaian atau perubahan pada pemboleh ubah global. Itu tidak bermakna Python tidak memberi anda fungsi ini, seperti dengan mengisytiharkan `x` sebagai` global` menggunakan kata kunci yang sama, fungsi itu dapat mengubah suai pembolehubah global `x`.

 def h (y):
  Global X # Sekarang ini dapat mengubah nilai global di dalam pemboleh ubah tempatan
  # Tetapi itu bukan cara pengekodan yang baik, anda harus memberi tumpuan kepada mengurangkan penggunaan kata kunci global ini
  x = 10

x = 1
H (x)
Cetak (x)

Output

 11

Output mengesahkan bahawa `X` telah dikemas kini secara global. Walau bagaimanapun, ingat bahawa perubahan akan menjejaskan keseluruhan program, kerana mengubahsuai fungsi utama juga akan mempengaruhi fungsi lain, yang bukan amalan pengaturcaraan yang baik.

5. Mengubah suai skop tempatan VariableInside Global menggunakan fungsi

Juga, anda boleh mengubah suai pembolehubah global di dalam fungsi ` g (x)` dengan kenaikan `x` oleh 10. Ia akan mencetak nilai baru dan mengembalikannya.

Nota : Ini tidak bermakna anda mengubahsuai pembolehubah global itu sendiri, kerana ia, bagaimanapun, tidak mungkin tanpa kata kunci `global` .

 def g (x):
  x = 10
  Cetak ("dalam f (x): x =", x)
  Kembali x # kembali f (x)

x = 2
z = g (x)
Cetak ("Dalam skop program utama: z =", z)
Cetak ("Dalam skop program utama: x =", x)

Output

 dalam f (x): x = 12<br><br> Dalam skop program utama: z = 12<br><br> Dalam skop program utama: x = 2

Di sini, global `x` tetap tidak berubah, sementara nilai yang dikembalikan ` Z` adalah nilai yang dikemas kini baru.

Apakah fungsi bersarang?

Fungsi yang ditakrifkan di dalam fungsi ` def` yang lain dipanggil fungsi bersarang atau fungsi dalaman .

Berikut adalah contoh untuk fungsi bersarang untuk pemahaman yang lebih baik:

 def f ():
  def g ():
    Cetak ("Fungsi Dalam G")
  g ()
  Cetak ("Fungsi Dalam F")

f ()

Output

 Fungsi dalam g<br><br> Fungsi dalam f

Nota : Fungsi bersarang ` g` dipanggil dalam fungsi ` f` , mencetak mesej dari kedua -dua fungsi. Fungsi panggilan ` g` di luar ` f` willresults dalam kesilapan, kerana ` g` tidak ditakrifkan dalam skop global.

 g () # Fungsi ini tidak ditakrifkan di luar fungsi f

Output

 TypeError Traceback (panggilan terkini terakhir)<br><br> <ipython-input-8-5fd69ddb5074> dalam <sel sel:> ()<br><br> ----> 1 g ()<br><br> TypeError: G () Hilang 1 Argumen Posisi Diperlukan: 'X'</sel></ipython-input-8-5fd69ddb5074>

Apakah skop pembolehubah yang melekat?

Python menawarkan skop pembolehubah yang berbeza dan khas untuk hanya nama -nama yang ditakrifkan di dalam fungsi bersarang, yang dikenali sebagai skop yang melekat . Ia juga dikenali sebagai skop ` non-tempatan` . Melampirkan skop adalah skop fungsi luar apabila terdapat fungsi tempatan, yang merupakan fungsi dalaman atau bersarang.

 def f ():
  x = 1
  def g ():
    Cetak ("Fungsi Dalam G")
    Cetak (x)
  g ()
  Cetak ("Fungsi Dalam F")
  
f ()

Pembolehubah ini `x` hadir di dalam skop yang melekat, yang boleh anda gunakan dalam skop tempatan, seperti yang ditunjukkan dalam contoh di atas. Inilah output:

Output

 Fungsi dalam g<br><br> 1<br><br> Fungsi dalam f

Sekarang, mari kita maju dan memahami skop baru ini dengan lebih baik.

7.Modifikasi pembolehubah global di dalam skop melampirkan tanpa pengisytiharan

Sekali lagi, mengubah suai pembolehubah global ` x` di dalam fungsi bersarang adalah mustahil .

 def g (x):
  def h ():
    x = 1
    Cetak ('dalam h (x): x =', x)
  x = x 1
  Cetak ('dalam g (x): x =', x)
  H (x)
  kembali x

x = 3
z = g (x)
Cetak ('dalam skop program utama: x =', x)
Cetak ('dalam skop program utama: z =', z)

Output

 dalam g (x): x = 4<br><br> -----------------------------------------------------------------------<br> TypeError Traceback (panggilan terkini terakhir)<br><br> <ipython-input-12-5bcfb2edb396> dalam <sel sel:> ()<br><br> 9<br><br> 10 x = 3<br><br> ---> 11 z = g (x)<br><br> 12 Cetak ('Dalam Skop Program Utama: x =', x)<br><br> 13 Cetak ('Dalam skop program utama: z =', z)<br><br> <ipython-input-12-5bcfb2edb396> dalam g (x)<br><br> 5 x = x 1<br><br> 6 cetak ('dalam g (x): x =', x)<br><br> ----> 7 h (x)<br><br> 8 Kembali x<br><br> 9<br><br> TypeError: g. <mocals> .h () mengambil 0 argumen kedudukan tetapi 1 diberikan</mocals></ipython-input-12-5bcfb2edb396></sel></ipython-input-12-5bcfb2edb396>

Sebagai fungsi ` h () `, ditakrifkan tanpa sebarang parameter, tetapi `h (x)` dipanggil dengan hujah. Ini akan memberikan `typeError`.Osso, walaupun pemboleh ubah yang melampirkan dapat mengakses pemboleh ubah global, anda tidak dapat melakukan perubahan dalam pembolehubah global.

8. Mengubah pemboleh ubah bersarang di dalam skop tempatan menggunakan perisytiharan

Begitu juga dengan kata kunci ` global` , Python menawarkan pemaju dengan kata kunci ` nonlocal '. Itu membolehkan fungsi bersarang ` H` untuk mengubah suai pembolehubah `x` ditakrifkan dalam fungsi yang melampirkan ` g` .

 def g (x):
  def h ():
    nonlocal x # beritahu h () untuk menggunakan x dari g (x)
    x = 1
    Cetak ('dalam h (x): x =', x)
  x = x 1
  Cetak ('dalam g (x): x =', x)
  h () # call h () tanpa sebarang hujah
  kembali x

x = 3
z = g (x)
Cetak ('dalam skop program utama: x =', x)
Cetak ('dalam skop program utama: z =', z)

Output

 dalam g (x): x = 4<br><br> dalam h (x): x = 5<br><br> Dalam skop program utama: x = 3<br><br> Dalam skop program utama: z = 5

Output menunjukkan perubahan yang dibuat dalam kedua -dua fungsi dan pembolehubah global ` x` tetap tidak berubah.

Akhir sekali, ambil perhatian bahawa bergantung kepada mana skop ditakrifkan, setiap skop sepadan dengan tahap akses yang berbeza sepanjang program dan akan mempunyai jangka hayat yang berbeza untuk ruang nama/s dalam kod.

Juga Baca: Tutorial Python Lengkap untuk Mempelajari Sains Data Dari Gores

Kesimpulan

Artikel ini meneroka bagaimana Python mengendalikan pembolehubah tempatan dan global dan fungsi bersarang. Kami telah mengetahui bahawa ruang nama adalah kamus yang Python menawarkan pemaju, dari mana anda dapat mencari nama yang berubah -ubah dan nilainya yang disimpan dalam skop memori Python. Selanjutnya, skop adalah empat jenis: tempatan, melampirkan, global, dan terbina dalam.

Ini benar -benar berguna untuk mengelakkan konflik penamaan dan untuk menjejaki nama/pengenal merujuk kepada objek mana di seluruh bahagian program.

Juga, jika anda ingin mengubah suai pembolehubah dalam skop global dari skop tempatan, anda boleh menggunakan kata kunci ` global` . Begitu juga, anda boleh menggunakan kata kunci `nonlocal` untuk menutup skop.

1. Skop Tempatan : Pembolehubah yang dibuat di dalam fungsi, hanya boleh diakses dalam fungsi itu, dan dipadam apabila fungsi kembali atau sebarang pengecualian dibangkitkan, iaitu, tidak dikendalikan semasa menulis fungsi.
2. Skop yang melampirkan atau bukan tempatan : Pembolehubah yang dibuat dalam fungsi luar fungsi bersarang, boleh diakses dengan fungsi dalaman.
3. Skop Global : Pembolehubah yang dibuat dalam program ` __Main__` , boleh diakses sepanjang program dan terakhir sehingga penterjemah berakhir.

Saya harap ini telah membantu anda mendapatkan pandangan untuk menulis kod peringkat pengeluaran yang baik sambil mengikuti amalan terbaik yang berkaitan dengan industri dan mengurangkan pengecualian yang ditentukan oleh pemaju. Walau bagaimanapun, ini adalah langkah pertama ke arah menjadikan program kami lebih mantap, dan kami mempunyai lebih banyak lagi untuk dilindungi.

Oleh itu, tunggu untuk artikel seterusnya, di mana kami akan membincangkan siri dan deserialization fail dalam bahasa pengaturcaraan Python!

Soalan yang sering ditanya

Q1. Apakah ruang nama di Python?

Ans. Ruang nama di Python menyusun dan mengurus nama atau pengenal dalam program. Pada asasnya, mereka bertindak seperti bekas atau kamus yang menyimpan nama yang dipetakan ke objek mereka, seperti pembolehubah dan fungsi.

S2. Apakah Peraturan Legb di Python?

Ans. Peraturan Legb di Python adalah urutan di mana seorang jurubahasa python melihat semasa bekerja dengan nama -nama atau biasanya dikenali sebagai pengenal. Ia bermaksud tempatan, melampirkan, global, dan terbina dalam:
1. Tempatan : Nama yang ditakrifkan dalam fungsi.
2. Melampirkan : Nama dalam skop tempatan sebarang fungsi yang dilampirkan (fungsi bersarang).
3. Global : Nama -nama yang ditakrifkan di peringkat tertinggi skrip atau modul.
Built-In : Nama-nama yang telah ditentukan sebelumnya dalam Python, seperti ` Print` atau ` Len` .

Q3. Apakah penggunaan kata kunci `global 'dalam Python?

Ans. Kata kunci global membolehkan fungsi untuk mengubah suai pembolehubah yang ditakrifkan dalam skop global dan membolehkan pembolehubah tinggal di luar operasi. Nota: Hanya kerana anda boleh melakukannya, tidak bermakna anda harus menggunakan ini (sering), kerana ia bukan amalan pengaturcaraan yang baik.

Q4. Mengapa disyorkan untuk meminimumkan penggunaan pembolehubah global?

Ans. Lebih banyak pembolehubah global boleh membawa kepada program yang sukar difahami dan dikekalkan. Ia juga boleh menyebabkan perubahan yang tidak diingini, menjadikan debugging lebih sukar. Secara amnya lebih baik menggunakan pembolehubah tempatan dan lulus mereka seperti yang diperlukan.

S5. Apakah penggunaan kata kunci `nonlocal 'dalam fungsi bersarang?

Ans. Sama seperti kata kunci global, Python menawarkan kata kunci `nonlocal` untuk mengubah suai pembolehubah yang melampirkan. Kata kunci bukan tempatan boleh mengubah suai pembolehubah yang ditakrifkan dalam fungsi melampirkan fungsi bersarang, menyediakan cara untuk mengawal skop pembolehubah dalam fungsi bersarang.

Atas ialah kandungan terperinci Panduan Komprehensif mengenai Python Namespaces & Variable Scopes. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!