Eine Erklärung veränderlicher Objekte und unveränderlicher Objekte in Python

Der folgende Editor bietet Ihnen eine kurze Diskussion über veränderliche Objekte und unveränderliche Objekte in Python. Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Folgen wir dem Editor und werfen wir einen Blick auf

Was ist ein veränderliches/unveränderliches Objekt?

Unveränderliches Objekt, die Erinnerung, auf die das Objekt zeigt Der Wert in kann nicht geändert werden. Wenn eine -Variable geändert wird, entspricht dies dem Kopieren und anschließenden Ändern des ursprünglichen Werts, da der Wert, auf den sie sich bezieht, nicht geändert werden kann. Dadurch wird eine neue Adresse geöffnet und die Variable zeigt auf diese neue eine. Adresse.

Veränderbares Objekt, der Wert im Speicher, auf den das Objekt zeigt, kann geändert werden. Nachdem die Variable (um genau zu sein: bezieht sich auf ) geändert wurde, wird der Wert, auf den sie sich bezieht, tatsächlich direkt geändert, und es wird keine neue ausgehende Adresse geöffnet an Ort und Stelle.

In Python sind numerischer Typ (int und float), stringstr und tuple tuple allesamt unveränderliche Typen. Listen, Wörterbücher und Mengen sind Variablentypen.

Es ist intuitiver, den Code zu betrachten. Schauen wir uns zunächst Beispiele für unveränderliche Objekte an

Unveränderliche Objekte

Erklären wir zunächst eines: Es geht darum, die IDs zweier Objekte zu bestimmen gleich sind und = = Es wird beurteilt, ob die Inhalte gleich sind.

a = 2
b = 2
c = a + 0 
c += 0

print(id(a), id(b), id(2)) # id都相同
print(c is b) #True

Schauen wir uns die Zeichenfolge

astr = 'good'
bstr = 'good'
cstr = astr + ''
print(cstr is bstr) # True
print(id(astr), id(bstr), id('good')) # 三个id相同

an, die das gleiche Ergebnis wie der numerische Typ hat . Wenn die folgende Situation auftritt, ist die Variable nach der Änderung nicht mehr gültig

astr = 'good'
print(id(astr))
astr += 'aa'
print(id(astr)) # id和上面的不一样

Da es sich um ein unveränderliches Objekt handelt, beträgt der Wert des Speichers, der der Variablen entspricht darf nicht geändert werden. Wenn eine Variable geändert werden soll, wird der ursprüngliche Wert tatsächlich kopiert und dann geändert, eine neue Adresse wird geöffnet und Astr zeigt auf diese neue Adresse (daher ist die ID des vorherigen und des vorherigen Astr unterschiedlich). Der ursprüngliche Astr ist anders, denn wenn ein anderes Objekt darauf zeigt, wird es durch Müll gesammelt. Dies gilt auch für die Typen int und float.

Schauen Sie sich das Tupel an

add = (1, 2, 3)
aee = (1, 2, 3)
print(id(add), id(aee), id((1, 2, 3))) # id各不相同

aee = (1, 2, 3)
print(id(aee))
aee += () # 加空元组
print(id(aee)) # id变了！
print(aee) #（1 ，2，3）

Obwohl es den Anschein hat, dass sie alle (1,2,3) sind, sollte es mit dem oben Gesagten übereinstimmen . Ist das ein veränderliches Objekt? Schauen Sie noch einmal

add = (1, 2, 3)
aee = add 
print(id(aee), id(add)) # 这两个id一样
aee += (4, 5, 6)
print(id(aee)) # aee的id变了！
print(add) # add还是(1, 2, 3)没有变

stimmt mit dem numerischen Typ und dem str-Typ überein. Wenn es sich um ein Variablenobjekt add = aee handelt, ist es sicher, dass sie auf dieselbe Adresse (dieselbe ID) verweisen. Dabei handelt es sich jedoch nicht um unterschiedliche Verweise auf dasselbe Objekt, denn wenn dies der Fall ist, führen Änderungen in aee zu Änderungen in add, was in tuple nicht der Fall ist. Tuple ist also ein unveränderliches Objekt, unterscheidet sich jedoch geringfügig von den Typen str und numeric. Die Unveränderlichkeit von Tupeln bedeutet normalerweise, dass die in ihnen gespeicherten Werte nicht geändert werden können (in einigen Sonderfällen, z. B. bei einer in einem Tupel gespeicherten Liste, können die Elemente in der Liste geändert werden. Tatsächlich wurde das Tupel jedoch nicht geändert geändert).

Für str, int und float sind ihre IDs gleich, solange sie denselben Typ und denselben Wert haben. (Warum sagen Sie, dass sie vom gleichen Typ sind?)

a = 2.0
b = 2
print(a is b) # False, 一个int一个float，类型都不同

2 und 2.0 sind nicht an derselben Adresse.

Beispiele für veränderliche Objekte

 lis = [1, 2, 3]
lis2 = [1, 2, 3]
# 虽然它们的内容一样，但是它们指向的是不同的内存地址
print(lis is lis2)
print(id(lis), id(lis2), id([1, 2, 3])) # 三个id都不同

Aufgabe anschauen

alist = [1, 2, 3]
# alist实际上是对对象的引用，blist = alist即引用的传递，现在两个引用都指向了同一个对象（地址）
blist = alist
print(id(alist), id(blist)) # id一样
# 所以其中一个变化，会影响到另外一个
blist.append(4)
print(alist) # 改变blist, alist也变成了[1 ,2 ,3 4]
print(id(alist), id(blist)) # id一样，和上面值没有改变时候的id也一样

blist = alist. alist ist eigentlich eine Referenz auf das Objekt, blist = alist ist die Übertragung der Referenz, und jetzt verweisen beide Referenzen auf dasselbe Objekt (Adresse). Eine der Änderungen wirkt sich also auf die andere aus

und schauen Sie sich die Menge an

abb = {1, 2, 3}
acc = abb
print(id(abb), id(acc))
acc.add(4)
print(abb) # {1, 2, 3, 4} 
print(id(abb), id(acc)) # 相等

, die mit dem Beispiel der obigen Liste übereinstimmt.

Da das gezeigte Objekt eines variablen Objekts geändert werden kann, ist es nicht erforderlich, eine Kopie zu erstellen und es dann direkt zu ändern, sodass kein neuer Speicher geöffnet wird und die ID nicht geändert werden kann bleibt vor und nach der Änderung unverändert.

Natürlich ist dies bei unveränderlichen Objekten nicht der Fall. Sie können es damit vergleichen

abc = 3
dd = abc
dd = 43
print(abc) # 3，并不随dd的改变而改变

Aber wenn es eine Kopie ist kopiert nur den Inhalt, was übergeben wird, wird nicht zitiert. Dies ist besonders nützlich, wenn Sie die Werte einer Liste verwenden möchten, ohne die ursprüngliche Liste zu ändern.

blist = alist[:] # or alist.copy()
print(alist is blist) # False
blist.append(4)
print(alist) # 还是[1，2 ，3]没有变化

als Funktionsparameter

als Funktionsparameter, dasselbe, Variable Typ Was übergeben wird, ist eine Referenz, und unveränderliche Typen sind übergebener Inhalt.

test_list = [1, 2, 3, 4]
test_str = 'HAHA'


def change(alist):
  alist.append(5)


def not_change(astr):
  astr.lower()


change(test_list)
not_change(test_str)
print(test_list) # 改变了原来的值
print(test_str) # 没有变

Wenn Sie den Wert der ursprünglichen Liste nicht ändern möchten, können die Parameter natürlich in einer Kopie der Spaltenvariablen übergeben werden. alsit[:]

Interessantes Beispiel

Wenn wir uns ein weiteres interessantes Beispiel ansehen, wissen wir, dass eine Liste mit + zu einer Liste hinzugefügt werden kann.

a1 = [1, 2, 3]
a2 = a1
print(id(a1), id(a2))
# 实际上是a2指向了新的对象，id已经改变。
# 所以现在a2、a1并不是同一对象的两个引用了，a2变化a1不会改变
a2 = a2 + [4] # 这个等式中，右边的a2还是和a1的id一样的，一旦赋值成功，a2就指向新的对象
print(id(1), id(a2)) # 不等，a2的id变化了
print(a1) # [1, 2, 3]没有变

Wenn es so geschrieben wird

a1 = [1, 2, 3]
a2 = a1
print(id(a1), id(a2))
a2 += [4] # 相当于调用了a2.extend([4]),原地改变并没有新的对象产生
print(id(1), id(a2)) # 相等，a2的id没有变化
print(a1)

Die Differenz ist a2 += [4 ] , dieser Satz entspricht dem Aufruf von a2.extend([4]), was einem Ortswechsel entspricht, und es werden keine neuen Objekte generiert.

Das obige ist der detaillierte Inhalt vonEine Erklärung veränderlicher Objekte und unveränderlicher Objekte in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!