Wie kann ich eine Python-Zeichenfolge kopieren?

Ich mache das:

a = 'hello'

Und jetzt möchte ich nur eine unabhängige Kopie von a:

import copy

b = str(a)
c = a[:]
d = a + ''
e = copy.copy(a)

map( id, [ a,b,c,d,e ] )

Out [3]:

[4365576160, 4365576160, 4365576160, 4365576160, 4365576160]

Warum haben alle dieselbe Speicheradresse und wie kann ich eine Kopie davon erhalten a?

Sie müssen nicht benötigen eine Python - Zeichenfolge zu kopieren. Sie sind unveränderlich, und das copyModul gibt in solchen Fällen immer das Original zurück, ebenso wie str()das gesamte String-Slice und die Verkettung mit einem leeren String.

Darüber hinaus ist Ihre 'hello'Zeichenfolge interniert ( bestimmte Zeichenfolgen sind ). Python versucht absichtlich, nur eine Kopie zu behalten, da dies die Suche nach Wörterbüchern beschleunigt.

Eine Möglichkeit, dies zu umgehen, besteht darin, eine neue Zeichenfolge zu erstellen und diese Zeichenfolge dann wieder auf den ursprünglichen Inhalt zurückzuschneiden:

>>> a = 'hello'
>>> b = (a + '.')[:-1]
>>> id(a), id(b)
(4435312528, 4435312432)

Aber alles, was Sie jetzt tun, ist Speicherverschwendung. Es ist schließlich nicht so, dass Sie diese Zeichenfolgenobjekte auf irgendeine Weise mutieren können.

Wenn Sie nur wissen möchten, wie viel Speicher ein Python-Objekt benötigt, verwenden Sie sys.getsizeof(); Es gibt Ihnen den Speicherbedarf jedes Python-Objekts.

Bei Containern ist der Inhalt nicht enthalten. Sie müssten in jeden Container zurückgreifen, um eine Gesamtspeichergröße zu berechnen:

>>> import sys
>>> a = 'hello'
>>> sys.getsizeof(a)
42
>>> b = {'foo': 'bar'}
>>> sys.getsizeof(b)
280
>>> sys.getsizeof(b) + sum(sys.getsizeof(k) + sys.getsizeof(v) for k, v in b.items())
360

Sie können dann die id()Verfolgung verwenden, um einen tatsächlichen Speicherbedarf zu ermitteln oder einen maximalen Speicherbedarf zu schätzen, wenn Objekte nicht zwischengespeichert und wiederverwendet wurden.

Sie können eine Zeichenfolge in Python über die Zeichenfolgenformatierung kopieren:

>>> a = 'foo'  
>>> b = '%s' % a  
>>> id(a), id(b)  
(140595444686784, 140595444726400)  

Ich fange gerade mit einigen String-Manipulationen an und habe diese Frage gefunden. Ich habe wahrscheinlich versucht, so etwas wie das OP zu machen, "normal ich". Die vorherigen Antworten haben meine Verwirrung nicht geklärt, aber nachdem ich ein wenig darüber nachgedacht hatte, habe ich es endlich "verstanden".

Solange a, b, c, d, und eden gleichen Wert haben , verweisen sie an der gleichen Stelle. Speicher wird gespeichert. Sobald die Variable unterschiedliche Werte aufweist, erhalten sie unterschiedliche Referenzen. Meine Lernerfahrung ergab sich aus diesem Code:

import copy
a = 'hello'
b = str(a)
c = a[:]
d = a + ''
e = copy.copy(a)

print map( id, [ a,b,c,d,e ] )

print a, b, c, d, e

e = a + 'something'
a = 'goodbye'
print map( id, [ a,b,c,d,e ] )
print a, b, c, d, e

Die gedruckte Ausgabe ist:

[4538504992, 4538504992, 4538504992, 4538504992, 4538504992]

hello hello hello hello hello

[6113502048, 4538504992, 4538504992, 4538504992, 5570935808]

goodbye hello hello hello hello something

Das Kopieren einer Zeichenfolge kann auf zwei Arten erfolgen: Kopieren Sie entweder die Position a = "a" b = a oder Sie können klonen, was bedeutet, dass b nicht betroffen ist, wenn a geändert wird, was durch a = 'a' b = a [:] erfolgt.

Anders ausgedrückt: "id ()" ist nicht das, was Sie interessiert. Sie möchten wissen, ob der Variablenname geändert werden kann, ohne den Namen der Quellvariablen zu beschädigen.

>>> a = 'hello'                                                                                                                                                                                                                                                                                        
>>> b = a[:]                                                                                                                                                                                                                                                                                           
>>> c = a                                                                                                                                                                                                                                                                                              
>>> b += ' world'                                                                                                                                                                                                                                                                                      
>>> c += ', bye'                                                                                                                                                                                                                                                                                       
>>> a                                                                                                                                                                                                                                                                                                  
'hello'                                                                                                                                                                                                                                                                                                
>>> b                                                                                                                                                                                                                                                                                                  
'hello world'                                                                                                                                                                                                                                                                                          
>>> c                                                                                                                                                                                                                                                                                                  
'hello, bye'                                                                                                                                                                                                                                                                                           

Wenn Sie an C gewöhnt sind, sind diese wie Zeigervariablen, außer dass Sie sie nicht de-referenzieren können, um zu ändern, worauf sie zeigen, aber id () sagt Ihnen, wohin sie aktuell zeigen.

Das Problem für Python-Programmierer tritt auf, wenn Sie tiefere Strukturen wie Listen oder Diktate betrachten:

>>> o={'a': 10}                                                                                                                                                                                                                                                                                        
>>> x=o                                                                                                                                                                                                                                                                                                
>>> y=o.copy()                                                                                                                                                                                                                                                                                         
>>> x['a'] = 20                                                                                                                                                                                                                                                                                        
>>> y['a'] = 30                                                                                                                                                                                                                                                                                        
>>> o                                                                                                                                                                                                                                                                                                  
{'a': 20}                                                                                                                                                                                                                                                                                              
>>> x                                                                                                                                                                                                                                                                                                  
{'a': 20}                                                                                                                                                                                                                                                                                              
>>> y                                                                                                                                                                                                                                                                                                  
{'a': 30}                                                                                                                                                                                                                                                                                              

Hier beziehen sich o und x auf dasselbe Diktat o ['a'] und x ['a'], und dieses Diktat ist in dem Sinne "veränderlich", dass Sie den Wert für Schlüssel 'a' ändern können. Deshalb muss "y" eine Kopie sein und y ['a'] kann sich auf etwas anderes beziehen.