__ init __ có cần thiết trong python không?

Các ví dụ trên là các lớp và đối tượng ở dạng đơn giản nhất và không thực sự hữu ích trong các ứng dụng thực tế

Để hiểu ý nghĩa của các lớp, chúng ta phải hiểu hàm __init__[] tích hợp sẵn

Tất cả các lớp đều có một hàm gọi là __init__[], hàm này luôn được thực thi khi lớp bắt đầu

Sử dụng hàm __init__[] để gán giá trị cho thuộc tính đối tượng hoặc các thao tác khác cần thực hiện khi đối tượng được tạo

Thí dụ

Tạo một lớp tên là Person, sử dụng hàm __init__[] để gán giá trị cho tên và tuổi

lớp người
def __init__[bản thân, tên, tuổi]
bản thân. tên = tên
bản thân. tuổi = tuổi

p1 = Người["John", 36]

in[p1. Tên]
in[p1. tuổi]

Tự mình thử »

Ghi chú. Hàm __init__[] được gọi tự động mỗi khi lớp được sử dụng để tạo một đối tượng mớ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[]

1 dunder đã làm gì trong Python. Và tôi đã nói, "nó được sử dụng để khởi tạo các biến bên trong một lớp". Và ngay sau đó, câu hỏi tiếp theo là, “vậy thì

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

2 dùng để làm gì?”. Và tôi hoàn toàn trống rỗng và không thể trả lời rằng

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[]

2. Tôi không muốn xảy ra điều này với bạn. Và đó là lý do tại sao tôi nghĩ ra bài viết blog này cho bạn

Đ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ện

Nó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[]

2 được gọi khi phiên bản được tạo lần đầu tiên. Điều này xảy ra trước khi khởi tạo lớp

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[]

1 luôn là

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

6 không? .

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

6 là cái mà

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

2 trả về

Đế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[]

2 được cho là trả về một thể hiện của lớp. Lưu ý rằng nếu

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

2 không trả về bất cứ thứ gì, thì

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

1 không được gọi

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,

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

2 là hàm tạo và

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

1 là hàm khởi tạo

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[]

2 là ẩn. Có nghĩa là nếu bạn không thực sự cần sửa đổi việc tạo một thể hiện của lớp, thì bạn không cần phải có phương thức

$ python3 in_it.py 
__new__ called
__init__ called

5

Mộ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

1
2
3
4
5
6
7
8
9

class 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[]

2 và

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

1 đang hoạt động. Nếu bạn lưu đoạn mã trên vào một tệp và chạy nó, bạn sẽ thấy như thế này

$ python3 in_it.py 
__new__ called
__init__ called

Như 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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Singleton:
    __instance = None
    
    def __new__[cls]:
        if cls.__instance is None:
            print["creating..."]
            cls.__instance = object.__new__[cls]
        return cls.__instance

s1 = Singleton[]
s2 = Singleton[]

print[s1]
print[s2]

đầu ra

$ python3 singleton.py 
creating...

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à

$ python3 in_it.py 
__new__ called
__init__ called

9

Bạ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[]

1? . Đó là bởi vì

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

1 không trả lại bất cứ thứ gì. Chúng ta sẽ xem trong phần tiếp theo những gì

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

1 rất phù hợp

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Animal:
    def __new__[cls, legs]:
        if legs == 2:
            return Biped[]
        else:
            return Quadruped[]

class Biped:
    def __init__[self]:
        print["Initializing 2-legged animal"]

class Quadruped:
    def __init__[self]:
        print["Initializing 4-legged animal"]

anim1 = Animal[legs=4]
anim1 = Animal[legs=2]

đầu ra

$ python3 newexample.py 
Initializing 4-legged animal
Initializing 2-legged animal

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[]

2 để tạo một thể hiện có điều kiện từ một lớp

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

Như chúng ta đã thấy trước đây.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

5 ở đó để khởi tạo một biến thể hiện. Các biến đối tượng này sau này có thể được sử dụng trong các phương thức khác nhau của đối tượng

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[]

1 khi tôi từng làm việc với khung Qt. Qt là một khuôn khổ để phát triển giao diện người dùng dựa trên máy tính để bàn. Khi khởi tạo các đối tượng giao diện người dùng, bạn có thể đặt độ rộng hoặc độ dài của cửa sổ. Bạn cũng có thể đọc các tùy chọn từ một tệp và áp dụng tùy chọn đó trong giai đoạn khởi tạo ứng dụng. Đặt tiêu đề cửa sổ có thể là một ví dụ khác

Ở đây tôi sẽ chứng minh một ví dụ như vậy

1
2
3
4
5

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

0

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

Cửa sổ PySide mẫu

Chìa khóa rút ra

• Trong hầu hết các trường hợp, bạn không cần

• class Demo:
      def __new__[cls, *args]:
          print["__new__ called"]
          return object.__new__[cls]
  
      def __init__[self]:
          print["__init__ called"]
  
  d = Demo[]
  

  2 được gọi trước

  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[]
  

  2 trả về một thể hiện của lớp

• class 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ởi

  class Demo:
      def __new__[cls, *args]:
          print["__new__ called"]
          return object.__new__[cls]
  
      def __init__[self]:
          print["__init__ called"]
  
  d = Demo[]
  

  2
• Sử dụng

  class Demo:
      def __new__[cls, *args]:
          print["__new__ called"]
          return object.__new__[cls]
  
      def __init__[self]:
          print["__init__ called"]
  
  d = Demo[]
  

  1 để 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

Phần 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[]

1 so với

class Demo:
    def __new__[cls, *args]:
        print["__new__ called"]
        return object.__new__[cls]

    def __init__[self]:
        print["__init__ called"]

d = Demo[]

2. Nếu bạn có một cái gì đó trong tâm trí của bạn mà tôi bỏ lỡ. Làm ơn cho tôi biết

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ự.

Điều gì xảy ra nếu tôi không sử dụng init trong Python?

Lớp Python có luôn cần init không?

Python có cần khởi tạo không?

Bạn có thể có một lớp mà không có init không?