source

Python 문자열을 복사하려면 어떻게 해야 합니까?

ittop 2023. 10. 19. 22:45
반응형

Python 문자열을 복사하려면 어떻게 해야 합니까?

나는 이렇게 합니다.

a = 'hello'

그리고 이제 나는 단지 독자적인 사본을 원합니다.a:

import copy

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

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

출력[3]:

[4365576160, 4365576160, 4365576160, 4365576160, 4365576160]

왜 그들은 모두 같은 메모리 주소를 가지고 있고 어떻게 복사본을 얻을 수 있습니까?a?

파이썬 문자열을 복사할 필요는 없습니다.그들은 불변이고, 그리고.copy모듈은 이러한 경우에 항상 원본을 반환합니다.str(), 전체 문자열 조각과 빈 문자열을 연결할 수 있습니다.

게다가 당신의'hello'string이 interned입니다(certain 문자열은 interned).파이썬은 의도적으로 한 부만 보관하려고 하는데, 이것은 사전 검색을 더 빠르게 하기 때문입니다.

이 문제를 해결할 수 있는 한 가지 방법은 실제로 새 문자열을 만든 다음 해당 문자열을 원래 내용으로 다시 잘라내는 것입니다.

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

하지만 지금 당신이 하고 있는 것은 기억력 낭비뿐입니다.결국 이러한 문자열 개체를 어떤 식으로든 변형시킬 수 있는 것은 아닙니다.

Python 개체에 필요한 메모리 양만 알고 싶다면 Python 개체의 메모리 사용량을 알려줍니다.

컨테이너의 경우 내용물은 포함되지 않으며, 총 메모리 크기를 계산하려면 각 컨테이너로 다시 이동해야 합니다.

>>> 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

그런 다음 사용을 선택할 수 있습니다.id()추적을 통해 실제 메모리 사용량을 측정하거나 개체를 캐시하고 재사용하지 않은 경우 최대 사용량을 추정할 수 있습니다.

지금 막 끈 조작을 시작했는데 이 질문을 발견했습니다.저는 아마 OP 같은 것을 하려고 했을 겁니다. "usual me".이전의 답변들은 혼란을 해소하지 못했지만, 조금 고민한 끝에 마침내 "알았다".

하는 한은a,b,c,d,그리고.e같은 값을 갖습니다. 그들은 같은 장소를 가리킵니다.메모리가 저장됩니다.변수가 서로 다른 값을 갖기 시작하면 변수는 서로 다른 참조를 갖기 시작합니다.저의 학습 경험은 다음 코드에서 비롯되었습니다.

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

출력된 출력은 다음과 같습니다.

[4538504992, 4538504992, 4538504992, 4538504992, 4538504992]

hello hello hello hello hello

[6113502048, 4538504992, 4538504992, 4538504992, 5570935808]

goodbye hello hello hello hello something

문자열 포맷을 통해 python의 문자열을 복사할 수 있습니다.

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

"id()"를 다르게 표현하는 것은 당신이 신경 쓸 일이 아닙니다.원본 변수 이름을 손상시키지 않고 변수 이름을 수정할 수 있는지 알고자 합니다.

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

C에 익숙하다면, 이 변수들은 포인터 변수와 같습니다. 다만 포인터 변수가 가리키는 부분을 수정하기 위해 참조를 해제할 수는 없지만 id()가 현재 가리키는 위치를 알려줄 것입니다.

파이썬 프로그래머의 문제는 목록이나 딕트와 같은 더 심층적인 구조를 고려할 때 발생합니다.

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

여기서 o와 x는 동일한 dict['a']와 x['a']를 가리키며, 이 dict는 키 'a'의 값을 변경할 수 있다는 의미에서 "mutable"입니다.그렇기 때문에 "y"는 복사이고 y[a]는 다른 것을 나타낼 수 있습니다.

다음과 같은 간단한 방법으로 가능합니다.

a = "Python"
b = a[ : : -1 ][ : : -1 ]
print( "a =" , a )
print( "b =" , b )
a == b  # True
id( a ) == id( b ) # False

다른 사람들이 이미 설명한 것처럼 실제로 필요한 경우는 거의 없지만, 그럼에도 불구하고 여기 있습니다.
(Python 3에서도 작동하지만, Python 2에도 비슷한 것이 있을 것입니다.)

import ctypes

copy          = ctypes.pythonapi._PyUnicode_Copy
copy.argtypes = [ctypes.py_object]
copy.restype  = ctypes.py_object

s1 = 'xxxxxxxxxxxxx'
s2 = copy(s1)

id(s1) == id(s2) # False

문자열 복사는 두 가지 방법으로 a = "a" b = a 위치를 복사하거나 a가 변경되었을 때 b가 영향을 받지 않도록 복제할 수 있습니다. a = 'a' b = a[:]

제가 방금 스트링 슬라이싱으로 해결한 것 같아요.

a="words"
b=a[:int(len(a)/2)]+a[int(len(a)/2):]
b
'words'
id(a),id(b)
(1492873997808, 1492902431216)

언급URL : https://stackoverflow.com/questions/24804453/how-can-i-copy-a-python-string

반응형