Hướng dẫn python fastest way to copy object - python cách nhanh nhất để sao chép đối tượng

Question

Nó thực sự phụ thuộc vào nhu cầu của bạn. deepcopy được xây dựng với ý định làm điều đúng đắn (hầu hết). Nó giữ các tài liệu tham khảo được chia sẻ, nó không tái phát vào các cấu trúc đệ quy vô hạn và cứ thế ... nó có thể làm điều đó bằng cách giữ một từ điển memo trong đó tất cả các "những thứ" được chèn bằng tham chiếu. Đó là những gì làm cho nó khá chậm đối với các bản sao dữ liệu thuần túy. Tuy nhiên, tôi hầu như luôn luôn nói rằng deepcopy là cách pythonic nhất để sao chép dữ liệu ngay cả khi các phương pháp khác có thể nhanh hơn.the most pythonic way to copy data even if other approaches could be faster.

Nội dung chính Show

Tạo một bản sao nhanh của một đối tượng
Vấn đề
Dung dịch
Thảo luận
Làm thế nào để bạn nhân đôi một đối tượng trong Python?
Bản sao sâu có nhanh hơn bản sao nông không?
Làm thế nào để bạn sao chép sâu một đối tượng trong Python?
Bản sao () là nông hay sâu?

Nếu bạn có dữ liệu thuần túy và một số loại hạn chế bên trong nó, bạn có thể xây dựng deepcopy của riêng mình (xây dựng gần như sau khi thực hiện deepcopy trong CPython):

_dispatcher = {}

def _copy_list(l, dispatch):
    ret = l.copy()
    for idx, item in enumerate(ret):
        cp = dispatch.get(type(item))
        if cp is not None:
            ret[idx] = cp(item, dispatch)
    return ret

def _copy_dict(d, dispatch):
    ret = d.copy()
    for key, value in ret.items():
        cp = dispatch.get(type(value))
        if cp is not None:
            ret[key] = cp(value, dispatch)

    return ret

_dispatcher[list] = _copy_list
_dispatcher[dict] = _copy_dict

def deepcopy(sth):
    cp = _dispatcher.get(type(sth))
    if cp is None:
        return sth
    else:
        return cp(sth, _dispatcher)

Điều này chỉ hoạt động chính xác cho tất cả các loại không liên tục bất biến và các trường hợp

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

2 và

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

3. Bạn có thể thêm nhiều người điều phối nếu bạn cần họ.

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Cũng hãy xem nó hoạt động như thế nào khi sao chép một từ điển lớn chứa chuỗi và số nguyên:

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Tạo một bản sao nhanh của một đối tượng

Tín dụng: Alex Martelli

Vấn đề

Bạn cần thực hiện phương pháp đặc biệt

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4 để lớp của bạn có thể hợp tác với chức năng

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

5. Nếu phương thức

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

6 của lớp của bạn chậm, bạn cần phải bỏ qua nó và nhận một đối tượng trống của lớp.

Dung dịch

Ở đây, một giải pháp hoạt động cho cả hai lớp học mới và cổ điển:

def empty_copy(obj):
    class Empty(obj._ _class_ _):
        def _ _init_ _(self): pass
    newcopy = Empty(  )
    newcopy._ _class_ _ = obj._ _class_ _
    return newcopy

Các lớp của bạn có thể sử dụng chức năng này để thực hiện

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4 như sau:

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

Ở đây, một ví dụ sử dụng:

if _ _name_ _ == '_ _main_ _':
    import copy
    y = YourClass(  )    # This, of course, does run _ _init_ _
    print y
    z = copy.copy(y)     # ...but this doesn't
    print z

Thảo luận

Python không hoàn toàn sao chép các đối tượng của bạn khi bạn gán chúng. Đây là một điều tuyệt vời, bởi vì nó cung cấp các ngữ nghĩa nhanh, linh hoạt và thống nhất. Khi bạn cần một bản sao, bạn yêu cầu rõ ràng, lý tưởng nhất với chức năng

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

5, biết cách sao chép các loại tích hợp, có mặc định hợp lý cho các đối tượng của riêng bạn và cho phép bạn tùy chỉnh quy trình sao chép bằng cách xác định phương thức đặc biệt

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4 trong lớp học của riêng bạn. Nếu bạn muốn các trường hợp của một lớp không thể sử dụng được, bạn có thể xác định

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4 và tăng

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

1 ở đó. Trong hầu hết các trường hợp, bạn có thể để ____ cơ chế mặc định ____ 15 hoạt động và bạn có khả năng nhân chính miễn phí cho hầu hết các lớp học của mình. Điều này khá đẹp hơn một chút so với các ngôn ngữ buộc bạn phải thực hiện một phương thức

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

3 cụ thể cho mỗi lớp có các trường hợp bạn muốn được nhân bản.

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4 thường cần bắt đầu với một phiên bản trống của lớp được đề cập (ví dụ:

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

5), bỏ qua

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

6 khi đó là một hoạt động tốn kém. Cách đơn giản nhất để làm điều này là sử dụng khả năng mà Python cung cấp cho bạn để thay đổi một lớp thể hiện trên đường bay bằng cách tạo một đối tượng mới trong một lớp trống cục bộ, sau đó đặt thuộc tính ____27 của nó, như mã công thức lại cho thấy. Lưu ý rằng việc kế thừa

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

8 từ

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

9 là dư thừa (nhưng khá vô hại) đối với các phiên bản Python cũ (lên đến Python 2.1), nhưng trong Python 2.2, nó trở nên cần thiết để tạo chức năng

def empty_copy(obj):
    class Empty(obj._ _class_ _):
        def _ _init_ _(self): pass
    newcopy = Empty(  )
    newcopy._ _class_ _ = obj._ _class_ _
    return newcopy

0 tương thích với tất cả các loại đối tượng của các lớp cổ điển hoặc kiểu mới ( bao gồm các loại tích hợp và mở rộng). Khi bạn chọn kế thừa từ lớp ____ 31 31, bạn phải ghi đè

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

6 trong

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)
# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit copy.deepcopy(data)
# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit json.loads(json.dumps(data))
# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

8, nếu không thì toàn bộ mục đích của công thức bị mất.

Khi bạn có một đối tượng trống của lớp cần thiết, bạn thường cần sao chép một tập hợp con của các thuộc tính ____ 25 25. Nếu bạn cần tất cả các thuộc tính, bạn sẽ không xác định rõ ràng

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

4, vì sao chép tất cả các thuộc tính thể hiện là mặc định ____ 15. Trừ khi, tất nhiên, bạn cần phải làm nhiều hơn một chút so với sao chép các thuộc tính thể hiện. Nếu bạn cần sao chép tất cả các thuộc tính ____ 25 vào

def empty_copy(obj):
    class Empty(obj._ _class_ _):
        def _ _init_ _(self): pass
    newcopy = Empty(  )
    newcopy._ _class_ _ = obj._ _class_ _
    return newcopy

8, thì đây là hai kỹ thuật:

newcopy._ _dict_ _.update(self._ _dict_ _)
newcopy._ _dict_ _ = self._ _dict_ _.copy(  )

Một ví dụ của một lớp kiểu mới không nhất thiết phải giữ tất cả trạng thái của nó trong

def empty_copy(obj):
    class Empty(obj._ _class_ _):
        def _ _init_ _(self): pass
    newcopy = Empty(  )
    newcopy._ _class_ _ = obj._ _class_ _
    return newcopy

9, vì vậy bạn có thể cần phải thực hiện một số sao chép trạng thái cụ thể theo lớp.

Các lựa chọn thay thế dựa trên mô-đun tiêu chuẩn

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

0 có thể được thực hiện trong suốt trên các lớp cổ điển và kiểu mới trong Python 2.2 (ít nhất, tôi đã không thể làm điều này). Bên cạnh đó, mô -đun

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

0 thường được coi là ma thuật đen nguy hiểm (khá phóng đại những nguy hiểm của nó). Dù sao, công thức này cho phép bạn tránh sử dụng mô -đun

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

0 cho mục đích cụ thể này.

Lưu ý rằng cho đến nay chúng ta đã nói về các bản sao nông, đó là những gì bạn muốn hầu hết thời gian. Với một bản sao nông, đối tượng của bạn được sao chép, nhưng các đối tượng mà nó đề cập đến (thuộc tính hoặc mục) không, vì vậy đối tượng được sao chép mới và đối tượng gốc đề cập đến cùng các mục hoặc đối tượng thuộc tính. Một bản sao sâu là một hoạt động hạng nặng, có khả năng nhân đôi một biểu đồ lớn các đối tượng đề cập đến nhau. Bạn nhận được một bản sao sâu bằng cách gọi

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

3 trên một đối tượng. Nếu bạn cần tùy chỉnh cách các phiên bản của lớp của bạn được sao chép sâu, bạn có thể xác định phương pháp đặc biệt

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

4 và tuân theo giao thức ghi nhớ hơi phức tạp của nó. Kỹ thuật thể hiện trong công thức này, việc nhận các bản sao trống của các đối tượng bằng cách bỏ qua các phương thức

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy
import msgpack
import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)
# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit copy.deepcopy(data)
# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit json.loads(json.dumps(data))
# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit msgpack.unpackb(msgpack.packb(data))
# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

6 của chúng, đôi khi vẫn có thể có ích, nhưng có rất nhiều công việc khác bạn cần làm.

Xem thêm

Phần tham chiếu thư viện trên mô -đun

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

6.Library Reference section on the

class YourClass:
    def _ _init_ _(self):
        print "assume there's a lot of work here"
    def _ _copy_ _(self):
        newcopy = empty_copy(self)
        print "now copy some relevant subset of self's attributes to newcopy"
        return newcopy

6 module.

Làm thế nào để bạn nhân đôi một đối tượng trong Python?

Sao chép một đối tượng trong Python trong Python, chúng tôi sử dụng toán tử = Toán tử để tạo một bản sao của một đối tượng.Bạn có thể nghĩ rằng điều này tạo ra một đối tượng mới;nó không.Nó chỉ tạo ra một biến mới chia sẻ tham chiếu của đối tượng gốc.use = operator to create a copy of an object. You may think that this creates a new object; it doesn't. It only creates a new variable that shares the reference of the original object.

Bản sao sâu có nhanh hơn bản sao nông không?

Bản sao nông lưu trữ bản sao của đối tượng gốc và trỏ các tham chiếu đến các đối tượng.Sao chép sâu lưu trữ bản sao của đối tượng gốc và sao chép đệ quy các đối tượng là tốt.Bản sao nông nhanh hơn.Bản sao sâu tương đối chậm hơn.Shallow copy is faster. Deep copy is comparatively slower.

Làm thế nào để bạn sao chép sâu một đối tượng trong Python?

Để tạo một bản sao sâu (hoặc bản sao) của một đối tượng, chúng tôi nhập mô-đun sao chép tích hợp trong Python.Mô -đun này có phương thức DeepCopy () giúp đơn giản hóa nhiệm vụ của chúng tôi.import the built-in copy module in Python. This module has the deepcopy() method which simplifies our task.

Bản sao () là nông hay sâu?

Trong bản sao nông, một bản sao của đối tượng gốc được lưu trữ và chỉ có địa chỉ tham chiếu cuối cùng được sao chép.Trong bản sao sâu, bản sao của đối tượng gốc và các bản sao lặp đi lặp lại đều được lưu trữ.2. ... Bản sao sâu ..

programming python Copy object Python Python copy update Python copy OrderedDict python __copy__