Saya bingung tentang tipe yang tidak bisa diubah. Saya tahu floatobjek tersebut dianggap tidak dapat diubah, dengan jenis contoh ini dari buku saya:

class RoundFloat(float):
    def __new__(cls, val):
        return float.__new__(cls, round(val, 2))

Apakah ini dianggap tidak dapat diubah karena struktur kelas / hierarki ?, makna floatada di bagian atas kelas dan merupakan pemanggilan metodenya sendiri. Mirip dengan jenis contoh ini (meskipun buku saya mengatakan dictbisa berubah):

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

Sedangkan sesuatu yang bisa berubah memiliki metode di dalam kelas, dengan jenis contoh ini:

class SortedKeyDict_a(dict):
    def example(self):
        return self.keys()

Juga, untuk yang terakhir class(SortedKeyDict_a), jika saya meneruskan jenis set ini ke sana:

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

tanpa memanggil examplemetode, itu mengembalikan kamus. The SortedKeyDictdengan __new__bendera itu sebagai kesalahan. Saya mencoba meneruskan bilangan bulat ke RoundFloatkelas __new__dan ditandai tidak ada kesalahan.

Apa? Mengapung tidak berubah? Tapi aku tidak bisa

x = 5.0
x += 7.0
print x # 12.0

Bukankah itu "mut" x?

Yah Anda setuju string tidak bisa diubah kan? Tetapi Anda dapat melakukan hal yang sama.

s = 'foo'
s += 'bar'
print s # foobar

Nilai variabel berubah, tetapi berubah dengan mengubah apa yang dimaksud variabel. Jenis yang bisa berubah bisa berubah seperti itu, dan itu juga bisa berubah "di tempat".

Inilah perbedaannya.

x = something # immutable type
print x
func(x)
print x # prints the same thing

x = something # mutable type
print x
func(x)
print x # might print something different

x = something # immutable type
y = x
print x
# some statement that operates on y
print x # prints the same thing

x = something # mutable type
y = x
print x
# some statement that operates on y
print x # might print something different

Contoh nyata

x = 'foo'
y = x
print x # foo
y += 'bar'
print x # foo

x = [1, 2, 3]
y = x
print x # [1, 2, 3]
y += [3, 2, 1]
print x # [1, 2, 3, 3, 2, 1]

def func(val):
    val += 'bar'

x = 'foo'
print x # foo
func(x)
print x # foo

def func(val):
    val += [3, 2, 1]

x = [1, 2, 3]
print x # [1, 2, 3]
func(x)
print x # [1, 2, 3, 3, 2, 1]

Anda harus memahami bahwa Python mewakili semua datanya sebagai objek. Beberapa objek seperti daftar dan kamus dapat berubah, artinya Anda dapat mengubah kontennya tanpa mengubah identitasnya. Objek lain seperti integer, float, string dan tuple adalah objek yang tidak dapat diubah. Cara mudah untuk memahami itu adalah jika Anda telah melihat ID objek.

Di bawah ini Anda melihat string yang tidak dapat diubah. Anda tidak dapat mengubah kontennya. Ini akan memunculkan TypeErrorjika Anda mencoba mengubahnya. Juga, jika kami menetapkan konten baru, objek baru dibuat alih-alih konten yang dimodifikasi.

>>> s = "abc"
>>>id(s)
4702124
>>> s[0] 
'a'
>>> s[0] = "o"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = "xyz"
>>>id(s)
4800100
>>> s += "uvw"
>>>id(s)
4800500

Anda dapat melakukannya dengan daftar dan itu tidak akan mengubah identitas objek

>>> i = [1,2,3]
>>>id(i)
2146718700
>>> i[0] 
1
>>> i[0] = 7
>>> id(i)
2146718700

Untuk membaca lebih lanjut tentang model data Python, Anda bisa melihat referensi bahasa Python:

• Model data Python 2
• Python 3 datamodel

Jenis abadi yang umum:

1. nomor: int(), float(),complex()
2. urutan berubah: str(), tuple(), frozenset(),bytes()

Jenis yang bisa berubah-ubah (hampir semuanya):

1. urutan bisa berubah: list(),bytearray()
2. jenis yang ditetapkan: set()
3. jenis pemetaan: dict()
4. kelas, instance kelas
5. dll.

Salah satu trik untuk dengan cepat menguji apakah suatu tipe bisa berubah atau tidak, adalah dengan menggunakan id()fungsi bawaan.

Contohnya, menggunakan pada integer,

>>> i = 1
>>> id(i)
***704
>>> i += 1
>>> i
2
>>> id(i)
***736 (different from ***704)

menggunakan daftar,

>>> a = [1]
>>> id(a)
***416
>>> a.append(2)
>>> a
[1, 2]
>>> id(a)
***416 (same with the above id)

Pertama-tama, apakah suatu kelas memiliki metode atau apa struktur kelasnya tidak ada hubungannya dengan mutabilitas.

ints dan floats tidak berubah . Jika aku melakukan

a = 1
a += 5

Itu menunjuk nama adi suatu 1tempat di memori di baris pertama. Pada baris kedua, terlihat up yang 1, menambahkan 5, mendapat 6, maka poin apada saat itu 6dalam memori - itu tidak mengubah yang 1ke 6cara apapun. Logika yang sama berlaku untuk contoh-contoh berikut, menggunakan tipe tidak berubah lainnya :

b = 'some string'
b += 'some other string'
c = ('some', 'tuple')
c += ('some', 'other', 'tuple')

Untuk tipe yang bisa berubah , saya dapat melakukan hal yang secara aktual mengubah nilai penyimpanannya . Dengan:

d = [1, 2, 3]

Saya telah membuat daftar lokasi 1, 2dan 3di memori. Jika saya melakukannya

e = d

Saya hanya menunjuk eke poin yang samalist d di. Saya kemudian dapat melakukan:

e += [4, 5]

Dan daftar yang menunjuk edan dakan diperbarui juga memiliki lokasi 4dan 5dalam memori.

Jika saya kembali ke tipe yang tidak dapat diubah dan melakukannya dengan tuple:

f = (1, 2, 3)
g = f
g += (4, 5)

Maka fmasih hanya menunjuk ke aslinyatuple - Anda telah menunjuk gpada yang sama sekali barutuple .

Sekarang, dengan contoh Anda

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

Di mana Anda lulus

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

(yang merupakan tupledari tuples) sebagai val, Anda mendapatkan kesalahan karena tuples tidak memiliki .clear()metode - Anda harus lulus dict(d)sebagai valuntuk itu untuk bekerja, dalam hal ini Anda akan mendapatkan kosong SortedKeyDictsebagai hasilnya.

Jika Anda datang ke Python dari bahasa lain (kecuali bahasa yang sangat mirip Python, seperti Ruby), dan bersikeras memahaminya dalam hal bahasa lain, di sinilah orang biasanya bingung:

>>> a = 1
>>> a = 2 # I thought int was immutable, but I just changed it?!

Dalam Python, tugas bukanlah mutasi dalam Python.

Di C ++, jika Anda menulis a = 2, Anda menelepon a.operator=(2), yang akan mengubah objek yang disimpan a. (Dan jika ada itu tidak ada objek yang disimpan dalam a, itu kesalahan.)

Dalam Python, a = 2tidak melakukan apa pun untuk apa pun yang disimpan di a; itu hanya berarti bahwa 2sekarang disimpan asebagai gantinya. (Dan jika ada yang tidak ada objek yang disimpan dalam a, itu bagus.)

Pada akhirnya, ini adalah bagian dari perbedaan yang bahkan lebih dalam.

Variabel dalam bahasa seperti C ++ adalah lokasi yang diketik dalam memori. Jika aadalah int, itu berarti 4 byte di suatu tempat yang diketahui oleh kompiler seharusnya ditafsirkan sebagai int. Jadi, ketika Anda melakukannya a = 2, itu mengubah apa yang disimpan dalam 4 byte memori itu dari 0, 0, 0, 1menjadi 0, 0, 0, 2. Jika ada variabel int lain di tempat lain, ia memiliki 4 byte sendiri.

Variabel dalam bahasa seperti Python adalah nama untuk objek yang memiliki kehidupan sendiri. Ada objek untuk nomor tersebut 1, dan objek lain untuk nomor tersebut 2. Dan abukan 4 byte memori yang direpresentasikan sebagai int, itu hanya nama yang menunjuk 1objek. Tidak masuk akal untuk a = 2mengubah angka 1 menjadi angka 2 (yang akan memberi programmer Python cara terlalu banyak kekuatan untuk mengubah cara kerja fundamental alam semesta); apa yang dilakukan sebagai gantinya adalah hanya membuat amelupakan 1objek dan menunjuk 2objek sebagai gantinya.

Jadi, jika tugas bukan mutasi, apa itu mutasi?

• Memanggil metode yang didokumentasikan untuk bermutasi, seperti a.append(b). (Perhatikan bahwa metode ini hampir selalu kembali None). Tipe yang tidak berubah tidak memiliki metode seperti itu, tipe yang bisa berubah biasanya.
• Menetapkan ke bagian objek, seperti a.spam = batau a[0] = b. Tipe yang tidak dapat diubah tidak memungkinkan penugasan ke atribut atau elemen, tipe yang dapat berubah biasanya memungkinkan satu atau yang lain.
• Terkadang menggunakan penugasan augmented, seperti a += b, terkadang tidak. Jenis yang dapat berubah biasanya memutasi nilai; tipe yang tidak dapat diubah tidak pernah melakukannya, dan sebaliknya memberikan Anda salinan (mereka menghitung a + b, kemudian menetapkan hasilnya a).

Tetapi jika penugasan bukan mutasi, bagaimana penugasan ke bagian dari mutasi objek? Di situlah rumit. a[0] = btidak tidak bermutasi a[0](sekali lagi, tidak seperti C ++), tetapi tidak bermutasi a(tidak seperti C ++, kecuali secara tidak langsung).

Semua ini adalah alasan mengapa mungkin lebih baik untuk tidak mencoba menempatkan semantik Python dalam hal bahasa yang biasa Anda gunakan, dan sebaliknya belajar semantik Python dengan istilah mereka sendiri.

Apakah suatu objek bisa berubah atau tidak tergantung pada tipenya. Ini tidak tergantung pada apakah ia memiliki metode tertentu atau tidak, pada struktur hierarki kelas.

Jenis yang ditentukan pengguna (yaitu kelas) umumnya bisa berubah. Ada beberapa pengecualian, seperti sub-kelas sederhana dari tipe yang tidak dapat diubah. Jenis kekal lainnya termasuk beberapa built-in jenis seperti int, float, tupledanstr , serta beberapa kelas Python diimplementasikan dalam C.

Penjelasan umum dari bab "Model Data" dalam Referensi Bahasa Python " :

Nilai beberapa objek dapat berubah. Objek yang nilainya dapat berubah dikatakan bisa berubah; objek yang nilainya tidak dapat diubah begitu mereka dibuat disebut tidak berubah.

(Nilai objek kontainer tidak berubah yang berisi referensi ke objek bisa berubah dapat berubah ketika nilai terakhir berubah; namun wadah masih dianggap tidak berubah, karena koleksi objek yang dikandungnya tidak dapat diubah. Jadi, ketidakmampuan tidak sepenuhnya ketat sama seperti memiliki nilai yang tidak dapat diubah, itu lebih halus.)

Mutabilitas suatu objek ditentukan oleh tipenya; misalnya, angka, string, dan tupel tidak berubah, sedangkan kamus dan daftar bisa berubah.

Perbedaan antara benda yang dapat Berubah dan yang Tidak Berubah

Definisi

Objek bisa berubah : Obyek yang dapat diubah setelah menciptakan itu.
Objek abadi : Obyek yang tidak dapat diubah setelah menciptakan itu.

Dalam python jika Anda mengubah nilai objek yang tidak dapat diubah itu akan membuat objek baru.

Objek yang Dapat Diubah

Berikut adalah objek dalam Python yang bertipe bisa berubah:

1. list
2. Dictionary
3. Set
4. bytearray
5. user defined classes

Objek yang Tidak Berubah

Berikut adalah objek dalam Python yang bertipe tidak berubah:

1. int
2. float
3. decimal
4. complex
5. bool
6. string
7. tuple
8. range
9. frozenset
10. bytes

Beberapa Pertanyaan Tidak Terjawab

Pertanyaan : Apakah string merupakan tipe yang tidak dapat diubah?
Jawab : ya , tapi bisakah Anda menjelaskan ini: Bukti 1 :

a = "Hello"
a +=" World"
print a

Keluaran

"Hello World"

Dalam contoh di atas string yang pernah dibuat sebagai "Hello" kemudian berubah menjadi "Hello World". Ini menyiratkan bahwa string adalah tipe yang bisa berubah. Tapi itu bukan ketika kita memeriksa identitasnya untuk melihat apakah itu jenis yang bisa berubah atau tidak.

a = "Hello"
identity_a = id(a)
a += " World"
new_identity_a = id(a)
if identity_a != new_identity_a:
    print "String is Immutable"

Keluaran

String is Immutable

Bukti 2 :

a = "Hello World"
a[0] = "M"

Keluaran

TypeError 'str' object does not support item assignment

Pertanyaan : Apakah Tuple adalah tipe yang tidak berubah?
Jawab : ya , benar. Bukti 1 :

tuple_a = (1,)
tuple_a[0] = (2,)
print a

Keluaran

'tuple' object does not support item assignment

Objek yang dapat berubah harus memiliki setidaknya metode yang dapat mengubah objek. Misalnya, listobjek memiliki appendmetode, yang akan benar-benar bermutasi objek:

>>> a = [1,2,3]
>>> a.append('hello') # `a` has mutated but is still the same object
>>> a
[1, 2, 3, 'hello']

tetapi kelas floattidak memiliki metode untuk bermutasi objek float. Anda dapat melakukan:

>>> b = 5.0 
>>> b = b + 0.1
>>> b
5.1

tetapi =operan bukan metode. Itu hanya membuat ikatan antara variabel dan apa pun di sebelah kanan itu, tidak ada yang lain. Itu tidak pernah mengubah atau membuat objek. Ini adalah pernyataan tentang apa yang akan ditunjukkan oleh variabel, sejak sekarang.

Ketika Anda melakukan b = b + 0.1itu =operan mengikat variabel untuk float baru, yang secara dibuat dengan te hasil 5 + 0.1.

Ketika Anda menetapkan variabel ke objek yang ada, bisa berubah atau tidak, =operan mengikat variabel ke objek itu. Dan tidak ada lagi yang terjadi

Dalam kedua kasus, =hanya membuat ikatan. Itu tidak mengubah atau membuat objek.

Ketika Anda melakukannya a = 1.0, =operan tidak menciptakan float, tetapi 1.0bagian dari garis. Sebenarnya ketika Anda menulis 1.0itu adalah singkatan untuk float(1.0)panggilan konstruktor mengembalikan objek float. (Itulah alasan mengapa jika Anda mengetik 1.0dan menekan enter Anda mendapatkan "gema" yang 1.0dicetak di bawah ini; itu adalah nilai pengembalian fungsi konstruktor yang Anda panggil)

Sekarang, jika badalah pelampung dan Anda menetapkan a = b, kedua variabel yang menunjuk ke objek yang sama, namun sebenarnya variabel tidak bisa comunicate betweem sendiri, karena benda tersebut inmutable, dan jika Anda melakukannya b += 1, sekarang barahkan ke objek baru, dan aadalah masih menunjuk ke yang lama dan tidak bisa tahu apa byang menunjuk.

tetapi jika c, katakanlah, a list, dan Anda tetapkan a = c, sekarang adan cdapat "berkomunikasi", karena listbisa berubah, dan jika Anda melakukannya c.append('msg'), maka cukup memeriksa aAnda mendapatkan pesan.

(Omong-omong, setiap objek memiliki nomor id unik yang dikaitkan, yang dapat Anda peroleh id(x). Jadi, Anda dapat memeriksa apakah suatu objek sama atau tidak memeriksa apakah id uniknya telah berubah.)

Sebuah kelas berubah jika setiap objek dari kelas yang memiliki nilai tetap pada Instansiasi yang tidak dapat kemudian diubah

Dengan kata lain ubah seluruh nilai variabel itu (name)atau biarkan saja.

Contoh:

my_string = "Hello world" 
my_string[0] = "h"
print my_string 

Anda mengharapkan ini berfungsi dan mencetak hello world tetapi ini akan menimbulkan kesalahan berikut:

Traceback (most recent call last):
File "test.py", line 4, in <module>
my_string[0] = "h"
TypeError: 'str' object does not support item assignment

Penerjemah mengatakan: saya tidak dapat mengubah karakter pertama dari string ini

Anda harus mengubah keseluruhan stringuntuk membuatnya bekerja:

my_string = "Hello World" 
my_string = "hello world"
print my_string #hello world

periksa tabel ini:

sumber

Tampaknya bagi saya bahwa Anda bertengkar dengan pertanyaan apa yang sebenarnya bisa berubah / tidak berubah . Jadi, inilah penjelasan sederhana:

Pertama-tama kita membutuhkan landasan untuk mendasarkan eksplorasi.

Jadi pikirkan apa pun yang Anda program sebagai objek virtual, sesuatu yang disimpan dalam memori komputer sebagai urutan angka biner. (Namun, jangan mencoba membayangkan ini terlalu keras. ^^) Sekarang di sebagian besar bahasa komputer Anda tidak akan bekerja dengan angka-angka biner ini secara langsung, tetapi lebih Anda menggunakan interpretasi angka-angka biner.

Misalnya Anda tidak berpikir tentang angka seperti 0x110, 0xaf0278297319 atau serupa, tetapi Anda berpikir tentang angka seperti 6 atau String seperti "Halo, dunia". Tidak pernah kurang angka-angka tesis atau String adalah interpretasi dari angka biner dalam memori komputer. Hal yang sama berlaku untuk nilai variabel apa pun.

Singkatnya: Kami tidak memprogram dengan nilai aktual tetapi dengan interpretasi dari nilai biner aktual.

Sekarang kita memiliki interpretasi yang tidak boleh diubah demi logika dan "hal-hal rapi" lainnya sementara ada interpretasi yang mungkin dapat diubah. Misalnya pikirkan simulasi kota, dengan kata lain program di mana ada banyak objek virtual dan beberapa di antaranya adalah rumah. Sekarang mungkinkah benda-benda virtual ini (rumah-rumah) diubah dan masihkah mereka dapat dianggap sebagai rumah yang sama? Ya tentu saja mereka bisa. Dengan demikian mereka bisa berubah: Mereka dapat diubah tanpa menjadi objek yang "sepenuhnya" berbeda.

Sekarang pikirkan bilangan bulat: Ini juga adalah objek virtual (urutan angka biner dalam memori komputer). Jadi jika kita mengubah salah satunya, seperti menambah nilai enam per satu, apakah masih enam? Ya tentu saja tidak. Jadi bilangan bulat apa pun tidak dapat berubah.

Jadi: Jika ada perubahan pada objek virtual berarti bahwa itu benar-benar menjadi objek virtual lain, maka itu disebut abadi.

Komentar akhir:

(1) Jangan pernah mencampurkan pengalaman dunia nyata Anda yang bisa berubah dan tidak berubah dengan pemrograman dalam bahasa tertentu:

Setiap bahasa pemrograman memiliki definisi sendiri di mana objek dapat dimatikan dan yang tidak.

Jadi sementara Anda sekarang dapat memahami perbedaan makna, Anda masih harus mempelajari implementasi aktual untuk setiap bahasa pemrograman. ... Memang mungkin ada tujuan dari bahasa di mana angka 6 dapat diredam untuk menjadi angka 7. Kemudian lagi ini akan menjadi hal yang cukup gila atau menarik, seperti simulasi alam semesta paralel. ^^

(2) Penjelasan ini tentu saja tidak ilmiah, ini dimaksudkan untuk membantu Anda memahami perbedaan antara bisa berubah dan tidak berubah.

Tujuan dari jawaban ini adalah untuk menciptakan satu tempat untuk menemukan semua ide bagus tentang bagaimana cara mengetahui apakah Anda berurusan dengan mutasi / nonmutasi (tidak berubah / tidak bisa berubah), dan jika mungkin, apa yang harus dilakukan? Ada saat-saat ketika mutasi tidak diinginkan dan perilaku python dalam hal ini bisa terasa kontra-intuitif untuk coders yang datang dari bahasa lain.

Per posting yang bermanfaat oleh @ mina-gabriel:

• Buku untuk dibaca yang mungkin membantu: " Struktur Data dan Algoritma dengan Python "
• Kutipan dari buku itu yang berisi daftar tipe yang bisa berubah / tidak dapat diubah: gambar yang dapat diubah / tidak bisa ditiru

Menganalisis di atas dan menggabungkan dengan posting oleh @ arrakëën:

Apa yang tidak bisa berubah secara tak terduga?

• skalar (tipe variabel yang menyimpan nilai tunggal) tidak berubah secara tak terduga
  • contoh numerik: int (), float (), complex ()
• ada beberapa "urutan yang bisa berubah-ubah":
  • str (), tuple (), frozenset (), bytes ()

Apa yang bisa?

• daftar seperti objek (daftar, kamus, set, bytearray ())
• sebuah posting di sini juga mengatakan kelas dan instance kelas tetapi ini mungkin tergantung pada apa yang diwarisi dari kelas dan / atau bagaimana dibangunnya.

oleh "tiba-tiba" Maksud saya programmer dari bahasa lain mungkin tidak mengharapkan perilaku ini (dengan pengecualian atau Ruby, dan mungkin beberapa bahasa "Python like" lainnya).

Menambah diskusi ini:

Perilaku ini merupakan keuntungan ketika mencegah Anda secara tidak sengaja mengisi kode Anda dengan banyak salinan struktur data besar yang memakan memori. Tetapi ketika ini tidak diinginkan, bagaimana kita mengatasinya?

Dengan daftar, solusi sederhana adalah membangun yang baru seperti ini:

list2 = daftar (list1)

dengan struktur lain ... solusinya bisa lebih sulit. Salah satu caranya adalah dengan loop melalui elemen dan menambahkannya ke struktur data kosong baru (dari tipe yang sama).

fungsi dapat bermutasi yang asli ketika Anda lulus dalam struktur yang bisa berubah. Bagaimana cara mengatakannya?

• Ada beberapa tes yang diberikan pada komentar lain di utas ini tetapi kemudian ada komentar yang menunjukkan tes ini bukan bukti lengkap
• object.function () adalah metode dari objek asli tetapi hanya beberapa di antaranya bermutasi. Jika mereka tidak mengembalikan apa pun, mereka mungkin melakukannya. Orang akan mengharapkan. Append () untuk bermutasi tanpa mengujinya diberi namanya. .union () mengembalikan penyatuan set1.union (set2) dan tidak bermutasi. Jika ragu, fungsi tersebut dapat diperiksa untuk nilai kembali. Jika return = None, itu tidak bermutasi.
• diurutkan () mungkin merupakan solusi dalam beberapa kasus. Karena mengembalikan versi asli yang diurutkan, ini dapat memungkinkan Anda untuk menyimpan salinan yang tidak bermutasi sebelum Anda mulai mengerjakan yang asli dengan cara lain. Namun, opsi ini mengasumsikan Anda tidak peduli dengan urutan elemen asli (jika ya, Anda perlu mencari cara lain). Sebaliknya .sort () bermutasi asli (seperti yang mungkin diharapkan).

Pendekatan Non-standar (dalam hal membantu): Menemukan ini di github yang diterbitkan di bawah lisensi MIT:

• repositori github di bawah: tobgu bernama: pyrsistent
• Apa itu: Python kode struktur data persisten ditulis untuk digunakan sebagai pengganti struktur data inti ketika mutasi tidak diinginkan

Untuk kelas khusus, @semicolon menyarankan untuk memeriksa apakah ada __hash__fungsi karena objek yang bisa berubah biasanya tidak memiliki__hash__() fungsi.

Ini semua yang telah saya kumpulkan tentang topik ini untuk saat ini. Ide lain, koreksi, dll. Dipersilakan. Terima kasih.

Salah satu cara berpikir tentang perbedaan:

Penugasan ke objek yang tidak dapat diubah dalam python dapat dianggap sebagai salinan yang dalam, sedangkan penugasan ke objek yang tidak dapat diubah adalah dangkal

Jawaban paling sederhana:

Variabel yang dapat berubah adalah variabel yang nilainya dapat berubah pada tempatnya, sedangkan dalam variabel yang tidak berubah, perubahan nilai tidak akan terjadi pada tempatnya. Mengubah variabel yang tidak dapat diubah akan membangun kembali variabel yang sama.

Contoh:

>>>x = 5

Akan membuat nilai 5 direferensikan oleh x

x -> 5

>>>y = x

Pernyataan ini akan membuat Anda merujuk ke 5 x

x -------------> 5 <----------- y

>>>x = x + y

Seperti x menjadi bilangan bulat (tipe tidak berubah) telah dibangun kembali.

Dalam pernyataan itu, ekspresi pada RHS akan menghasilkan nilai 10 dan ketika ini ditugaskan ke LHS (x), x akan dibangun kembali menjadi 10. Jadi sekarang

x ---------> 10

y ---------> 5

Saya belum membaca semua jawaban, tetapi jawaban yang dipilih tidak benar dan saya pikir penulis memiliki gagasan bahwa dapat menetapkan ulang suatu variabel berarti bahwa apa pun jenis data yang bisa berubah. Bukan itu masalahnya. Mutabilitas berkaitan dengan melewati dengan referensi daripada melewati dengan nilai.

Katakanlah Anda membuat Daftar

a = [1,2]

Jika Anda mengatakan:

b = a
b[1] = 3

Meskipun Anda menetapkan ulang nilai pada B, itu juga akan menetapkan kembali nilai pada a. Itu karena ketika Anda menetapkan "b = a". Anda memberikan "Referensi" ke objek daripada salinan nilainya. Ini bukan kasus dengan string, float dll. Ini membuat daftar, kamus dan sejenisnya bisa berubah, tetapi booleans, floats dll tidak berubah.

Untuk objek yang tidak berubah, tugas membuat salinan nilai baru, misalnya.

x=7
y=x
print(x,y)
x=10 # so for immutable objects this creates a new copy so that it doesnot 
#effect the value of y
print(x,y)

Untuk objek yang bisa diubah, tugas tidak membuat salinan nilai lain. Sebagai contoh,

x=[1,2,3,4]
print(x)
y=x #for immutable objects assignment doesn't create new copy 
x[2]=5
print(x,y) # both x&y holds the same list

Dengan Python, ada cara mudah untuk mengetahui:

Kekal:

    >>> s='asd'
    >>> s is 'asd'
    True
    >>> s=None
    >>> s is None
    True
    >>> s=123
    >>> s is 123
    True

Yg mungkin berubah:

>>> s={}
>>> s is {}
False
>>> {} is {}
Flase
>>> s=[1,2]
>>> s is [1,2]
False
>>> s=(1,2)
>>> s is (1,2)
False

Dan:

>>> s=abs
>>> s is abs
True

Jadi saya pikir fungsi bawaan juga tidak berubah dalam Python.

Tapi saya benar-benar tidak mengerti cara kerja float:

>>> s=12.3
>>> s is 12.3
False
>>> 12.3 is 12.3
True
>>> s == 12.3
True
>>> id(12.3)
140241478380112
>>> id(s)
140241478380256
>>> s=12.3
>>> id(s)
140241478380112
>>> id(12.3)
140241478380256
>>> id(12.3)
140241478380256

Ini sangat aneh.