it-swarm.com.de

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 sie alle dieselbe Speicheradresse und wie bekomme ich eine Kopie von a?

58
usual me

Sie brauchen nicht brauchen, um eine Python-Zeichenfolge zu kopieren. Sie sind unveränderlich und das copy-Modul gibt in solchen Fällen immer das Original zurück, wie str(), den gesamten String-Slice und das Verketten mit einem leeren String.

Darüber hinaus ist Ihre 'hello'-Zeichenfolge interned ( 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, tatsächlich eine neue Zeichenfolge zu erstellen und sie dann wieder in den ursprünglichen Inhalt zu schneiden:

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

Aber alles, was Sie jetzt tun, ist Verschwendung von Speicher. Es ist nicht so, als könnten Sie diese String-Objekte auf irgendeine Weise mutieren.

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

Bei Containern enthält not den Inhalt nicht. Sie müssten in jeden Container rekursieren, um die 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 id() tracking verwenden, um einen tatsächlichen Speicherbedarf zu ermitteln oder den maximalen Platzbedarf zu schätzen, wenn Objekte nicht zwischengespeichert und wiederverwendet wurden.

106
Martijn Pieters

Sie können einen String in Python per String-Formatierung kopieren: 

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

Ich fange gerade mit einigen String-Manipulationen an und habe diese Frage gefunden. Ich habe wahrscheinlich versucht, so etwas wie das OP zu machen. 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 e denselben Wert haben, beziehen sie sich auf dieselbe Stelle. Speicher wird gespeichert. Sobald die Variablen unterschiedliche Werte haben, erhalten sie unterschiedliche Referenzen. Meine Lernerfahrung stammt 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
5
karl s

Das Kopieren eines Strings kann auf zwei Arten erfolgen: entweder kopieren Sie die Position a = "a" b = a oder Sie können klonen, was bedeutet, dass b nicht beeinflusst wird, wenn a geändert wird. Dies geschieht durch a = 'a' b = a [:]

0
Thomas Y

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 dies Zeigervariablen, mit der Ausnahme, dass Sie sie nicht abwählen können, um den Punkt zu ändern, auf den sie zeigen, aber id () sagt Ihnen, wo sie gerade zeigen.

Das Problem für Python-Programmierer besteht, 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 "veränderlich" in dem Sinne, dass Sie den Wert für Schlüssel 'a' ändern können. Deshalb muss "y" eine Kopie sein und y ['a'] kann auf etwas anderes verweisen.

0
Charles Thayer