copy với copy.copy (nông) và copy.deepcopy (sâu). Điểm cần nhớ nhất: shallow copy chia sẻ tham chiếu tới các đối tượng con mutable, sửa bản clone có thể làm hỏng bản gốc.Bạn có một đối tượng đã cấu hình xong xuôi: nạp dữ liệu, tính toán vài thứ, chỉnh đủ tham số. Giờ cần một đối tượng gần giống hệt, chỉ khác vài chỗ. Dựng lại từ đầu thì phí, mà chép tay từng thuộc tính thì dễ sót. Prototype giải quyết đúng tình huống này: cứ nhân bản cái đã có rồi chỉnh phần khác biệt.
Prototype là gì?
Prototype (mẫu vật) là một pattern nhóm Creational (khởi tạo). Ý tưởng gọn trong một câu: tạo đối tượng mới bằng cách clone một đối tượng mẫu, thay vì gọi constructor và cấu hình lại từ số 0.
Hình dung việc photocopy một tài liệu đã điền sẵn. Bạn có một tờ đơn điền đầy đủ thông tin chung. Cần một bản cho người khác, bạn không lấy tờ trắng điền lại từ đầu, mà photo cái bản đã điền rồi chỉ sửa vài ô riêng. Nhanh hơn, và chắc chắn không quên phần chung. Trong game cũng vậy: có một con quái "mẫu" với đủ chỉ số, muốn thả 50 con ra map thì clone từ mẫu đó, không dựng từng con từ đầu.
Điểm mấu chốt: đối tượng mẫu (prototype) tự biết cách sinh ra bản sao của chính nó. Bạn không cần biết class cụ thể hay quá trình cấu hình phức tạp phía sau, chỉ cần nói "cho tôi một bản giống anh".
Vì sao cần, và khi nào dùng
Prototype đáng dùng khi:
- Tạo mới tốn kém. Đối tượng phải nạp dữ liệu từ DB, đọc file, tính toán nặng hay gọi mạng mới sẵn sàng. Đã trả cái giá đó một lần rồi thì clone lại rẻ hơn nhiều so với dựng lại.
- Muốn nhân bản trạng thái hiện tại. Bạn cần một bản sao đúng y trạng thái của đối tượng ở thời điểm này (ví dụ để thử nghiệm, để "undo", để tạo biến thể), không phải một đối tượng mặc định mới tinh.
- Có nhiều biến thể gần giống nhau. Chuẩn bị sẵn vài "mẫu" cấu hình, mỗi lần cần thì clone rồi chỉnh vài chỗ, thay vì lặp lại đống code khởi tạo giống nhau.
Cách hoạt động trong Python
Nhiều ngôn ngữ phải tự viết method clone() cho pattern này. Python cho sẵn qua module chuẩn copy, với hai mức sao chép mà bạn bắt buộc phải phân biệt: copy.copy (shallow, nông) và copy.deepcopy (deep, sâu).
Shallow copy: chỉ chép lớp vỏ
copy.copy tạo một đối tượng mới, nhưng các thuộc tính của nó vẫn trỏ tới cùng những đối tượng con như bản gốc. Nếu thuộc tính là kiểu mutable (list, dict, set, hay một object khác), bản gốc và bản clone chia sẻ chung cái đó:
import copy
# Mau nhan vat trong game: co inventory (list) va stats (dict) long nhau
class Monster:
def __init__(self, name, hp, inventory, stats):
self.name = name
self.hp = hp
self.inventory = inventory # mutable: list
self.stats = stats # mutable: dict
def __repr__(self):
return f"Monster({self.name}, hp={self.hp}, inv={self.inventory}, stats={self.stats})"
# Con quai goc, cau hinh san
goblin = Monster("Goblin", 100, ["dao gi"], {"atk": 12, "def": 5})
# Shallow copy: sao chep vo boc ngoai, nhung inventory/stats VAN chung tham chieu
shallow = copy.copy(goblin)
shallow.name = "Goblin (shallow)"
shallow.inventory.append("khien") # sua list cua ban clone
print("Goc :", goblin)
print("Shallow :", shallow)
Chú ý cái bẫy: tôi chỉ append vào inventory của bản clone, nhưng inventory của bản gốc cũng mọc thêm "khien". Lý do: hai đối tượng dùng chung một list trong bộ nhớ. Đổi name thì không sao (gán lại thuộc tính là tạo liên kết mới, riêng cho từng đối tượng), nhưng sửa bên trong một đối tượng con mutable thì cả hai cùng dính.
Deep copy: chép sâu theo đồ thị đối tượng
copy.deepcopy đi theo đồ thị đối tượng (object graph) và sao chép đệ quy các đối tượng con có thể copy được: con, con của con... Với một đồ thị đối tượng thông thường, các đối tượng con mutable đều được nhân bản riêng, nên sửa trong clone không đụng tới bản gốc:
import copy
class Monster:
def __init__(self, name, hp, inventory, stats):
self.name = name
self.hp = hp
self.inventory = inventory
self.stats = stats
def __repr__(self):
return f"Monster({self.name}, hp={self.hp}, inv={self.inventory}, stats={self.stats})"
goblin = Monster("Goblin", 100, ["dao gi"], {"atk": 12, "def": 5})
# Deep copy: sao chep de quy, moi doi tuong con cung duoc nhan ban rieng
deep = copy.deepcopy(goblin)
deep.name = "Goblin (deep)"
deep.inventory.append("khien") # sua list cua ban clone
deep.stats["atk"] = 99 # sua dict cua ban clone
print("Goc :", goblin)
print("Deep :", deep)
Lần này bản gốc đứng yên: inventory vẫn chỉ có "dao gi", stats vẫn atk=12. Mọi thay đổi nằm gọn trong deep. Đây mới là "nhân bản" theo đúng nghĩa bạn thường mong đợi.
Nhưng đừng đọc deepcopy thành "clone hoàn toàn độc lập, không còn dính gì tới bản gốc". Nó có ngoại lệ và có cơ chế tuỳ biến:
- Class được phép tự định nghĩa cách clone qua
__deepcopy__(self, memo)(và__copy__cho shallow). Nếu class làm vậy, kết quả là do class quyết định, không phải docopyquyết định. memogiữ đúng quan hệ dùng chung. Một đối tượng xuất hiện nhiều lần trong đồ thị chỉ được copy một lần, các bản sao vẫn trỏ về cùng một đối tượng mới. Nhờ đó tham chiếu vòng không gây đệ quy vô hạn, và cấu trúc chia sẻ không bị biến thành nhiều bản rời rạc.- Có thứ không copy được, hoặc không nên copy. File handle, socket, kết nối DB, lock... thường ném lỗi hoặc cho ra thứ vô nghĩa.
- Hàm và class không bị nhân bản.
deepcopytrả về chính chúng (giữ nguyên tham chiếu), nên thuộc tính trỏ tới hàm hay class vẫn là cùng một đối tượng.
Ba điểm cuối dễ thấy nhất khi chạy thật:
import copy
import threading
class Worker:
def __init__(self, name):
self.name = name
self.lock = threading.Lock() # tai nguyen: KHONG copy duoc
try:
copy.deepcopy(Worker("w1"))
except TypeError as e:
print("1. deepcopy that bai:", e)
class SafeWorker:
def __init__(self, name):
self.name = name
self.tasks = ["a"]
self.lock = threading.Lock()
def __deepcopy__(self, memo):
new = SafeWorker.__new__(SafeWorker)
memo[id(self)] = new # dang ky truoc, tranh de quy vo han
new.name = self.name
new.tasks = copy.deepcopy(self.tasks, memo)
new.lock = threading.Lock() # khoi tao lai, khong sao chep
return new
goc = SafeWorker("w2")
clone = copy.deepcopy(goc)
clone.tasks.append("b")
print("2. clone:", clone.tasks, "| goc:", goc.tasks, "| lock rieng:", clone.lock is not goc.lock)
# memo con giu dung quan he dung chung: 1 object xuat hien 2 lan van la 1 sau khi copy
chung = {"k": 1}
cap = copy.deepcopy([chung, chung])
print("3. van dung chung sau deepcopy:", cap[0] is cap[1])
# ham va class khong bi nhan ban, deepcopy tra ve chinh no
def ham(): pass
print("4. ham/class giu nguyen tham chieu:", copy.deepcopy(ham) is ham, copy.deepcopy(SafeWorker) is SafeWorker)
Dòng 1 cho thấy deepcopy không phải lúc nào cũng chạy được. Dòng 2 cho thấy khi class tự cài __deepcopy__, bạn là người quyết định cái gì được nhân bản và cái gì được dựng lại. Dòng 3 và 4 cho thấy "độc lập" không có nghĩa là "mọi thứ bên trong đều là bản sao mới".
Đây chính là Prototype
Ghép lại với ý tưởng ban đầu: dựng một "mẫu" chuẩn tốn công một lần, rồi mỗi đối tượng mới chỉ là clone từ mẫu đó và chỉnh phần khác biệt:
import copy
# Mot cau hinh "nang": gia su phai tinh toan/nap nhieu thu moi dung duoc
class ReportConfig:
def __init__(self):
# Tuong tuong cho nay tinh toan ton kem, nap tu DB, doc file...
self.columns = ["ngay", "doanh_thu", "chi_phi"]
self.filters = {"vung": "toan_quoc", "trang_thai": "da_duyet"}
self.theme = "sang"
def __repr__(self):
return f"cols={self.columns}, filters={self.filters}, theme={self.theme}"
# Dung 1 lan cai "mau" (prototype) chuan
base = ReportConfig()
# Moi bao cao moi = clone tu mau roi chinh vai cho, khong dung lai tu dau
report_mien_bac = copy.deepcopy(base)
report_mien_bac.filters["vung"] = "mien_bac"
report_toi = copy.deepcopy(base)
report_toi.theme = "toi"
print("Mau goc :", base)
print("Mien Bac :", report_mien_bac)
print("Nen toi :", report_toi)
Nhờ dùng deepcopy, khi tôi sửa filters của report_mien_bac, cái filters của base và của report_toi không hề bị ảnh hưởng. Ba đối tượng tách rời nhau về phần state mutable, cùng sinh ra từ một mẫu.
__copy__(self) để định nghĩa hành vi cho copy.copy, và __deepcopy__(self, memo) cho copy.deepcopy. Hữu ích khi có thuộc tính không nên (hoặc không thể) sao chép, ví dụ muốn clone reset lại một cache, hay bỏ qua một kết nối. Tham số memo là dict Python dùng để nhớ đối tượng đã copy, tránh lặp vô hạn khi có tham chiếu vòng.copy.deepcopy() chỉ là một công cụ của Python để hiện thực ý định đó. Gọi deepcopy ở đâu đó không tự động nghĩa là bạn đang dùng Prototype - phần lớn lời gọi deepcopy trong code chỉ là "tôi cần một bản sao để khỏi đụng dữ liệu gốc", không có mẫu nào cả. Ngược lại, Prototype hoàn toàn có thể hiện thực không cần copy: tự viết clone(), một factory dựng đối tượng từ template, hay deserialize lại từ một snapshot đã lưu. Cái làm nên pattern là vai trò "mẫu" của đối tượng gốc, không phải hàm bạn dùng để chép nó.Cạm bẫy: shallow vs deep
deepcopy.- Không phải lúc nào cũng nên deepcopy. Deep copy tốn thời gian và bộ nhớ hơn (phải đi hết cây đối tượng). Nếu các thuộc tính đều là kiểu bất biến (immutable: số, chuỗi, tuple của immutable) thì shallow đã đủ và nhanh hơn.
- Cẩn thận tài nguyên không nên copy. File handle, socket, kết nối DB, thread... không sao chép được một cách có nghĩa. Sao chép chúng thường gây lỗi hoặc hành vi kỳ lạ (hai đối tượng cùng ghi vào một file). Với những thứ này, hãy tự cài
__deepcopy__để bỏ qua hoặc khởi tạo lại tài nguyên, đừng đểdeepcopytự làm. - Tham chiếu vòng. Nếu đối tượng trỏ vòng về chính nó,
deepcopyvẫn xử lý đúng nhờmemo, nhưng nếu bạn tự viết clone thủ công thì phải tự lo chuyện này.
Khi nào KHÔNG nên dùng
Prototype không phải mặc định. Đừng đụng tới nó khi:
- Đối tượng đơn giản, tạo mới rẻ. Nếu constructor chỉ gán vài thuộc tính, cứ gọi
MyClass(...)bình thường. Clone rồi chỉnh lại còn khó đọc hơn. - Bạn muốn một đối tượng mặc định mới, không phải bản sao trạng thái hiện tại. Lúc đó khởi tạo trực tiếp mới đúng ý; clone chỉ khiến trạng thái cũ dính theo ngoài mong muốn.
- Trạng thái quá phức tạp/không rõ ràng. Nếu chính bạn còn không chắc cái gì nên chép sâu, cái gì nên chia sẻ, thì clone tự động dễ giấu lỗi. Khi đó một hàm factory viết tay, tường minh, lại an toàn hơn.
Trong hệ thống thật
Chỗ tôi thấy Prototype xuất hiện nhiều nhất không phải trong code "pattern hoá" đàng hoàng, mà nằm rải rác dưới dạng một object mẫu và vài lời gọi clone:
- Factory tạo fixture cho test. Một
base_orderhaybase_userđầy đủ field hợp lệ được dựng một lần, mỗi test clone nó ra rồi chỉ tinh chỉnh đúng field mình quan tâm. Test đọc ra ý định ("đơn hàng này đã thanh toán") thay vì 20 dòng gán thuộc tính nhiễu. Quan trọng hơn: phải clone chứ không dùng chung, nếu không test này sửa fixture làm hỏng test kia, và bug đó chỉ lộ ra khi đổi thứ tự chạy. - Template cấu hình cho từng tenant/môi trường. Có một config mặc định đã qua validate, mỗi tenant hoặc mỗi môi trường (dev, staging, prod) clone bản mặc định rồi override vài khoá. Tránh chuyện mỗi nơi tự dựng config từ số 0 rồi thiếu mất một key mới thêm tuần trước.
- Spawn entity trong game hoặc simulation. Load định nghĩa quái/đạn/NPC từ file một lần thành object mẫu, lúc runtime cần 200 con thì clone, không parse lại file 200 lần. Đây là trường hợp "tạo mới tốn kém" rõ nhất.
- Nhân bản bản nháp tài liệu hoặc đơn hàng mẫu. Nút "Duplicate" trong CMS, "Tạo đơn tương tự" trong hệ thống bán hàng, "Save as template" trong công cụ thiết kế - bản chất đều là clone một bản ghi đã cấu hình rồi cho người dùng sửa tiếp. Chỗ này cái khó không phải copy, mà là quyết định cái gì KHÔNG được copy: id, mã đơn, thời gian tạo, trạng thái thanh toán, lịch sử duyệt.
- Clone request/context trước khi sửa. Middleware hay client HTTP thường clone object request (headers, params, timeout) trước khi thêm bớt, để không làm bẩn bản gốc dùng chung cho các lời gọi sau. Với object bất biến thì khỏi cần, nhưng phần lớn config client trong thực tế là mutable.
Trade-off
Được:
- Bỏ qua được bước khởi tạo tốn kém: đọc file, query DB, gọi mạng, tính toán nặng chỉ trả giá một lần cho bản mẫu.
- Nhân bản cả một cấu hình phức tạp mà không cần biết cách dựng nó, cũng không cần biết class cụ thể phía sau.
- Thêm biến thể mới chỉ cần thêm một prototype, không phải thêm một nhánh
ifhay một subclass trong factory. - Mẫu có thể được nạp từ dữ liệu (file config, DB) lúc chạy, nên thêm biến thể không cần sửa code và deploy lại.
Phải trả giá:
- Shallow vs deep rất dễ sai, và lỗi thường âm thầm: code "trông như" đã tạo bản riêng nhưng thật ra hai bên vẫn dùng chung một list, đến khi dữ liệu lệch nhau mới phát hiện.
deepcopytốn CPU và bộ nhớ khi đồ thị đối tượng lớn. Clone một object ôm cache vài chục MB trong vòng lặp là một cách tự tạo sự cố.- Đối tượng ôm tài nguyên (socket, file handle, lock, connection pool) không copy được, buộc bạn phải viết và bảo trì
__deepcopy__cho từng class như vậy. - Clone mang theo cả state không mong muốn: id, timestamp, cache đã hâm nóng, cờ trạng thái nội bộ. Phải chủ động reset, và danh sách "cần reset" rất dễ lạc hậu.
__deepcopy__tự viết là code phải bảo trì song song với class: thêm một thuộc tính mới mà quên cập nhật clone, bạn có một bug im lặng đúng kiểu khó truy nhất.
Tóm tắt
- Prototype: tạo đối tượng mới bằng cách clone một mẫu có sẵn, thay vì dựng lại từ đầu. Hợp khi tạo mới tốn kém hoặc cần nhân bản trạng thái hiện tại.
- Python cho sẵn qua module
copy:copy.copy(shallow) vàcopy.deepcopy(deep). - Shallow chép lớp vỏ nhưng chia sẻ tham chiếu tới các đối tượng con mutable, sửa clone có thể làm hỏng bản gốc. Deep đi theo đồ thị đối tượng và nhân bản đệ quy các đối tượng con copy được - tách rời phần state mutable, nhưng không phải là "clone tuyệt đối".
- Prototype là pattern (ý định: nhân bản một mẫu đã cấu hình sẵn),
copy.deepcopychỉ là công cụ hiện thực nó trong Python. Gọideepcopykhông có nghĩa là đang dùng Prototype. - Tuỳ biến clone bằng
__copy__/__deepcopy__; cẩn thận với tài nguyên không nên copy (file, socket, kết nối). - Đối tượng đơn giản, tạo mới rẻ thì cứ khởi tạo bình thường, đừng vẽ ra pattern.
Nguồn tham khảo
- Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương Prototype trong nhóm Creational.
- Tài liệu Python chính thức, module
copy(Shallow and deep copy operations), giải thíchcopy.copy,copy.deepcopy,__copy__,__deepcopy__.
- Kai