Làm thế nào để bạn sao chép thay vì tham chiếu trong python?

Question

Câu lệnh gán trong Python không tạo bản sao của đối tượng, chúng chỉ liên kết tên với đối tượng. Đối với các đối tượng bất biến, điều đó thường không tạo ra sự khác biệt

Nội dung chính Show

Tạo bản sao nông
Tạo bản sao sâu
Sao chép các đối tượng Python tùy ý
3 điều cần nhớ
Python có sao chép hoặc tham chiếu không?
Copy() nghĩa là gì trong Python?

Nhưng để làm việc với các đối tượng có thể thay đổi hoặc bộ sưu tập các đối tượng có thể thay đổi, bạn có thể đang tìm cách tạo “bản sao thực” hoặc “bản sao” của các đối tượng này

Về cơ bản, đôi khi bạn sẽ muốn các bản sao mà bạn có thể sửa đổi mà không tự động sửa đổi bản gốc cùng một lúc. Trong bài viết này, tôi sẽ cung cấp cho bạn tóm tắt về cách sao chép hoặc “nhân bản” các đối tượng trong Python 3 và một số cảnh báo liên quan

Ghi chú. Hướng dẫn này được viết dành cho Python 3 nhưng có một chút khác biệt giữa Python 2 và 3 khi nói đến việc sao chép các đối tượng. Khi có sự khác biệt, tôi sẽ chỉ ra chúng trong văn bản

Hãy bắt đầu bằng cách xem cách sao chép các bộ sưu tập có sẵn của Python. Có thể sao chép các bộ sưu tập có thể thay đổi được tích hợp sẵn của Python như danh sách, ký tự và bộ bằng cách gọi các hàm xuất xưởng của chúng trên một bộ sưu tập hiện có

new_list = list(original_list)
new_dict = dict(original_dict)
new_set = set(original_set)

Tuy nhiên, phương pháp này sẽ không hoạt động đối với các đối tượng tùy chỉnh và trên hết, nó chỉ tạo các bản sao nông. Đối với các đối tượng phức hợp như danh sách, ký tự và tập hợp, có một sự khác biệt quan trọng giữa sao chép nông và sâu

Một bản sao nông có nghĩa là xây dựng một đối tượng bộ sưu tập mới và sau đó đưa vào đó các tham chiếu đến các đối tượng con được tìm thấy trong bản gốc. Thực chất phó bản nông chỉ sâu một bậc. Quá trình sao chép không lặp lại và do đó sẽ không tạo bản sao của chính các đối tượng con
Một bản sao sâu làm cho quá trình sao chép trở nên đệ quy. Nó có nghĩa là đầu tiên xây dựng một đối tượng bộ sưu tập mới và sau đó điền đệ quy nó với các bản sao của các đối tượng con được tìm thấy trong bản gốc. Sao chép một đối tượng theo cách này sẽ đi qua toàn bộ cây đối tượng để tạo ra một bản sao hoàn toàn độc lập của đối tượng ban đầu và tất cả các phần tử con của nó

Tôi biết, đó là một chút của một ngụm. Vì vậy, hãy xem xét một số ví dụ để hiểu rõ sự khác biệt giữa các bản sao sâu và nông

Tải xuống miễn phí. Nhận một chương mẫu từ Thủ thuật Python. Cuốn sách chỉ cho bạn các phương pháp hay nhất về Python với các ví dụ đơn giản mà bạn có thể áp dụng ngay lập tức để viết mã Pythonic + đẹp hơn

Tạo bản sao nông

Trong ví dụ bên dưới, chúng ta sẽ tạo một danh sách lồng nhau mới và sau đó sao chép sơ qua nó bằng hàm xuất xưởng

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

7

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

Điều này có nghĩa là

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8 bây giờ sẽ là một đối tượng mới và độc lập với cùng nội dung như

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9. Bạn có thể xác minh điều này bằng cách kiểm tra cả hai đối tượng

>>>

>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Để khẳng định

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8 có thực sự độc lập với bản gốc, chúng ta hãy làm một thí nghiệm nhỏ. Bạn có thể thử thêm một danh sách con mới vào bản gốc (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9) và sau đó kiểm tra để đảm bảo rằng sửa đổi này không ảnh hưởng đến bản sao (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8)

>>>

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Như bạn có thể thấy, điều này có tác dụng như mong đợi. Việc sửa đổi danh sách đã sao chép ở mức độ “hời hợt” hoàn toàn không có vấn đề gì

Tuy nhiên, vì chúng ta chỉ tạo một bản sao nông của danh sách ban đầu, nên

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8 vẫn chứa các tham chiếu đến các đối tượng con ban đầu được lưu trữ trong

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9

Những đứa trẻ này không được sao chép. Chúng chỉ được tham chiếu lại trong danh sách đã sao chép

Do đó, khi bạn sửa đổi một trong các đối tượng con trong

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9, sửa đổi này cũng sẽ được phản ánh trong

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8—đó là vì cả hai danh sách đều chia sẻ cùng một đối tượng con. Phó bản chỉ là nông, phó bản sâu một cấp

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

4

Trong ví dụ trên, chúng tôi (dường như) chỉ thực hiện thay đổi thành

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9. Nhưng hóa ra cả hai danh sách phụ ở chỉ mục 1 trong

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9 và

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

8 đều đã được sửa đổi. Một lần nữa, điều này xảy ra bởi vì chúng tôi chỉ tạo một bản sao nông của danh sách gốc

Nếu chúng ta tạo một bản sao sâu của

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9 trong bước đầu tiên, thì cả hai đối tượng sẽ hoàn toàn độc lập. Đây là sự khác biệt thực tế giữa các bản sao nông và sâu của các đối tượng

Bây giờ bạn đã biết cách tạo các bản sao nông của một số lớp bộ sưu tập tích hợp sẵn và bạn biết sự khác biệt giữa sao chép nông và sâu. Những câu hỏi chúng tôi vẫn muốn câu trả lời là

Làm cách nào bạn có thể tạo các bản sao sâu của các bộ sưu tập cài sẵn?
Làm cách nào bạn có thể tạo các bản sao (nông và sâu) của các đối tượng tùy ý, bao gồm các lớp tùy chỉnh?

Câu trả lời cho những câu hỏi này nằm trong mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1 trong thư viện chuẩn của Python. Mô-đun này cung cấp một giao diện đơn giản để tạo các bản sao nông và sâu của các đối tượng Python tùy ý

Loại bỏ các quảng cáo

Tạo bản sao sâu

Hãy lặp lại ví dụ sao chép danh sách trước đó, nhưng với một điểm khác biệt quan trọng. Thay vào đó, lần này chúng ta sẽ tạo một bản sao sâu bằng cách sử dụng hàm

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

2 được xác định trong mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

2

Khi bạn kiểm tra

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9 và bản sao của nó

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

5 mà chúng tôi đã tạo bằng

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

6, bạn sẽ thấy rằng cả hai đều giống hệt nhau một lần nữa—giống như trong ví dụ trước

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

6

Tuy nhiên, nếu bạn sửa đổi một trong các đối tượng con trong đối tượng ban đầu (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9), bạn sẽ thấy rằng sửa đổi này sẽ không ảnh hưởng đến bản sao sâu (

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

5)

Cả hai đối tượng, bản gốc và bản sao, lần này hoàn toàn độc lập.

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

9 được sao chép đệ quy, bao gồm tất cả các đối tượng con của nó

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

0

Bạn có thể muốn dành chút thời gian để ngồi xuống với trình thông dịch Python và xem qua các ví dụ này ngay bây giờ. Việc sao chép các đối tượng sẽ dễ dàng hơn khi bạn trực tiếp trải nghiệm và chơi với các ví dụ

Nhân tiện, bạn cũng có thể tạo các bản sao nông bằng một hàm trong mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1. Hàm

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

41 tạo bản sao nông của đối tượng

Điều này hữu ích nếu bạn cần thông báo rõ ràng rằng bạn đang tạo một bản sao nông ở đâu đó trong mã của mình. Sử dụng

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

41 cho phép bạn chỉ ra thực tế này. Tuy nhiên, đối với các bộ sưu tập tích hợp, nó được coi là Pythonic hơn khi chỉ sử dụng các hàm list, dict và set factory để tạo các bản sao nông

Sao chép các đối tượng Python tùy ý

Câu hỏi chúng ta vẫn cần trả lời là làm cách nào để tạo các bản sao (nông và sâu) của các đối tượng tùy ý, bao gồm các lớp tùy chỉnh. Bây giờ chúng ta hãy xem xét điều đó

Một lần nữa mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1 đến để giải cứu chúng tôi. Các hàm

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

41 và

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

6 của nó có thể được sử dụng để sao chép bất kỳ đối tượng nào

Một lần nữa, cách tốt nhất để hiểu cách sử dụng chúng là làm một thí nghiệm đơn giản. Tôi sẽ dựa trên ví dụ sao chép danh sách trước đó. Hãy bắt đầu bằng cách định nghĩa một lớp điểm 2D đơn giản

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

7

Tôi hy vọng bạn đồng ý rằng điều này là khá đơn giản. Tôi đã thêm một triển khai

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

46 để chúng ta có thể dễ dàng kiểm tra các đối tượng được tạo từ lớp này trong trình thông dịch Python

Ghi chú. Ví dụ trên sử dụng Python 3. 6 chuỗi f để xây dựng chuỗi được trả về bởi
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy
47. Trên Python 2 và các phiên bản Python 3 trước 3. 6, bạn sẽ sử dụng một biểu thức định dạng chuỗi khác, chẳng hạn
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy
0

Tiếp theo, chúng ta sẽ tạo một phiên bản

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

48 và sau đó sao chép (một cách nông cạn) nó, sử dụng mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

0

Nếu chúng tôi kiểm tra nội dung của đối tượng

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

48 ban đầu và bản sao (nông) của nó, chúng tôi sẽ thấy những gì chúng tôi mong đợi

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

1

Đây là một cái gì đó khác để ghi nhớ. Bởi vì đối tượng điểm của chúng ta sử dụng các kiểu bất biến (int) cho tọa độ của nó, nên không có sự khác biệt giữa bản sao nông và sâu trong trường hợp này. Nhưng tôi sẽ mở rộng ví dụ sau

Hãy chuyển sang một ví dụ phức tạp hơn. Tôi sẽ định nghĩa một lớp khác để biểu diễn các hình chữ nhật 2D. Tôi sẽ làm điều đó theo cách cho phép chúng ta tạo ra một hệ thống phân cấp đối tượng phức tạp hơn—các hình chữ nhật của tôi sẽ sử dụng các đối tượng

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

48 để thể hiện tọa độ của chúng

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

2

Một lần nữa, đầu tiên chúng ta sẽ cố gắng tạo một bản sao nông của một thể hiện hình chữ nhật

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

3

Nếu bạn kiểm tra hình chữ nhật ban đầu và bản sao của nó, bạn sẽ thấy ghi đè

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

46 hoạt động tốt như thế nào và quy trình sao chép nông hoạt động như mong đợi

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

4

Hãy nhớ ví dụ về danh sách trước đã minh họa sự khác biệt giữa các bản sao sâu và nông như thế nào? . Tôi sẽ sửa đổi một đối tượng sâu hơn trong hệ thống phân cấp đối tượng, sau đó bạn sẽ thấy thay đổi này cũng được phản ánh trong bản sao (nông)

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

5

Tôi hy vọng điều này hành xử như bạn mong đợi nó. Tiếp theo, tôi sẽ tạo một bản sao sâu của hình chữ nhật ban đầu. Sau đó, tôi sẽ áp dụng một sửa đổi khác và bạn sẽ thấy đối tượng nào bị ảnh hưởng

>>>

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

6

thì đấy. Lần này bản sao sâu (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

23) hoàn toàn độc lập với bản gốc (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

24) và bản sao nông (

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

25)

Chúng tôi đã đề cập rất nhiều điều ở đây và vẫn còn một số điểm tốt hơn để sao chép các đối tượng

Nó trả tiền để đi sâu (ha. ) về chủ đề này, vì vậy bạn có thể muốn nghiên cứu tài liệu về mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1. Ví dụ: các đối tượng có thể kiểm soát cách chúng được sao chép bằng cách xác định các phương thức đặc biệt

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

27 và

>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> ys = list(xs)  # Make a shallow copy

28 trên chúng

Loại bỏ các quảng cáo

3 điều cần nhớ

Tạo một bản sao nông của một đối tượng sẽ không sao chép các đối tượng con. Vì vậy, bản sao không hoàn toàn độc lập với bản gốc
Một bản sao sâu của một đối tượng sẽ sao chép đệ quy các đối tượng con. Bản sao hoàn toàn độc lập với bản gốc, nhưng việc tạo bản sao sâu sẽ chậm hơn

Bạn có thể sao chép các đối tượng tùy ý (bao gồm cả các lớp tùy chỉnh) bằng mô-đun

>>> xs.append(['new sublist'])
>>> xs
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['new sublist']]
>>> ys
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

1

Nếu bạn muốn tìm hiểu sâu hơn về các kỹ thuật lập trình Python cấp trung cấp khác, hãy xem phần thưởng miễn phí này

Tải xuống miễn phí. Nhận một chương mẫu từ Thủ thuật Python. Cuốn sách chỉ cho bạn các phương pháp hay nhất về Python với các ví dụ đơn giản mà bạn có thể áp dụng ngay lập tức để viết mã Pythonic + đẹp hơn

Đánh dấu là đã hoàn thành

🐍 Thủ thuật Python 💌

Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python

Gửi cho tôi thủ thuật Python »

Giới thiệu về Dan Bader

Làm thế nào để bạn sao chép thay vì tham chiếu trong python?

Dan Bader là chủ sở hữu và tổng biên tập của Real Python và là nhà phát triển chính của realpython. nền tảng học tập com. Dan đã viết mã hơn 20 năm và có bằng thạc sĩ về khoa học máy tính

» Thông tin thêm về Đan

Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực

Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia

Nâng cao kỹ năng Python của bạn »

Bạn nghĩ sao?

Đánh giá bài viết này

Tweet Chia sẻ Chia sẻ Email

Bài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?

Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi

Python có sao chép hoặc tham chiếu không?

Python luôn hoạt động theo tham chiếu, trừ khi bạn yêu cầu một bản sao một cách rõ ràng (một phần của danh sách tích hợp được coi là "yêu cầu một bản sao" -- nhưng một phần . Tuy nhiên, chính vì điều đó, alist=anotherlist; .

Copy() nghĩa là gì trong Python?

Copy() trong Lập trình Python là một phương thức được sử dụng trên các đối tượng để tạo các bản sao của chúng . Nó trả về một bản sao nông của danh sách. Sử dụng hàm deepcopy() của mô-đun sao chép có thể cung cấp bản sao thực/sâu của đối tượng.

programming python

Làm thế nào để bạn sao chép thay vì tham chiếu trong python?

Tạo bản sao nông

Tạo bản sao sâu

Sao chép các đối tượng Python tùy ý

3 điều cần nhớ

Python có sao chép hoặc tham chiếu không?

Copy() nghĩa là gì trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội