Nếu bạn là người mới sử dụng Python hoặc một nhà phát triển dày dạn kinh nghiệm thì rất có thể bạn đã thấy phương thức __init__ đặc biệt. Phát âm là “Dunder” hoặc gạch dưới kép là một phương thức đặc biệt khi khởi tạo một lớp. Trong các ngôn ngữ khác hỗ trợ lập trình hướng đối tượng, nó được gọi là hàm tạo. Phương thức __init__ được gọi khi một đối tượng được tạo từ lớp và cho phép nó khởi tạo các thuộc tính của lớp. Khá dễ dàng phải không?
Trong bài viết này, tôi muốn thảo luận về một trong những tính năng bị hiểu lầm nhiều nhất của Python là phương thức __new__. Chúng ta sẽ bắt đầu bằng cách đơn giản nói rằng cả hai phương thức __init__ và __new__ đều được gọi khi cố gắng tạo một thể hiện của một lớp. Theo tài liệu chính thức của Python, __new__ được sử dụng khi bạn cần kiểm soát việc tạo phiên bản mới trong khi __init__ được sử dụng để kiểm soát việc khởi tạo phiên bản mới. Về cơ bản, khi tạo các đối tượng Python, __new__ là phương thức đầu tiên được gọi và chịu trách nhiệm trả về một thể hiện mới của lớp
Mặt khác, __init__ không trả lại bất cứ thứ gì. Nó chỉ chịu trách nhiệm khởi tạo thể hiện SAU KHI nó được tạo. Một nguyên tắc nhỏ đơn giản là lớp __new__ không bao giờ được ghi đè trừ khi bạn đang phân lớp con một kiểu dữ liệu Python bất biến, chẳng hạn như kiểu dữ liệu số, chuỗi, byte, bộ cố định và bộ dữ liệu
Tại thời điểm này, bạn có thể nghĩ “Thật tuyệt, tôi cũng có thể đọc tài liệu. Khi nào tôi thực sự cần sử dụng cái này?” . Chúng ta có thể bắt đầu bằng cách tạo một đối tượng proxy viết thường tất cả các đối số và sau đó chuyển tiếp tất cả các lời gọi phương thức của nó đến bộ bên dưới. Tuy nhiên, làm điều này sẽ làm giảm hiệu suất đáng kể vì nó được viết bằng Python. Trong khi loại bộ tiêu chuẩn được viết bằng C làm cho nó nhanh hơn đáng kể so với bất kỳ mã Python nào mà chúng ta có thể viết. Một giả định ngây thơ nhưng công bằng khác là bắt đầu hạ thấp các bộ dữ liệu trong phương thức __init__
Tuy nhiên, lúc này đối tượng đã tồn tại trong bộ nhớ và không thể thay đổi [immutable]. Cách duy nhất để giải quyết vấn đề này là chặn và sửa đổi đối số trước khi đối tượng được tạo. Đây là nơi __new__ phát huy tác dụng
class LowerCaseTuple[tuple]:
def __new__[cls, iterable]:
lower_iterable = [l.lower[] for l in iterable]
return super[].__new[cls, lower_iterable]def lower_case_example[]:
print[LowerCaseTuple[['HELLO', 'MEDIUM']]]def main[]:
lower_case_example[]if __name__ == '__main__':
main[]
Chạy chương trình sau sẽ dẫn đến một bộ phần tử chữ thường
['hello', 'medium']Lý do điều này hiện có thể thực hiện được là do phương thức __new__ luôn chạy trước __init__ do đây là phương thức tĩnh cấp lớp. Khi một thể hiện của một lớp được tạo bằng cách gọi hàm tạo của lớp, phương thức __new__ sẽ được gọi trước để tạo thể hiện của lớp, sau đó thể hiện sẽ là phương thức __init__ cấp thể hiện để khởi tạo thể hiện của lớp. Điều quan trọng cần lưu ý là nếu __new__ không trả về một thể hiện của lớp mà nó bị ràng buộc [e. g. LowerCaseTuple], nó hoàn toàn bỏ qua bước xây dựng và sẽ trả về loại Không có. Để thấy điều này hoạt động, chỉ cần nhận xét câu lệnh trả về trong phương thức __new__ và chạy tập lệnh trên
Nếu bạn thích bài viết này, xin vui lòng vỗ tay và nếu bạn có bất kỳ nhận xét nào, vui lòng để lại chúng. Ngoài ra, bạn có thể theo dõi tôi trên Medium để cập nhật các bài đăng mới nhất của tôi
Gần đây tôi đã hỏi tôi phương thức
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Tôi không thể trả lời câu hỏi đó vì không có nhiều hướng dẫn nói về
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Điểm tương đồng
Hãy bắt đầu với những điểm tương đồng
- Cả hai đều được gọi/gọi trong quá trình tạo thể hiện
sự khác biệt
Hãy bắt đầu với sự khác biệt
newinit1Được gọi trước initĐược gọi sau new2Chấp nhận một loại làm đối số đầu tiênChấp nhận một thể hiện làm đối số đầu tiên3Được cho là trả về một thể hiện của loại đã nhậnKhông được phép trả về bất kỳ thứ gì4Được sử dụng để kiểm soát việc tạo cá thểĐược sử dụng để khởi tạo các biến thể hiệnNói về điểm đầu tiên.
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Nhân tiện, bạn có lưu ý rằng đối số đầu tiên của
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Đến điểm thứ ba,
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Mà một trong số họ là một nhà xây dựng?
Nếu bạn đến từ một ngôn ngữ khác, bạn có thể ngạc nhiên rằng có hai điều giống nhau đang làm cùng một loại công việc. Hầu hết các ngôn ngữ mà bạn có thể đã từng làm việc sẽ có một thứ gọi là hàm tạo
Trong Python, khái niệm đó được chia thành hàm tạo và trình khởi tạo. Và bạn có thể đoán ra,
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Xin lưu ý rằng
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
['hello', 'medium']65Một điều nữa tôi muốn thêm vào là… các biến thể hiện là cục bộ của một thể hiện. Vì vậy, bất cứ điều gì bạn đang làm trong init chỉ là cục bộ của phiên bản đó. Nhưng bất cứ điều gì bạn đang làm mới sẽ ảnh hưởng đến mọi thứ được tạo cho loại đó
Luồng thực thi với một ví dụ
Tôi sẽ thêm một số mã để làm cho điều này hấp dẫn hơn. Hãy xem xét ví dụ này
['hello', 'medium']7class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Đây là ví dụ đơn giản nhất về cả
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
['hello', 'medium']6Như bạn có thể thấy, phương thức mới được gọi đầu tiên và sau đó việc thực thi được chuyển sang phương thức init
Trường hợp sử dụng
Trường hợp sử dụng cho class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
2
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Một trong những trường hợp sử dụng tốt nhất mà tôi có thể lấy làm ví dụ là khi tạo một Singleton. Như chúng ta đã biết, Singleton đảm bảo một lớp chỉ có một thể hiện và cung cấp một điểm truy cập toàn cục cho nó
Một số nơi tôi đã thấy singleton đang hoạt động là trong lập trình trò chơi nơi chỉ có một phiên bản của trình phát. Một nơi khác, nếu bạn đã sử dụng các thư viện frontend như Vuex [hoặc Redux] thì chỉ có một phiên bản toàn cầu của cửa hàng. Không quan trọng bạn tạo bao nhiêu phiên bản, cuối cùng bạn sẽ chỉ có một
Hãy xem cách đạt được hành vi tương tự trong Python
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
đầu ra
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Như bạn có thể thấy, việc tạo… chỉ được in một lần. cả hai đều trỏ đến cùng một vị trí bộ nhớ. Trong trường hợp của tôi, đó là
['hello', 'medium']69Bạn có thể đoán rằng chúng ta không thể làm điều tương tự với
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Nhưng trước tiên, tôi muốn cho bạn thấy một trường hợp sử dụng khác của new
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
đầu ra
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Tôi không phải là nhà động vật học. Nhưng bạn hiểu ý tôi ở đây. Bạn có thể sử dụng
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Trường hợp sử dụng cho class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
1
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Như chúng ta đã thấy trước đây.
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Tôi đã sử dụng rộng rãi
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Ở đây tôi sẽ chứng minh một ví dụ như vậy
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Ví dụ trên không phải là một ví dụ hoàn chỉnh, nhưng khi được thiết lập chính xác, nó sẽ hiển thị một cửa sổ tương tự như thế này
Chìa khóa rút ra
- Trong hầu hết các trường hợp, bạn không cần
2 được gọi trướcclass Demo: def __new__[cls, *args]: print["__new__ called"] return object.__new__[cls] def __init__[self]: print["__init__ called"] d = Demo[]
1class Demo: def __new__[cls, *args]: print["__new__ called"] return object.__new__[cls] def __init__[self]: print["__init__ called"] d = Demo[]
2 trả về một thể hiện của lớpclass Demo: def __new__[cls, *args]: print["__new__ called"] return object.__new__[cls] def __init__[self]: print["__init__ called"] d = Demo[]
1 nhận các thể hiện của lớp được trả về bởiclass Demo: def __new__[cls, *args]: print["__new__ called"] return object.__new__[cls] def __init__[self]: print["__init__ called"] d = Demo[]
2class Demo: def __new__[cls, *args]: print["__new__ called"] return object.__new__[cls] def __init__[self]: print["__init__ called"] d = Demo[]- Sử dụng ________ 21 để khởi tạo giá trị
Khái niệm tương tự có thể được sử dụng để trả lời câu hỏi trừu tượng hóa và đóng gói
Sự kết luận
Đó là tất cả những gì tôi biết về
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
class Demo:
def __new__[cls, *args]:
print["__new__ called"]
return object.__new__[cls]
def __init__[self]:
print["__init__ called"]
d = Demo[]
Tôi cũng sẽ liệt kê một số tài liệu tham khảo mà tôi muốn viết bài đăng trên blog này để bạn có thể thực sự là nguồn thông tin thực sự.