옵션 또는 복제본에 며칠입니까 클론할 목록에 파이썬?
'수정', '모든' 변화 '를 사용하는 동안 new_list = my_list new_list my_list' everytime. 그 이유는 무엇입니까?
실제로 복사합니다를 나열하십시오 다양한 가능성이 있습니다.
new_list = old_list.copy ()
new_list = old_list [.]
[# 39 의 알렉스랑 Martelli&] [1] 의견 (최소한 [지난 2007년] [2]) 에 있는 것은 이 이상한 판매업체에서 이를 사용하여 구문 및 것은 앞뒤가 맞지 않는다. ) (다음 하나는 자신의 의견을 더 잘).
new_list = 목록 (old_list)
가져오기의 복제본에 new_list = 코피스코프 (old_list)
이는 '조금' 목록 () 의 데이터 형식을 가지고 있기 때문에 보다 느린 알아보기 위해 'old_list' 이번이 처음이다.
가져오기의 복제본에 new_list = 코피.딥코프 (old_list)
이 방법은 당연히 필요하지만 때로는 최저속 및 대부분의 메모리를 필요로 합니다. 불가피할 전망이다.
import copy
class Foo(object):
def __init__(self, val):
self.val = val
def __repr__(self):
return str(self.val)
foo = Foo(1)
a = ['foo', foo]
b = a.copy()
c = a[:]
d = list(a)
e = copy.copy(a)
f = copy.deepcopy(a)
# edit orignal list and instance
a.append('baz')
foo.val = 5
print('original: %r\n list.copy(): %r\n slice: %r\n list(): %r\n copy: %r\n deepcopy: %r'
% (a, b, c, d, e, f))
결과:.
original: ['foo', 5, 'baz']
list.copy(): ['foo', 5]
slice: ['foo', 5]
list(): ['foo', 5]
copy: ['foo', 5]
deepcopy: ['foo', 1]
[1]: https://en.wikipedia.org/wiki/Alex_Martelli " 알렉스랑 Martelli"; [2]: https://www.youtube.com/watch? v = g7v89k8qfgq " 파이썬 interest group), 8월 2007년 meeting" bay area. [3]: https://docs.python.org/2/library/functions.html # " 나열하십시오 list"; [4]: https://docs.python.org/2/library/copy.html # 코피스코프 " copy.copy"; [5]: https://docs.python.org/2/library/copy.html # 코피.딥코프 " copy.deepcopy";
하지만 이미 제공된 펠릭스 훌륭한 오토메이티드 생각해봤죠 I&; d # 39 는 속도 비교 할 수 있는 다양한 방법:
1.10.59 초 (105.9us/itn) - ['코피.딥코프 (old_list)'] (http://docs.python.org/library/copy.html # 코피.딥코프) 2.10.16 - 순수 파이썬 복사 (copy) '와' 초 (101.6us/itn) 방법을 클래스뿐만 딥코프 복사 3 초 (14.88us/itn) - 순수 파이썬 '아닌' 복제본에 1.488. () 메서드를 클래스뿐만 복사 (전용 딕토스 / / 튜플을 열거합니다) 0.325 의 초 (3.25us/itn) - '항목에 대한 old_list. 4. new_list.append (item) ' 5. [i i 의 old_list] '-' 초 (2.17us/itn) 0.217 (a [목록 번역] (http://docs.python.org/tutorial/datastructures.html # 지능형 목록)) 6. (0.186 초 (1.86us/itn) - ['코피스코프 (old_list)'] http://docs.python.org/library/copy.html # 코피스코프) 0.075 목록 (old_list) '-' 초 (0.75us/itn) 7. 8 초 (0.53us/itn) - '= [], new_list 0.053. new_list.extend (old_list) ' [.] '-' old_list 0.039 초 (0.39us/itn) 9. ([목록 슬라이싱] (http://docs.python.org/tutorial/introduction.html # 열거합니다))
그래서 가장 빠른 나열하십시오 슬라이싱 있다. 그러나 점을 유념하십시오 코피스코프 목록 ' ()', '목록 (list)', ' [.]' 와 ' ()' 와 파이썬 버전을 don& 코피.딥코프 달리 모든 목록에서 # 39, t, 사전 및 클래스용 인스턴스들도 복제본에 열거합니다 오리지널스 바꼈소, 만일 그들이 불지윽으로 변화가 너무 복사됨 목록, 그 반대의 경우도 마찬가지입니다.
(Here& # 39 의 경우 # 39 에 관심을 높이기 위해 모든 것을 스크립트입니다 anyone& 또는 문제)
from copy import deepcopy
class old_class:
def __init__(self):
self.blah = 'blah'
class new_class(object):
def __init__(self):
self.blah = 'blah'
dignore = {str: None, unicode: None, int: None, type(None): None}
def Copy(obj, use_deepcopy=True):
t = type(obj)
if t in (list, tuple):
if t == tuple:
# Convert to a list if a tuple to
# allow assigning to when copying
is_tuple = True
obj = list(obj)
else:
# Otherwise just do a quick slice copy
obj = obj[:]
is_tuple = False
# Copy each item recursively
for x in xrange(len(obj)):
if type(obj[x]) in dignore:
continue
obj[x] = Copy(obj[x], use_deepcopy)
if is_tuple:
# Convert back into a tuple again
obj = tuple(obj)
elif t == dict:
# Use the fast shallow dict copy() method and copy any
# values which aren't immutable (like lists, dicts etc)
obj = obj.copy()
for k in obj:
if type(obj[k]) in dignore:
continue
obj[k] = Copy(obj[k], use_deepcopy)
elif t in dignore:
# Numeric or string/unicode?
# It's immutable, so ignore it!
pass
elif use_deepcopy:
obj = deepcopy(obj)
return obj
if __name__ == '__main__':
import copy
from time import time
num_times = 100000
L = [None, 'blah', 1, 543.4532,
['foo'], ('bar',), {'blah': 'blah'},
old_class(), new_class()]
t = time()
for i in xrange(num_times):
Copy(L)
print 'Custom Copy:', time()-t
t = time()
for i in xrange(num_times):
Copy(L, use_deepcopy=False)
print 'Custom Copy Only Copying Lists/Tuples/Dicts (no classes):', time()-t
t = time()
for i in xrange(num_times):
copy.copy(L)
print 'copy.copy:', time()-t
t = time()
for i in xrange(num_times):
copy.deepcopy(L)
print 'copy.deepcopy:', time()-t
t = time()
for i in xrange(num_times):
L[:]
print 'list slicing [:]:', time()-t
t = time()
for i in xrange(num_times):
list(L)
print 'list(L):', time()-t
t = time()
for i in xrange(num_times):
[i for i in L]
print 'list expression(L):', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(L)
print 'list extend:', time()-t
t = time()
for i in xrange(num_times):
a = []
for y in L:
a.append(y)
print 'list append:', time()-t
t = time()
for i in xrange(num_times):
a = []
a.extend(i for i in L)
print 'generator expression extend:', time()-t
>. # 며칠입니까 클론할 목록에 옵션 또는 복제본에 파이썬?
Python 에서 3, 얕은 복제본에 함께 만들 수 있습니다.
a_copy = a_list.copy()
파이썬 2 와 3 에서 얻을 수 있으며, 전체 슬라이스에 함께 얕은 복제본에, 원래:
a_copy = a_list[:]
두 가지 방법을 의미 복제본에 바뀌엇어요. 얕은 복제본에 tcpg 같은 새로운 목록을 객체에 깊이형 복제본에 새로운 목록을 만들 수 있는 새로운 avamer 객체에는.
얕은 복제본에 목록에 있는 객체에 대한 참조가 복제본만 자체를 컨테이너입니다 목록에 있습니다. 스스로 변경 가능 및 원-부트 변경될 경우 v2.03-00 객체에는 열거합니다 변경 모두 반영됩니다.
파이썬 2 와 3 이 작업을 수행할 수 있는 여러 가지입니다. 또한 파이썬 작업하십시오 파이썬 2 가지 방법 3.
이 성어는 길이 2 의 파이썬, 얕은 복제본입니다 목록은 완전한 슬라이스에 함께 하며, 원래:
a_copy = a_list[:]
똑같은 수행할 수도 있습니다, 목록에 의해 반군지역 통해 구성자를 목록
a_copy = list(a_list)
그러나 name. domain. 구성자를 덜 효율적인:
>>> timeit
>>> l = range(20)
>>> min(timeit.repeat(lambda: l[:]))
0.30504298210144043
>>> min(timeit.repeat(lambda: list(l)))
0.40698814392089844
Python 에서 3 ',' 리스트리코프 내려받습니다 열거합니다 방법:
a_copy = a_list.copy()
Python 에서 3.5:
>>> import timeit
>>> l = list(range(20))
>>> min(timeit.repeat(lambda: l[:]))
0.38448613602668047
>>> min(timeit.repeat(lambda: list(l)))
0.6309100328944623
>>> min(timeit.repeat(lambda: l.copy()))
0.38122922903858125
>. New_list 사용하여 그 때마다 = my_list 수정되므로 new_list my_list 변경. 그 이유는 가능
'그냥' 는 실제 목록에 이름을 my_list 가리키는 메모리. When you say ',' = my_list new_list you& you& # 39, re, re 않고 있어 복제본에 # 39 는 기존 목록에 추가 메모리를 가리키는 또 다른 이름이 바로 알 수 있다. 우리는 우리가 할 때 복제본입니다 비슷한 문제가 있을 수 있습니다.
>>> l = [[], [], []]
>>> l_copy = l[:]
>>> l_copy
[[], [], []]
>>> l_copy[0].append('foo')
>>> l_copy
[['foo'], [], []]
>>> l
[['foo'], [], []]
이 목록은 그냥 배열입니다 내용을 가리키는 포인터, 그래서 당신은 얕은 복제본에 복사됩니다 때문에 그냥 서로 다른 두 개의 동일한 내용을 갖고 있지만 열거합니다 있다. 복제본입니다 콘텐츠를 만들기 위해 필요한 깊은 복제본입니다.
만들기 위해 깊이형 복제본입니다 목록 중 ',' 를 사용하여 딥코프 파이썬 2 또는 3 '' 모듈에서는 복제본에:
import copy
a_deep_copy = copy.deepcopy(a_list)
이를 어떻게 보여줄 수 있게 만들기 하위 목록:
>>> import copy
>>> l
[['foo'], [], []]
>>> l_deep_copy = copy.deepcopy(l)
>>> l_deep_copy[0].pop()
'foo'
>>> l_deep_copy
[[], [], []]
>>> l
[['foo'], [], []]
그래서 우리가 지켜보리니 작업자쪽에서 깊이형 복사됨 목록은 완전히 다른 목록의 원본. 단, t # 39 don& 자신의 기능을 선보일 수 있습니다. # 39, re 만들 가능성이 있습니다 # 39, 그렇지 않으면 wouldn& you& 버그 없는 # 39 의 기능을 사용하여 표준 library& 딥코프.
problematic_deep_copy = eval(repr(a_list))
파이썬 2.7 의 64 비트.
>>> import timeit
>>> import copy
>>> l = range(10)
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
27.55826997756958
>>> min(timeit.repeat(lambda: eval(repr(l))))
29.04534101486206
64 비트 Python 의 3.5:
>>> import timeit
>>> import copy
>>> l = list(range(10))
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
16.84255409205798
>>> min(timeit.repeat(lambda: eval(repr(l))))
34.813894678023644
이미 여러 가지가 있지만, 그들 중 아무도 대답을 제대로 파악할 수 있는 방법, 기존 & # 39 라고 복제본에 왜 copy& # 39. 못했습니다.
각 요소에 바뀌엇어요 이름, 그 각 요소를 바인딩됩니다 충족되었으며 객체에는 비 독점적 역할을 합니다. 그 이전과 같은 객체에는 바인딩하지 요소이면 얕은 복제본에 새로운 목록을 만듭니다.
new_list = list(my_list) # or my_list[:], but I prefer this syntax
# is simply a shorter way of:
new_list = [element for element in my_list]
한 걸음 더 나아가, 목록에 있는 각 객체에는 복제본에 나열하십시오 복제본에 경험하십시오 수 있으며, 이러한 요소점 복제본에 바인딩해야 () 은 새 목록.
import copy
# each element must have __copy__ defined for this...
new_list = [copy.copy(element) for element in my_list]
이 때문에 아직 깊은 복제본에 각 요소에 바뀌엇어요 마찬가지로 이 목록은 해당 요소를 바인딩되고 다른 객체 () 는 다음과 같은 뜻이 있다. 모든 요소가 재귀적으로 복제본에 목록에서 각 요소를 참조하는 다른 객체까지 다음 각각의, 등드으로: 수행하는 깊이형 복제본입니다.
import copy
# each element must have __deepcopy__ defined for this...
new_list = copy.deepcopy(my_list)
문서 지켜보리니 모퉁이점 건에 대한 자세한 정보는 복사.
다음은 타이밍 사용하여 결과를 파이썬 3.6.8. 이 시기에 기준은 절대 아닌 채널이어야 염두에 두어야 합니다.
내가 할 수 있도록 하고, 또한 몇 가지 새로운 메서드입니다 weren& # 39 만 t, 얕은 복제본에 추가되든지 Python2 리스트리코프 같은 수 있는 ' ()' (이하 Python3 슬라이스에 avamer) 과 두 가지 형태의 목록 꺼내기 (' new_list new_list = [ 목록]', '와' = list):
METHOD TIME TAKEN
b = [*a] 2.75180600000021
b = a * 1 3.50215399999990
b = a[:] 3.78278899999986 # Python2 winner (see above)
b = a.copy() 4.20556500000020 # Python3 "slice equivalent" (see above)
b = []; b.extend(a) 4.68069800000012
b = a[0:len(a)] 6.84498999999959
*b, = a 7.54031799999984
b = list(a) 7.75815899999997
b = [i for i in a] 18.4886440000000
b = copy.copy(a) 18.8254879999999
b = []
for item in a:
b.append(item) 35.4729199999997
하지만 승자는 Python2 doesn& # 39 가 여전히 잘 볼 수 있습니다. () '별로' t 면쪽 아웃해야 Python3 리스트리코프 고려하면 뛰어난 가독성을 후자의.
The dark horse) 는 압축 풀기 재포장 및 방법 ('b = [ a]') ~ 25%, 이는 보다 두 배 이상 빨리 꺼내기 기초형상 슬라이싱, 그리고 다른 방법 (= a b ',').
'a * b = 1' 도 의외로 잘 않습니다.
다음은 테스트 코드를 관련 당사자들이 (템플리트를 여기에서):
import timeit
COUNT = 50000000
print("Array duplicating. Tests run", COUNT, "times")
setup = 'a = [0,1,2,3,4,5,6,7,8,9]; import copy'
print("b = list(a)\t\t", timeit.timeit(stmt='b = list(a)', setup=setup, number=COUNT))
print("b = copy.copy(a)\t", timeit.timeit(stmt='b = copy.copy(a)', setup=setup, number=COUNT))
print("b = a.copy()\t\t", timeit.timeit(stmt='b = a.copy()', setup=setup, number=COUNT))
print("b = a[:]\t\t", timeit.timeit(stmt='b = a[:]', setup=setup, number=COUNT))
print("b = a[0:len(a)]\t\t", timeit.timeit(stmt='b = a[0:len(a)]', setup=setup, number=COUNT))
print("*b, = a\t\t\t", timeit.timeit(stmt='*b, = a', setup=setup, number=COUNT))
print("b = []; b.extend(a)\t", timeit.timeit(stmt='b = []; b.extend(a)', setup=setup, number=COUNT))
print("b = []; for item in a: b.append(item)\t", timeit.timeit(stmt='b = []\nfor item in a: b.append(item)', setup=setup, number=COUNT))
print("b = [i for i in a]\t", timeit.timeit(stmt='b = [i for i in a]', setup=setup, number=COUNT))
print("b = [*a]\t\t", timeit.timeit(stmt='b = [*a]', setup=setup, number=COUNT))
print("b = a * 1\t\t", timeit.timeit(stmt='b = a * 1', setup=setup, number=COUNT))
>. # 39 의 let& 처음부터, 익스플로러 it a little 깊이형:
그래서 두 개의 목록 가정합니다.
list_1=['01','98']
list_2=[['01','98']]
그리고 우리는 이제 모두 복제본에 나열하십시오 시작으로 첫 번째 목록:
그래서 let& # 39 의 첫 번째 방법은 장군에 의해 시도하시겠습니까 복제본에:
copy=list_1
그런 다음, 이 경우 지금 생각하고 있다 # 39 의 복제본에 복사됨 list_1 잘못됐다 let& 살펴보자.
>. 우리 모두 동일한 id () 함수를 fs@snapa com/go/4e6b330a_kr 가리키십시오 list 객체, 즉 이 객체에는 공유한다.
print(id(copy))
print(id(list_1))
출력:
4329485320
4329485320
놀란? # 39 의 양호임 let& 살펴보았으므로 있다.
따라서, 우리가 아는 파이썬 doesn& t 스토어, 참조하는 변수는 그냥 # 39 어떤 변수 값을 저장하는 객체 및 객체에는. 그런데 여기서 객체인지 '목록 참조 두 개가 서로 다른 두 개의 변수 이름을 통해 같은 객체에는 만들었습니다. 따라서 동일한 객체에는 com/go/4e6b330a_kr 주목하고 있다.
실제로 어떤 일을 할 수 있다 '' = list_1 외면하였나니 복제본에.
하지만 두 가지 변수 이름은 이 곳 이미지 및 복제본에 list_1 객체인지 원하는거요 가변적입니다 모두에 대해 '같은' 목록
네가 만일 그런 것이 너무 수정하려고 복사됨 목록 수정 때문에 목록은 하나만 는 원래 목록으로 나열되어 있는데, 너희는 너희가 수정하십시오 아무리 &solarisdvd 복사됨 목록이거나 는 원래 목록:
copy[0]="modify"
print(copy)
print(list_1)
출력:
['modify', '98']
['modify', '98']
따라서 원래 목록으로 수정되었음.
>. 솔루션 그리고는요? >. >. 해결책:
지금 # 39 의 두 번째 파이썬 let& 움직이십시오 복사하는 방법이 목록:
copy_1=list_1[:]
이제 중요한 것은 우리가 이 문제를 해결할 방법을 평면가공 그렇고여 let& # 39 의 첫 번째 살펴보자.
print(id(copy_1))
print(id(list_1))
4338792136
4338791432
그래서 우리 모두 각기 다른 id 와 무슨뜻이냐믄 나열하십시오 보듯 두 변수가 가리키는 다른 객체에는 정말로 그렇다면 여기에:
지금 # 39 의 let& 수정하려고 목록 및 let& # 39 의 있는지 아직 인쇄면 이전 문제:
copy_1[0]="modify"
print(list_1)
print(copy_1)
출력:
['01', '98']
['modify', '98']
그래서 것은 알 수 있듯이 원래 목록의 수정 뿐 아니라, 따라서 우리는 이를 수정한 복사됨 나열하십시오 괜찮습니다.
이제 우리는 완료했습니까? 생쥐라. 그래서 우리는 너무 네스트된 목록 # 39 의 두 번째 진정하라구요 복제본에 let& 파이썬 시도하시겠습니까 운행에서어떠한:
copy_2=list_2[:]
그래서 다른 객체에 대한 참조가 list_2 /dev/raw/raw200 원하는거요 복제본입니다 list_2 let& # 39 의 확인:
print(id((list_2)),id(copy_2))
우리 출력물에는:
4330403592 4330403528
이제 다른 객체에는 let& # 39 의 열거합니다 solaris. 모두 주목하고 있다 이제 수정하려고 let& 정보기술 (it) 과 # 39 의 지켜보리니 우리가 원하는 것은 확증하노라.
하나님이 종료기:
copy_2[0][1]="modify"
print(list_2,copy_2)
이를 통해 미국 출력:
[['01', 'modify']] [['01', 'modify']]
이제 우리는 여전히 명확하지 않아, 파이썬, 이것은 거의 동일한 방법으로 문제를 평면가공 사용했습니다.
외면하였나니 we do.
copy_2=list_2[:]
이 때문에 우리는 실제 복제가 아니라 외부 나열하십시오 네스트된 나열하십시오 네스트된 목록은 모두 동일한 객체에는 let& # 39 의 목록을 확인하십시오.
print(id(copy_2[0]))
print(id(list_2[0]))
출력:
4329485832
4329485832
그래서 [.] "이것이 우리가 실제로 '= list_2 copy_2 때 어떻게 됩니까.
It 는 복제본입니다 단 나열하십시오 아닌 다른 외부 목록.직렬 복제본에 네스트된 목록.직렬 복제본에서 네스트된 목록은 모두 가변으로 그러하매 시도할 경우 네스트된 목록 수정 후 원래 목록으로 수정하십시오 것 때문에 동일한 모두에 대해 너무 네스트된 객체인지 나열하십시오 네스트된 목록.
왜 솔루션이므로?
솔루션이므로 깊이형 복제본에 '는'
from copy import deepcopy
deep=deepcopy(list_2)
이제 let& # 39 의 살펴보자.
print(id((list_2)),id(deep))
출력:
4322146056 4322148040
지금 # 39 의 검사 모두 다르고 let& 네스트된 나열하십시오 id, id:
print(id(deep[0]))
print(id(list_2[0]))
출력:
4322145992
4322145800
모두 볼 수 있듯이 다른 id 가 둘 수 있도록 solaris. 네스트된 나열하십시오 이제 다른 객체에는 설명하고 있다.
너 외면하였나니 딥코프 (list_2) '' 깊이형 = 실제로 어떤 상황이 발생합니다.
그래서 그들은 지금 목록을 네스트된 제프 라이트 복제본에 다른 객체에는 네스트된 나열하십시오 모두 주목하고 있다.
지금 # 39 의 let& 시도하시겠습니까 네스트된 목록 및 let& # 39 의 수정할 수 있는지, 방관하겠나 이전 문제 해결했습니다.
만일 우리가:
deep[0][1]="modify"
print(list_2,deep)
출력:
[['01', '98']] [['01', 'modify']]
그래서 그것을 볼 수 있듯이, t # 39 didn& 수정하십시오 네스트된 목록 뿐 아니라 기존 수정한 복사됨 목록.
자세한 답변 완수에요 제 경우, 이를 통해 업보팅 알려주세요 이 경우, 모든 것에 대한 답을 릴테드 셀명 다운되어도:)
, 답변이 있을 때 사용할 수 있는 모든 다른 투고자 제공했음 멋지구리해요 한 치수 (주장하며) 그러나 목록 () '는 지금까지 언급한 방법은 오직' 코피.딥코프 클론할 바뀌엇어요 '이 아니라' 목록 / 복제본에 할꺼이나 가리키십시오 네스트된 작업할 때 객체에는 다차원, 네스트된 목록 (list of 열거합니다). 펠릭스 클링 는 그 동안 그의 답변은 문제가 있을 수 있고, 조금 더 빠르게 대체할 수 있는 방법을 사용하여 증명할 수 있는 내장 기능 '딥코프'.
[.] ',' 동시에 '& # 39 new_list = old_list 코피스코프 (old_list)' 과 ',' 일하는 단일 주장하며 py3k old_list.copy (), 그들은 '목록' 을 가리키고 열거합니다 되돌려집니다 new_list '및' 와 '내' old_list 네스트된 객체에는 변경되는지 관객이 '목록 중 하나가' 개체는 또 다른.
>. 모두 이용하여 지적한 것과 에런 홀 와 PM 2Ring flexlm용 eval () '가 아니라' 나쁜 아이디어, 또 ' ()' 에서 제공합니다.* 코피.딥코프 훨씬 느리다.
>. 따라서 유일한 옵션은 '다차원 열거합니다 코피.딥코프 ()'. # 39 와 있다는 것, 정말 isn& t an 옵션으로 사용할 수 있는 다차원 중간 크기의 이 때 단순화표현 운행에서어떠한 성능 댁이라면 대한민국 어레이입니다. 심지어 '찾았다' 의 크지 않은 42x42 어레이이며 티마이트 사용하여 애플리케이션을 위한 생물정보학 들리지 않는 포기한 응답을 기다리는 동안, 나는 내 편집하십시오 입력 및 막 시작된 이 포스트.
>. 차라리 진짜 여러 옵션을 초기화하려면 열거합니다 작업하고 있는 유일한 것, 그리고 독립적으로 것입니다. 만약 누군가 다른 제안에 대해 어떻게 처리할 수 있는 다차원 목록*.직렬 복사 될 수 있다고 평가했다.
또 다른 성능 문제를 가지고 있다 '와' 코피.딥코프 좁히어 상당히 많이 사용하여 '대한' 다차원 복제본에 모듈에서는 열거합니다 .
그렇게 말한 적이 있어, t # 39 이 예기치 않은 it hasn& 생각해서라도 아직 완성도.
목록에 있는 압축 풀기, 쥐포가 되는거야 operator", " 수행할 수 있습니다. 또한 '*' 복제본에 목록에 있는 요소를.
old_list = [1, 2, 3]
new_list = [*old_list]
new_list.append(4)
old_list == [1, 2, 3]
new_list == [1, 2, 3, 4]
그러나 분명한 것은 이 방법을 3.5+ 에서만 사용할 수 있다.
하지만, 이 시기 보다 현명한 전능하신분은 진행하십시오 다른 일반적인 방식.
x = [random.random() for _ in range(1000)]
%timeit a = list(x)
%timeit a = x.copy()
%timeit a = x[:]
%timeit a = [*x]
#: 2.47 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
#: 2.47 µs ± 54.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
#: 2.39 µs ± 58.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
#: 2.22 µs ± 43.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
이미 지정된 것은 매우 간단한 외곽진입 독립적으로 파이썬 버전을 사용할 수 있는 대부분의 시간을 missing in 답변 (최소한 나는한다):
new_list = my_list * 1 #Solution 1 when you are not using nested lists
그러나 다른 컨테이너입니다 my_list map_layer 경우 (예: 위에서 제시한 대로 대답을 딥코프 네스트된 열거합니다) 의 다른 라이브러리란 복제본에 사용해야 합니다. 예를 들면 다음과 같습니다.
import copy
new_list = copy.deepcopy(my_list) #Solution 2 when you are using nested lists
new_list = my_list[:]
< hr>;
>>> a = range(5)
>>> b = a*1
>>> a,b
([0, 1, 2, 3, 4], [0, 1, 2, 3, 4])
>>> a[2] = 55
>>> a,b
([0, 1, 55, 3, 4], [0, 1, 2, 3, 4])
>>> from copy import deepcopy
>>> a = [range(i,i+4) for i in range(3)]
>>> a
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> b = a*1
>>> c = deepcopy(a)
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> a[2].append('99')
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]] #Solution#1 didn't work in nested list
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]] #Solution #2 - DeepCopy worked in nested list
단, 몇 가지 경우에 사용자 정의 클래스를 정의한 경우 유지하려는 속성을 콩지름에 코피스코프 () '또는' 다음 ' ()' 가 아니라, 예를 들어 있는 대안을 코피.딥코프 파이썬 3:
import copy
class MyList(list):
pass
lst = MyList([1,2,3])
lst.name = 'custom list'
d = {
'original': lst,
'slicecopy' : lst[:],
'lstcopy' : lst.copy(),
'copycopy': copy.copy(lst),
'deepcopy': copy.deepcopy(lst)
}
for k,v in d.items():
print('lst: {}'.format(k), end=', ')
try:
name = v.name
except AttributeError:
name = 'NA'
print('name: {}'.format(name))
출력:
lst: original, name: custom list
lst: slicecopy, name: NA
lst: lstcopy, name: NA
lst: copycopy, name: custom list
lst: deepcopy, name: custom list
new_list = my_list[:]
new_list my_list '=' 이 점을 이해할 수 있도록 노력하겠다. # 39 의 메모리 위치에 있다고 let& my_list 힙 () 은 x 는 x = my_list '지금' 즉 my_list 가리키는 할당하여 new_list you& # 39, re 하는 new_list 가리키는 것으로 알려진 이 x 얕은 복제본입니다.
[.] ',' 이제 new_list = my_list 할당할 경우 단순히 You& # 39 의 복사 각 객체에는 my_list new_list 수 있을 정도다. 이는 알려진 깊이형 복제본입니다.
다른 방법으로도 할 수 있다.
new_list = 목록 (old_list) '-'
그 후 일부 다른 답을 좀 다른 글 올릴 싶었다. 비록 이날 가장 빠른 속도로, 또는 가장 잘 이해할 수 있는 옵션을 제공한다 않은 것 좀 δ1 보기입니다 복제본에 아니라 또 다른 대체 얼마나 깊은 작동됨 部门是这样的 옵션을 깊이형 복사. 이 모든 경우에, t really doesn& # 39 는 내 함수에 버그, 이후 이 같은 방법을 표시하십시오 요점이지 복제본에 객체에는 뿐만 아니라 이를 사용할 수 있는 방법에 대해 질문 답변 가리키십시오 딥코프 작동됨 storagex 의 핵심.
핵심은 깊이형 복제본에 모든 기능을 사용할 수 있는 방법이 노출됐어 얕은 복제본입니다. 단순해졌습니다. 기능만 컨테이너입니다 불변 객체에 대한 모든 깊이형 복제본에 복제합니다. 때 아닌 외부 열거합니다 미디어만을 복제하는 경우 딥코프 네스트된 목록 내의 변경 가능 객체에는 열거합니다. 틀렸다니까 국한됨 복제하는 컨테이너입니다. 같은 클래스를 사용할 수 없다. 그 때, 당신은 모든 딥코프 딥코프 클래스 변경 가능 합니다. 그래서, 어떻게? 왜 같은,, 국제열핵융합실험로 튜플을 딕토스 열거합니다 복사합니다를 컨테이너입니다 됩니다, 클래스, 클래스 인스턴스?
한 번 없이 완전히 객체가 참조를 복제하는 알잖나 것은 매우 어렵다. # 39 에 대한 기본 데이터 유형 딥코피링 here& 함수 (사용자 정의 클래스를 사용할 수 있는 t # 39, wouldn& 확장하지만 항상 추가)
def deepcopy(x):
immutables = (str, int, bool, float)
mutables = (list, dict, tuple)
if isinstance(x, immutables):
return x
elif isinstance(x, mutables):
if isinstance(x, tuple):
return tuple(deepcopy(list(x)))
elif isinstance(x, list):
return [deepcopy(y) for y in x]
elif isinstance(x, dict):
values = [deepcopy(y) for y in list(x.values())]
keys = list(x.keys())
return dict(zip(keys, values))
이 목록은 말하고 있습니다. [1, 2, 3] . 하지만 다른 레이어에는 불변 숫자임 재현할 수 없는 이 있다. 이 목록을 사용하는 복제본임을 표현할 수 있습니다. [x 를 x 의 [1, 2, 3]
이제 이 목록을 상상할 수 있습니다. [[1, 2], [3, 4], [5, 6]] . 이 때, 함수, 만들려는 사용하는 모든 계층의 명단요 깊은 복제본에 반복 위 목록에 대신 것이다.
[x for x in _list]
It 는 새로운 하나는 목록:
[deepcopy_list(x) for x in _list]
def deepcopy_list(x):
if isinstance(x, (str, bool, float, int)):
return x
else:
return [deepcopy_list(y) for y in x]
그럼 이제 당신은 딥코프 수 있는 모든 함수, 심지어 str 목록니다 부울 프로스트, 정수, 무한히 많은 레이어에는 반복 사용할 수 있습니다. 그리고 거기 할꺼이나, 딥코피링.