Ubah variabel dalam loop python

Ini bisa menjadi kejutan untuk mendapatkan kode yang sebelumnya berfungsi ketika dimodifikasi dengan menambahkan pernyataan penugasan di suatu tempat di badan fungsi

Kode ini

>>> x = 10
>>> def bar():
..     print(x)
...
>>> bar()
10

bekerja, tapi kode ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

menghasilkan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Ini karena ketika Anda membuat tugas ke variabel dalam lingkup, variabel tersebut menjadi lokal untuk lingkup tersebut dan membayangi variabel bernama serupa di lingkup luar. Karena pernyataan terakhir di foo menetapkan nilai baru ke

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Dalam contoh di atas, Anda dapat mengakses variabel lingkup luar dengan mendeklarasikannya secara global

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Deklarasi eksplisit ini diperlukan untuk mengingatkan Anda bahwa (tidak seperti situasi analog yang dangkal dengan kelas dan variabel instan) Anda sebenarnya mengubah nilai variabel di lingkup luar

>>> print(x)
11

Anda dapat melakukan hal serupa dalam lingkup bersarang menggunakan kata kunci

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Dalam Python, variabel yang hanya direferensikan di dalam suatu fungsi bersifat global secara implisit. Jika sebuah variabel diberi nilai di mana saja di dalam badan fungsi, itu dianggap sebagai lokal kecuali secara eksplisit dinyatakan sebagai global

Meskipun agak mengejutkan pada awalnya, pertimbangan sesaat menjelaskan hal ini. Di satu sisi, mensyaratkan variabel yang ditetapkan memberikan batasan terhadap efek samping yang tidak diinginkan. Di sisi lain, jika

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Asumsikan Anda menggunakan for loop untuk mendefinisikan beberapa lambda yang berbeda (atau bahkan fungsi biasa), mis. g

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Ini memberi Anda daftar yang berisi 5 lambda yang menghitung

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> squares[2]()
16
>>> squares[4]()
16

Hal ini terjadi karena

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 8
>>> squares[2]()
64

Untuk menghindari hal ini, Anda perlu menyimpan nilai dalam variabel lokal ke lambda, sehingga mereka tidak bergantung pada nilai global

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Di sini,

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Perhatikan bahwa perilaku ini tidak khusus untuk lambda, tetapi juga berlaku untuk fungsi reguler

Cara kanonik untuk berbagi informasi lintas modul dalam satu program adalah dengan membuat modul khusus (sering disebut config atau cfg). Cukup impor modul konfigurasi di semua modul aplikasi Anda; . Karena hanya ada satu instance dari setiap modul, setiap perubahan yang dibuat pada objek modul akan tercermin di mana-mana. Sebagai contoh

config. py

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

mod. py

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

utama. py

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Perhatikan bahwa menggunakan modul juga merupakan dasar untuk mengimplementasikan pola desain singleton, untuk alasan yang sama

Secara umum, jangan gunakan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Impor modul di bagian atas file. Melakukan hal itu memperjelas modul apa yang dibutuhkan kode Anda dan menghindari pertanyaan apakah nama modul ada dalam cakupan. Menggunakan satu impor per baris memudahkan untuk menambah dan menghapus impor modul, tetapi menggunakan banyak impor per baris menggunakan lebih sedikit ruang layar

Ini praktik yang baik jika Anda mengimpor modul dalam urutan berikut

1. modul pustaka standar – e. g. , , ,

2. modul perpustakaan pihak ketiga (apa pun yang dipasang di direktori paket situs Python) – e. g.

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   _57,

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   58,

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   59

3. modul yang dikembangkan secara lokal

Terkadang perlu memindahkan impor ke fungsi atau kelas untuk menghindari masalah dengan impor melingkar. kata Gordon McMillan

Circular imports are fine where both modules use the “import ” form of import. They fail when the 2nd module wants to grab a name out of the first (“from module import name”) and the import is at the top level. That’s because names in the 1st are not yet available, because the first module is busy importing the 2nd.

Dalam hal ini, jika modul kedua hanya digunakan dalam satu fungsi, maka impor dapat dengan mudah dipindahkan ke fungsi tersebut. Pada saat impor dipanggil, modul pertama sudah selesai diinisialisasi, dan modul kedua dapat melakukan impornya

Mungkin juga diperlukan untuk memindahkan impor dari kode tingkat atas jika beberapa modul khusus untuk platform. Dalam hal ini, bahkan tidak mungkin untuk mengimpor semua modul di bagian atas file. Dalam hal ini, mengimpor modul yang benar dalam kode khusus platform yang sesuai adalah pilihan yang baik

Hanya pindahkan impor ke lingkup lokal, seperti di dalam definisi fungsi, jika diperlukan untuk menyelesaikan masalah seperti menghindari impor melingkar atau mencoba mengurangi waktu inisialisasi modul. Teknik ini sangat membantu jika banyak impor yang tidak diperlukan bergantung pada bagaimana program dijalankan. Anda mungkin juga ingin memindahkan impor ke suatu fungsi jika modul hanya digunakan dalam fungsi itu. Perhatikan bahwa memuat modul pertama kali mungkin mahal karena inisialisasi modul satu kali, tetapi memuat modul berkali-kali sebenarnya gratis, hanya menghabiskan beberapa pencarian kamus. Bahkan jika nama modul telah keluar dari ruang lingkup, modul tersebut mungkin tersedia di

Jenis bug ini biasanya menggigit programmer pemula. Pertimbangkan fungsi ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Pertama kali Anda memanggil fungsi ini,

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Seringkali pemanggilan fungsi diharapkan membuat objek baru untuk nilai default. Bukan ini yang terjadi. Nilai default dibuat tepat satu kali, saat fungsi ditentukan. Jika objek itu diubah, seperti kamus dalam contoh ini, panggilan selanjutnya ke fungsi tersebut akan merujuk ke objek yang diubah ini

Menurut definisi, objek yang tidak dapat diubah seperti angka, string, tupel, dan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Karena fitur ini, merupakan praktik pemrograman yang baik untuk tidak menggunakan objek yang dapat diubah sebagai nilai default. Alih-alih, gunakan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

tetapi

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Fitur ini dapat bermanfaat. Saat Anda memiliki fungsi yang memakan waktu komputasi, teknik yang umum adalah meng-cache parameter dan nilai yang dihasilkan dari setiap panggilan ke fungsi, dan mengembalikan nilai yang di-cache jika nilai yang sama diminta lagi. Ini disebut "memoisasi", dan dapat diimplementasikan seperti ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Anda bisa menggunakan variabel global yang berisi kamus alih-alih nilai default;

Kumpulkan argumen menggunakan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

didefinisikan oleh nama yang muncul dalam definisi fungsi, sedangkan nilai sebenarnya diteruskan ke fungsi saat memanggilnya. Parameter menentukan apa yang dapat diterima oleh suatu fungsi. Misalnya, diberikan definisi fungsi

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

foo, bar dan kwargs adalah parameter dari

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

nilai

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Jika Anda menulis kode seperti

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Anda mungkin bertanya-tanya mengapa menambahkan elemen ke

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Ada dua faktor yang menghasilkan hasil ini

1. Variabel hanyalah nama yang merujuk ke objek. Melakukan

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   _79 tidak membuat salinan daftar – itu membuat variabel baru

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   77 yang merujuk ke objek yang sama

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   24 mengacu pada. Ini berarti bahwa hanya ada satu objek (daftar), dan keduanya

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   24 dan

   >>> x = 10
   >>> def foo():
   ..     print(x)
   ..     x += 1
   

   77 mengacu padanya

2. Daftar adalah , artinya Anda dapat mengubah kontennya

Setelah panggilan ke

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Jika kami malah menetapkan objek yang tidak dapat diubah ke

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

kita dapat melihat bahwa dalam hal ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Beberapa operasi (misalnya

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Namun, ada satu kelas operasi dimana operasi yang sama terkadang memiliki perilaku yang berbeda dengan tipe yang berbeda. operator penugasan ditambah. Misalnya,

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Dengan kata lain

• Jika kita memiliki objek yang bisa berubah (, , , dll. ), kita dapat menggunakan beberapa operasi khusus untuk memutasinya dan semua variabel yang merujuknya akan melihat perubahannya

• Jika kita memiliki objek yang tidak dapat diubah (, , , dll. ), semua variabel yang merujuk padanya akan selalu melihat nilai yang sama, tetapi operasi yang mengubah nilai tersebut menjadi nilai baru selalu mengembalikan objek baru

Jika Anda ingin mengetahui apakah dua variabel merujuk ke objek yang sama atau tidak, Anda dapat menggunakan operator, atau fungsi bawaan

Ingatlah bahwa argumen diteruskan dengan penugasan di Python. Karena penugasan hanya membuat referensi ke objek, tidak ada alias antara nama argumen di pemanggil dan yang dipanggil, jadi tidak ada referensi panggilan per se. Anda dapat mencapai efek yang diinginkan dengan beberapa cara

1. Dengan mengembalikan tuple hasil

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   _3

   Ini hampir selalu merupakan solusi paling jelas

2. Dengan menggunakan variabel global. Ini tidak aman untuk thread, dan tidak disarankan

3. Dengan melewati objek yang bisa berubah (dapat diubah di tempat).

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   _4

4. Dengan mengirimkan kamus yang bermutasi

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   5

5. Atau bundel nilai dalam instance kelas

   >>> foo()
   Traceback (most recent call last):
     ...
   UnboundLocalError: local variable 'x' referenced before assignment
   

   6

   Hampir tidak pernah ada alasan bagus untuk menjadi serumit ini

Pilihan terbaik Anda adalah mengembalikan tuple yang berisi banyak hasil

Anda memiliki dua pilihan. Anda dapat menggunakan cakupan bersarang atau Anda dapat menggunakan objek yang dapat dipanggil. Misalnya, Anda ingin mendefinisikan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Atau menggunakan objek yang bisa dipanggil

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Dalam kedua kasus tersebut,

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

memberikan objek yang dapat dipanggil di mana

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Pendekatan objek yang dapat dipanggil memiliki kelemahan yaitu sedikit lebih lambat dan menghasilkan kode yang sedikit lebih panjang. Namun, perhatikan bahwa kumpulan callable dapat membagikan tanda tangan mereka melalui pewarisan

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Objek dapat mengenkapsulasi status untuk beberapa metode

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Di sini

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Secara umum, coba atau untuk kasus umum. Tidak semua objek bisa disalin, tapi sebagian besar bisa

Beberapa objek dapat disalin dengan lebih mudah. Kamus memiliki metode

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Urutan dapat disalin dengan mengiris

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Untuk instance

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Secara umum, tidak bisa, karena objek sebenarnya tidak memiliki nama. Pada dasarnya, penugasan selalu mengikat sebuah nama ke sebuah nilai; . Pertimbangkan kode berikut

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Bisa dibilang kelas tersebut memiliki nama. meskipun terikat pada dua nama dan dipanggil melalui nama

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Secara umum, kode Anda tidak perlu "mengetahui nama" dari nilai tertentu. Kecuali jika Anda sengaja menulis program introspektif, ini biasanya merupakan indikasi bahwa perubahan pendekatan mungkin bermanfaat

Dalam komp. lang. python, Fredrik Lundh pernah memberikan analogi yang sangat bagus untuk menjawab pertanyaan ini

Cara yang sama seperti Anda mendapatkan nama kucing yang Anda temukan di teras Anda. kucing (objek) itu sendiri tidak dapat memberi tahu Anda namanya, dan ia tidak terlalu peduli - jadi satu-satunya cara untuk mengetahui apa namanya adalah dengan bertanya kepada semua tetangga (ruang nama) Anda apakah itu kucing (objek) mereka…

…. dan jangan kaget jika Anda menemukan bahwa itu dikenal dengan banyak nama, atau tanpa nama sama sekali

Koma bukan operator di Python. Pertimbangkan sesi ini

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Karena koma bukan operator, tetapi pemisah antara ekspresi di atas dievaluasi seolah-olah Anda telah memasukkannya

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

bukan

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Hal yang sama berlaku untuk berbagai operator penugasan (

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Ya ada. Sintaksnya adalah sebagai berikut

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Sebelum sintaks ini diperkenalkan di Python 2. 5, idiom umum adalah menggunakan operator logika

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Namun, idiom ini tidak aman, karena dapat memberikan hasil yang salah ketika on_true memiliki nilai boolean yang salah. Oleh karena itu, selalu lebih baik menggunakan formulir ________3______44

Ya. Biasanya ini dilakukan dengan bersarang di dalam

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> print(x)
11

Jangan coba ini di rumah, anak-anak

Garis miring dalam daftar argumen suatu fungsi menunjukkan bahwa parameter sebelumnya hanya untuk posisi. Parameter khusus posisi adalah parameter tanpa nama yang dapat digunakan secara eksternal. Saat memanggil fungsi yang menerima parameter hanya posisional, argumen dipetakan ke parameter hanya berdasarkan posisinya. Misalnya, adalah fungsi yang menerima parameter hanya posisi. Dokumentasinya terlihat seperti ini

>>> print(x)
11

Garis miring di akhir daftar parameter berarti kedua parameter hanya untuk posisi. Jadi, memanggil dengan argumen kata kunci akan menyebabkan kesalahan

>>> print(x)
11

Untuk menentukan digit oktal, awali nilai oktal dengan nol, lalu huruf kecil atau huruf besar “o”. Misalnya, untuk mengatur variabel "a" ke nilai oktal "10" (8 dalam desimal), ketik

>>> print(x)
11

Heksadesimal sama mudahnya. Cukup awali angka heksadesimal dengan nol, lalu huruf kecil atau besar “x”. Digit heksadesimal dapat ditentukan dalam huruf kecil atau huruf besar. Misalnya, dalam juru bahasa Python

>>> print(x)
11

Ini terutama didorong oleh keinginan bahwa

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> print(x)
11

maka pembagian bilangan bulat harus mengembalikan lantai. C juga mengharuskan identitas tersebut dipertahankan, dan kemudian kompiler yang memotong

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Ada beberapa kasus penggunaan nyata untuk

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Mencoba mencari

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> print(x)
11

Solusinya adalah memisahkan literal dari titik dengan spasi atau tanda kurung

>>> print(x)
11

Untuk bilangan bulat, gunakan konstruktor tipe bawaan, mis. g.

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Secara default, ini mengartikan angka sebagai desimal, sehingga

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Jangan gunakan fungsi bawaan jika yang Anda butuhkan hanyalah mengonversi string menjadi angka. akan secara signifikan lebih lambat dan menimbulkan risiko keamanan. seseorang dapat memberi Anda ekspresi Python yang mungkin memiliki efek samping yang tidak diinginkan. Misalnya, seseorang dapat mengirimkan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

juga memiliki efek menafsirkan angka sebagai ekspresi Python, sehingga e. g.

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Untuk mengkonversi, e. g. , nomor

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Anda tidak bisa, karena string tidak dapat diubah. Dalam kebanyakan situasi, Anda cukup membuat string baru dari berbagai bagian yang ingin Anda rakit. Namun, jika Anda memerlukan objek dengan kemampuan untuk mengubah data unicode di tempat, coba gunakan objek atau modul

>>> print(x)
11

Ada berbagai teknik

• Yang terbaik adalah menggunakan kamus yang memetakan string ke fungsi. Keuntungan utama dari teknik ini adalah string tidak perlu cocok dengan nama fungsi. Ini juga merupakan teknik utama yang digunakan untuk meniru konstruksi kasus

  >>> print(x)
  11
  

  _9

• Gunakan fungsi bawaan

  >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  _0

  Perhatikan bahwa berfungsi pada objek apa pun, termasuk kelas, instance kelas, modul, dan sebagainya

  Ini digunakan di beberapa tempat di perpustakaan standar, seperti ini

  >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  _1

• Gunakan untuk menyelesaikan nama fungsi

  >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  _2

Anda dapat menggunakan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Karena ini biasanya hanya diinginkan saat membaca teks satu baris pada satu waktu, menggunakan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Tidak seperti itu

Untuk penguraian input sederhana, pendekatan termudah biasanya adalah membagi baris menjadi kata-kata yang dipisahkan spasi menggunakan metode objek string dan kemudian mengonversi string desimal menjadi nilai numerik menggunakan atau.

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Untuk penguraian input yang lebih rumit, ekspresi reguler lebih kuat daripada C

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Lihat

String mentah yang diakhiri dengan garis miring terbalik dalam jumlah ganjil akan lolos dari kutipan string

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Ada beberapa solusi untuk ini. Salah satunya adalah menggunakan string biasa dan menggandakan garis miring terbalik

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Cara lainnya adalah menggabungkan string biasa yang berisi tanda garis miring terbalik ke string mentah

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Dimungkinkan juga untuk menggunakan garis miring terbalik pada Windows

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Perhatikan bahwa meskipun garis miring terbalik akan "melarikan diri" dari kutipan untuk tujuan menentukan di mana string mentah berakhir, tidak ada pelolosan yang terjadi saat menginterpretasikan nilai string mentah. Artinya, garis miring terbalik tetap ada pada nilai string mentah

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Lihat juga spesifikasinya di

Itu yang sulit, secara umum. Pertama, berikut adalah daftar hal yang perlu diingat sebelum menyelam lebih jauh

• Karakteristik kinerja bervariasi di seluruh implementasi Python. FAQ ini berfokus pada

• Perilaku dapat bervariasi di seluruh sistem operasi, terutama saat berbicara tentang I/O atau multi-threading

• Anda harus selalu menemukan hot spot di program Anda sebelum mencoba mengoptimalkan kode apa pun (lihat modul)

• Menulis skrip tolok ukur akan memungkinkan Anda melakukan iterasi dengan cepat saat mencari peningkatan (lihat modul)

• Sangat disarankan untuk memiliki cakupan kode yang baik (melalui pengujian unit atau teknik lainnya) sebelum berpotensi memperkenalkan regresi yang tersembunyi dalam pengoptimalan canggih

Meski begitu, ada banyak trik untuk mempercepat kode Python. Berikut adalah beberapa prinsip umum yang sangat membantu untuk mencapai tingkat kinerja yang dapat diterima

• Membuat algoritme Anda lebih cepat (atau mengubah ke yang lebih cepat) dapat menghasilkan manfaat yang jauh lebih besar daripada mencoba memercikkan trik pengoptimalan mikro ke seluruh kode Anda

• Gunakan struktur data yang tepat. Pelajari dokumentasi untuk dan modul

• Ketika perpustakaan standar menyediakan primitif untuk melakukan sesuatu, kemungkinan (walaupun tidak dijamin) lebih cepat daripada alternatif apa pun yang mungkin Anda buat. Ini berlaku ganda untuk primitif yang ditulis dalam C, seperti bawaan dan beberapa jenis ekstensi. Misalnya, pastikan untuk menggunakan metode bawaan atau fungsi terkait untuk melakukan penyortiran (dan lihat contoh penggunaan tingkat lanjut yang sedang)

• Abstraksi cenderung menciptakan tipuan dan memaksa penafsir untuk bekerja lebih banyak. Jika tingkat tipuan melebihi jumlah pekerjaan berguna yang dilakukan, program Anda akan lebih lambat. Anda harus menghindari abstraksi yang berlebihan, terutama dalam bentuk fungsi atau metode kecil (yang juga seringkali merugikan keterbacaan)

Jika Anda telah mencapai batas yang diperbolehkan oleh Python murni, ada alat untuk membawa Anda lebih jauh. Misalnya, Cython dapat mengkompilasi versi kode Python yang sedikit dimodifikasi menjadi ekstensi C, dan dapat digunakan di banyak platform berbeda. Cython dapat memanfaatkan kompilasi (dan anotasi tipe opsional) untuk membuat kode Anda jauh lebih cepat daripada saat ditafsirkan. Jika Anda yakin dengan keterampilan pemrograman C Anda, Anda juga bisa melakukannya sendiri

Lihat juga

Halaman wiki yang dikhususkan untuk tip kinerja

dan objek tidak dapat diubah, oleh karena itu menggabungkan banyak string menjadi tidak efisien karena setiap penggabungan membuat objek baru. Dalam kasus umum, total biaya runtime adalah kuadrat dalam total panjang string

Untuk mengumpulkan banyak objek, idiom yang disarankan adalah menempatkannya ke dalam daftar dan menelepon di bagian akhir

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

(idiom lain yang cukup efisien adalah menggunakan )

Untuk mengumpulkan banyak objek, idiom yang disarankan adalah memperluas objek menggunakan penggabungan di tempat (operator

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Konstruktor tipe

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Misalnya,

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Konstruktor tipe

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Urutan python diindeks dengan angka positif dan angka negatif. Untuk bilangan positif 0 adalah indeks pertama 1 adalah indeks kedua dan seterusnya. Untuk indeks negatif -1 adalah indeks terakhir dan -2 adalah indeks kedua dari belakang (di sebelah terakhir) dan seterusnya. Pikirkan

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Menggunakan indeks negatif bisa sangat nyaman. Misalnya

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Gunakan fungsi bawaan

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Ini tidak akan menyentuh urutan asli Anda, tetapi buat salinan baru dengan urutan terbalik untuk mengulanginya

Lihat Buku Masak Python untuk diskusi panjang tentang banyak cara untuk melakukan ini

https. //kode. status aktif. com/resep/52560/

Jika Anda tidak keberatan menyusun ulang daftar, urutkan, lalu pindai dari akhir daftar, hapus duplikat saat Anda melakukannya

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Jika semua elemen daftar dapat digunakan sebagai kunci set (mis. e. mereka semua ) ini seringkali lebih cepat

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Ini mengubah daftar menjadi satu set, sehingga menghapus duplikat, dan kemudian kembali ke daftar

Seperti halnya menghapus duplikat, iterasi secara terbalik secara eksplisit dengan kondisi hapus adalah salah satu kemungkinannya. Namun, lebih mudah dan lebih cepat untuk menggunakan penggantian irisan dengan iterasi maju implisit atau eksplisit. Berikut adalah tiga variasi

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Pemahaman daftar mungkin tercepat

Gunakan daftar

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Daftar setara dengan array C atau Pascal dalam kompleksitas waktunya;

Modul

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Untuk mendapatkan daftar tertaut gaya Lisp, Anda dapat meniru sel kontra menggunakan tupel

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Jika mutabilitas diinginkan, Anda bisa menggunakan daftar, bukan tupel. Di sini analog mobil Lisp adalah

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Anda mungkin mencoba membuat array multidimensi seperti ini

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Ini terlihat benar jika Anda mencetaknya

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Namun saat Anda menetapkan nilai, nilai itu muncul di banyak tempat

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda: x**2)

Alasannya adalah mereplikasi daftar dengan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Pendekatan yang disarankan adalah membuat daftar dengan panjang yang diinginkan terlebih dahulu lalu mengisi setiap elemen dengan daftar yang baru dibuat

>>> squares[2]()
16
>>> squares[4]()
16

Ini menghasilkan daftar yang berisi 3 daftar berbeda dengan panjang dua. Anda juga dapat menggunakan pemahaman daftar

>>> squares[2]()
16
>>> squares[4]()
16

Atau, Anda dapat menggunakan ekstensi yang menyediakan tipe data matriks;

Untuk memanggil metode atau fungsi dan mengumpulkan nilai pengembalian adalah daftar, a adalah solusi yang elegan

>>> squares[2]()
16
>>> squares[4]()
16

Untuk hanya menjalankan metode atau fungsi tanpa menyimpan nilai yang dikembalikan, loop biasa sudah cukup

>>> squares[2]()
16
>>> squares[4]()
16

Ini karena kombinasi dari fakta bahwa operator penugasan yang diperbesar adalah operator penugasan, dan perbedaan antara objek yang dapat diubah dan yang tidak dapat diubah di Python

Diskusi ini berlaku secara umum ketika operator penugasan tambahan diterapkan ke elemen tupel yang mengarah ke objek yang dapat diubah, tetapi kami akan menggunakan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Jika Anda menulis

>>> squares[2]()
16
>>> squares[4]()
16

Alasan pengecualian harus segera jelas.

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Di balik selimut, apa yang dilakukan pernyataan penugasan tambahan ini kira-kira seperti ini

>>> squares[2]()
16
>>> squares[4]()
16

Itu adalah bagian penugasan dari operasi yang menghasilkan kesalahan, karena tupel tidak dapat diubah

Ketika Anda menulis sesuatu seperti

>>> squares[2]()
16
>>> squares[4]()
16

Pengecualian ini sedikit lebih mengejutkan, dan yang lebih mengejutkan lagi adalah fakta bahwa meskipun ada kesalahan, appendnya berfungsi

>>> squares[2]()
16
>>> squares[4]()
16

Untuk mengetahui mengapa hal ini terjadi, Anda perlu mengetahui bahwa (a) jika sebuah objek mengimplementasikan metode ajaib, objek tersebut akan dipanggil saat penugasan tambahan

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> squares[2]()
16
>>> squares[4]()
16

Ini setara dengan

>>> squares[2]()
16
>>> squares[4]()
16

Objek yang ditunjuk oleh a_list telah dimutasi, dan penunjuk ke objek yang dimutasi ditugaskan kembali ke

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

Jadi, dalam contoh tuple kita apa yang terjadi setara dengan

>>> x = 8
>>> squares[2]()
64

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Teknik tersebut, dikaitkan dengan Randal Schwartz dari komunitas Perl, mengurutkan elemen daftar dengan metrik yang memetakan setiap elemen ke "nilai pengurutan" -nya. Di Python, gunakan argumen

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Gabungkan mereka menjadi iterator tupel, urutkan daftar yang dihasilkan, lalu pilih elemen yang Anda inginkan

>>> x = 8
>>> squares[2]()
64

Kelas adalah tipe objek tertentu yang dibuat dengan mengeksekusi pernyataan kelas. Objek kelas digunakan sebagai templat untuk membuat objek instan, yang mewujudkan data (atribut) dan kode (metode) khusus untuk tipe data

Kelas dapat didasarkan pada satu atau lebih kelas lain, yang disebut kelas dasarnya (es). Itu kemudian mewarisi atribut dan metode kelas dasarnya. Ini memungkinkan model objek untuk disempurnakan secara berturut-turut dengan pewarisan. Anda mungkin memiliki kelas

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Metode adalah fungsi pada beberapa objek

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Diri hanyalah sebuah nama konvensional untuk argumen pertama dari sebuah metode. Sebuah metode didefinisikan sebagai

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Lihat juga

Gunakan fungsi bawaan. Anda dapat memeriksa apakah suatu objek adalah turunan dari sejumlah kelas dengan menyediakan tuple alih-alih satu kelas, mis. g.

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Perhatikan bahwa juga memeriksa warisan virtual dari sebuah. Jadi, tes akan mengembalikan

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

>>> x = 8
>>> squares[2]()
64

Perhatikan bahwa sebagian besar program tidak terlalu sering digunakan pada kelas yang ditentukan pengguna. Jika Anda mengembangkan kelas sendiri, gaya berorientasi objek yang lebih tepat adalah mendefinisikan metode pada kelas yang merangkum perilaku tertentu, alih-alih memeriksa kelas objek dan melakukan hal yang berbeda berdasarkan kelas apa itu. Misalnya, jika Anda memiliki fungsi yang melakukan sesuatu

>>> x = 8
>>> squares[2]()
64

Pendekatan yang lebih baik adalah dengan mendefinisikan metode

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Delegasi adalah teknik berorientasi objek (juga disebut pola desain). Katakanlah Anda memiliki objek

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Pemrogram Python dapat dengan mudah mengimplementasikan delegasi. Misalnya, kelas berikut mengimplementasikan kelas yang berperilaku seperti file tetapi mengubah semua data tertulis menjadi huruf besar

>>> x = 8
>>> squares[2]()
64

Di sini kelas

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Perhatikan bahwa untuk kasus yang lebih umum, pendelegasian bisa menjadi lebih rumit. Ketika atribut harus disetel dan juga diambil, kelas juga harus menentukan metode, dan harus melakukannya dengan hati-hati. Implementasi dasar

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 8
>>> squares[2]()
64

Sebagian besar implementasi

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Gunakan fungsi bawaan

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Dalam contoh, akan secara otomatis menentukan instance dari mana ia dipanggil (nilai

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Anda bisa menetapkan kelas dasar ke alias dan berasal dari alias. Maka yang harus Anda ubah hanyalah nilai yang diberikan ke alias. Kebetulan, trik ini juga berguna jika Anda ingin memutuskan secara dinamis (mis. g. tergantung pada ketersediaan sumber daya) kelas dasar mana yang akan digunakan. Contoh

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Baik data statis maupun metode statis (dalam pengertian C++ atau Java) didukung dengan Python

Untuk data statis, cukup tentukan atribut kelas. Untuk menetapkan nilai baru ke atribut, Anda harus menggunakan nama kelas secara eksplisit dalam penetapan

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

Hati-hati. dalam metode C, penugasan seperti

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Metode statis dimungkinkan

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Namun, cara yang jauh lebih mudah untuk mendapatkan efek dari metode statis adalah melalui fungsi tingkat modul yang sederhana

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Jika kode Anda terstruktur untuk mendefinisikan satu kelas (atau hierarki kelas yang terkait erat) per modul, ini menyediakan enkapsulasi yang diinginkan

Jawaban ini sebenarnya berlaku untuk semua metode, tetapi pertanyaan biasanya muncul pertama kali dalam konteks konstruktor

Di C++ Anda akan menulis

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Di Python Anda harus menulis satu konstruktor yang menangkap semua kasus menggunakan argumen default. Sebagai contoh

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Ini tidak sepenuhnya setara, tetapi cukup dekat dalam praktiknya

Anda juga bisa mencoba daftar argumen dengan panjang variabel, mis. g

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Pendekatan yang sama berlaku untuk semua definisi metode

Nama variabel dengan garis bawah ganda di depan "hancur" untuk menyediakan cara sederhana namun efektif untuk mendefinisikan variabel privat kelas. Pengidentifikasi apa pun dalam bentuk

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Ini tidak menjamin privasi. pengguna luar masih dapat dengan sengaja mengakses atribut "_classname__spam", dan nilai pribadi terlihat di

>>> print(x)
11

Ada beberapa kemungkinan alasan untuk ini

Pernyataan itu tidak harus memanggil - itu hanya mengurangi jumlah referensi objek, dan jika ini mencapai nol

>>> print(x)
11

Jika struktur data Anda berisi tautan melingkar (mis. g. pohon di mana setiap anak memiliki referensi orang tua dan setiap orang tua memiliki daftar anak-anak) jumlah referensi tidak akan pernah kembali ke nol. Sesekali Python menjalankan algoritme untuk mendeteksi siklus seperti itu, tetapi pengumpul sampah mungkin berjalan beberapa saat setelah referensi terakhir ke struktur data Anda hilang, sehingga metode

>>> print(x)
11

Terlepas dari pengumpul siklus, masih merupakan ide bagus untuk mendefinisikan metode

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Cara lain untuk menghindari referensi siklis adalah dengan menggunakan modul, yang memungkinkan Anda menunjuk ke objek tanpa menambah jumlah referensinya. Struktur data pohon, misalnya, harus menggunakan referensi yang lemah untuk referensi orang tua dan saudara kandungnya (jika mereka membutuhkannya. )

Terakhir, jika metode

>>> print(x)
11

Python tidak melacak semua contoh kelas (atau tipe bawaan). Anda dapat memprogram konstruktor kelas untuk melacak semua instance dengan menyimpan daftar referensi yang lemah untuk setiap instance

Builtin mengembalikan bilangan bulat yang dijamin unik selama masa pakai objek. Karena di CPython, ini adalah alamat memori objek, sering terjadi setelah objek dihapus dari memori, objek yang baru dibuat berikutnya dialokasikan pada posisi yang sama di memori. Ini diilustrasikan oleh contoh ini

>>> squares = []
>>> for x in range(5):
..     squares.append(lambda n=x: n**2)

Kedua id milik objek bilangan bulat berbeda yang dibuat sebelumnya, dan dihapus segera setelah eksekusi panggilan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Operator

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

>>> print(x)
11

>>> print(x)
11

Properti paling penting dari tes identitas adalah bahwa objek selalu identik dengan dirinya sendiri,

>>> print(x)
11

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> x = 10
>>> def foobar():
..     global x
..     print(x)
..     x += 1
...
>>> foobar()
10

>>> print(x)
11

Namun, tes identitas hanya dapat diganti dengan tes kesetaraan ketika identitas objek terjamin. Secara umum, ada tiga keadaan di mana identitas dijamin

1) Tugas membuat nama baru tetapi tidak mengubah identitas objek. Setelah penugasan

>>> print(x)
11

>>> print(x)
11

2) Memasukkan objek ke dalam wadah yang menyimpan referensi objek tidak mengubah identitas objek. Setelah penugasan daftar

>>> print(x)
11

>>> print(x)
11

3) Jika suatu objek adalah singleton, itu berarti hanya ada satu instance dari objek itu. Setelah penugasan

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Dalam sebagian besar keadaan lain, tes identitas tidak disarankan dan tes kesetaraan lebih disukai. Khususnya, uji identitas tidak boleh digunakan untuk memeriksa konstanta seperti dan yang tidak dijamin sebagai lajang

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Demikian pula, instance baru dari wadah yang dapat berubah tidak pernah identik

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Dalam kode pustaka standar, Anda akan melihat beberapa pola umum untuk menggunakan pengujian identitas dengan benar

1) Seperti yang direkomendasikan oleh PEP 8, tes identitas adalah cara yang lebih disukai untuk memeriksa

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

2) Mendeteksi argumen opsional bisa jadi rumit ketika

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

3) Implementasi wadah kadang-kadang perlu menambah tes kesetaraan dengan tes identitas. Ini mencegah kode menjadi bingung oleh objek seperti

>>> print(x)
11

Sebagai contoh, inilah penerapan

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Saat mensubklasifikasikan tipe yang tidak dapat diubah, timpa metode alih-alih metode. Yang terakhir hanya berjalan setelah instance dibuat, yang sudah terlambat untuk mengubah data dalam instance yang tidak dapat diubah

Semua kelas yang tidak dapat diubah ini memiliki tanda tangan yang berbeda dari kelas induknya

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Kelas dapat digunakan seperti ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Dua alat utama untuk metode caching adalah dan. Yang pertama menyimpan hasil di tingkat instance dan yang terakhir di tingkat kelas

Pendekatan cached_property hanya berfungsi dengan metode yang tidak menggunakan argumen apa pun. Itu tidak membuat referensi ke instance. Hasil metode yang di-cache hanya akan disimpan selama instance masih hidup

Keuntungannya adalah ketika sebuah instance tidak lagi digunakan, hasil metode yang di-cache akan segera dirilis. Kerugiannya adalah jika instans terakumulasi, metode yang terakumulasi juga akan dihasilkan. Mereka bisa tumbuh tanpa terikat

Pendekatan lru_cache bekerja dengan metode yang memiliki argumen hashable. Itu membuat referensi ke instance kecuali upaya khusus dilakukan untuk meneruskan referensi yang lemah

Keuntungan dari algoritme yang paling jarang digunakan adalah bahwa cache dibatasi oleh ukuran maksimum yang ditentukan. Kerugiannya adalah instans tetap hidup sampai mereka menua dari cache atau sampai cache dibersihkan

Contoh ini menunjukkan berbagai teknik

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Contoh di atas mengasumsikan bahwa station_id tidak pernah berubah. Jika atribut instance yang relevan dapat diubah, pendekatan cached_property tidak dapat berfungsi karena tidak dapat mendeteksi perubahan pada atribut

Agar pendekatan lru_cache berfungsi ketika station_id dapat diubah, kelas perlu menentukan metode and sehingga cache dapat mendeteksi pembaruan atribut yang relevan

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Saat modul diimpor untuk pertama kali (atau saat file sumber telah berubah sejak file kompilasi saat ini dibuat) file

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Salah satu alasan mengapa file

>>> print(x)
11

>>> print(x)
11

Kecuali jika variabel lingkungan disetel, pembuatan a. pyc otomatis jika Anda mengimpor modul dan Python memiliki kemampuan (izin, ruang kosong, dll...) untuk membuat subdirektori

>>> print(x)
11

Menjalankan Python pada skrip tingkat atas tidak dianggap sebagai impor dan tidak ada

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Jika Anda perlu membuat file

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Modul dapat mengkompilasi modul apa pun secara manual. Salah satu caranya adalah dengan menggunakan fungsi

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Ini akan menulis

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

Anda juga dapat secara otomatis mengkompilasi semua file dalam direktori atau direktori menggunakan modul. Anda dapat melakukannya dari prompt shell dengan menjalankan

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Sebuah modul dapat mengetahui nama modulnya sendiri dengan melihat variabel global yang telah ditentukan sebelumnya

>>> print(x)
11

>>> print(x)
11

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Misalkan Anda memiliki modul berikut

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

>>> print(x)
11

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Masalahnya adalah juru bahasa akan melakukan langkah-langkah berikut

• impor utama

  >>> print(x)
  11
  

  _65

• Global kosong untuk

  >>> print(x)
  11
  

  _65 telah dibuat

• >>> print(x)
  11
  

  65 dikompilasi dan mulai dijalankan

• >>> print(x)
  11
  

  65 impor

  >>> print(x)
  11
  

  95

• Global kosong untuk

  >>> print(x)
  11
  

  _95 telah dibuat

• >>> print(x)
  11
  

  95 dikompilasi dan mulai dijalankan

• >>> print(x)
  11
  

  95 mengimpor

  >>> print(x)
  11
  

  65 (yang merupakan no-op karena sudah ada modul bernama

  >>> print(x)
  11
  

  65)

• Mekanisme impor mencoba membaca

  >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  _01 dari

  >>> print(x)
  11
  

  65 global, untuk mengatur

  >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  03

Langkah terakhir gagal, karena Python belum selesai menafsirkan

>>> print(x)
11

>>> print(x)
11

Hal yang sama terjadi ketika Anda menggunakan

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Ada (setidaknya) tiga kemungkinan solusi untuk masalah ini

Guido van Rossum merekomendasikan untuk menghindari semua penggunaan

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

>>> def foo():
..    x = 10
..    def bar():
..        nonlocal x
..        print(x)
..        x += 1
..    bar()
..    print(x)
...
>>> foo()
10
11

Jim Roskind menyarankan melakukan langkah-langkah dalam urutan berikut di setiap modul

• ekspor (global, fungsi, dan kelas yang tidak memerlukan kelas dasar yang diimpor)

• >>> def foo():
  ..    x = 10
  ..    def bar():
  ..        nonlocal x
  ..        print(x)
  ..        x += 1
  ..    bar()
  ..    print(x)
  ...
  >>> foo()
  10
  11
  

  _10 pernyataan

• kode aktif (termasuk global yang diinisialisasi dari nilai yang diimpor)

Van Rossum tidak terlalu menyukai pendekatan ini karena impor muncul di tempat yang aneh, tetapi berhasil

Matthias Urlichs merekomendasikan restrukturisasi kode Anda sehingga impor rekursif tidak diperlukan sejak awal

Solusi ini tidak saling eksklusif

Pertimbangkan untuk menggunakan fungsi kenyamanan dari sebagai gantinya

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Untuk alasan efisiensi dan juga konsistensi, Python hanya membaca file modul saat pertama kali modul diimpor. Jika tidak, dalam program yang terdiri dari banyak modul di mana masing-masing mengimpor modul dasar yang sama, modul dasar akan diurai dan diurai berkali-kali. Untuk memaksa membaca ulang modul yang diubah, lakukan ini

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

Peringatan. teknik ini tidak 100% anti-bodoh. Secara khusus, modul yang berisi pernyataan seperti

>>> x = 10
>>> def foo():
..     print(x)
..     x += 1

akan terus bekerja dengan versi lama dari objek yang diimpor. Jika modul berisi definisi kelas, instance kelas yang ada tidak akan diperbarui untuk menggunakan definisi kelas yang baru. Hal ini dapat mengakibatkan perilaku paradoks berikut

Bagaimana Anda mengubah variabel dalam satu lingkaran dengan Python?

Bisakah Anda mengubah variabel di while loop Python?

Bisakah saya memodifikasi variabel loop?

Apa yang dilakukan += dalam perulangan for?