Hướng dẫn __init__ multiple inheritance python - __init__ python đa kế thừa

Cách tiếp cận ("kiểu mới" hoặc "kiểu cũ") sẽ hoạt động nếu bạn có quyền kiểm soát mã nguồn cho

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Mã nguồn có thể truy cập: Sử dụng đúng "kiểu mới"

class A(object):
    def __init__(self):
        print("-> A")
        super(A, self).__init__()
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class C(A, B):
    def __init__(self):
        print("-> C")
        # Use super here, instead of explicit calls to __init__
        super(C, self).__init__()
        print("<- C")

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Ở đây, thứ tự phân giải phương pháp (MRO) ra lệnh sau:

• class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  0 ra lệnh

  >>> C()
  -> C
  -> A
  -> B
  <- B
  <- A
  <- C
  

  8 Đầu tiên, sau đó

  >>> C()
  -> C
  -> A
  -> B
  <- B
  <- A
  <- C
  

  9. MRO là

  class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  3.

• class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  4 tiếp tục dọc theo chuỗi MRO được bắt đầu trong

  class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  5 đến

  class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  6.

• class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  7 tiếp tục dọc theo chuỗi MRO được bắt đầu trong

  class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  5 đến

  class A(object):
      def __init__(self):
          print("-> A")
          print("<- A")
  
  class B(object):
      def __init__(self):
          print("-> B")
          # Don't use super here.
          print("<- B")
  
  class C(A, B):
      def __init__(self):
          print("-> C")
          A.__init__(self)
          B.__init__(self)
          print("<- C")
  

  9.

Bạn có thể nói rằng trường hợp này được thiết kế cho nhiều kế thừa.

Mã nguồn có thể truy cập: Sử dụng đúng "kiểu cũ"

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        # Don't use super here.
        print("<- B")

class C(A, B):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        B.__init__(self)
        print("<- C")

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Ở đây, MRO không quan trọng, vì

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        # Don't use super here.
        print("<- B")

class C(A, B):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        B.__init__(self)
        print("<- C")

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Mặc dù trường hợp này không được "thiết kế" cho nhiều kế thừa theo phong cách mới như trước đây, nhưng nhiều kế thừa vẫn có thể.

Bây giờ, điều gì sẽ xảy ra nếu

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Cha mẹ của bên thứ ba: >>> C() -> C -> A -> B <- B <- A <- C 8 không thực hiện >>> C() -> C -> A <- A -> B <- B <- C 7; >>> C() -> C -> A -> B <- B <- A <- C 9 không

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Lớp

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

Và điều gì sẽ xảy ra nếu đó là cách khác?

Cha mẹ của bên thứ ba: >>> C() -> C -> A -> B <- B <- A <- C 8 thực hiện >>> C() -> C -> A <- A -> B <- B <- C 7; >>> C() -> C -> A -> B <- B <- A <- C 9 không

class A(object):
    def __init__(self):
        print("-> A")
        super(A, self).__init__()
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        super(Adapter, self).__init__()
        B.__init__(self)
        print("<- C")

class C(Adapter, A):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Cùng một mẫu ở đây, ngoại trừ thứ tự thực thi được chuyển đổi trong

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Vì vậy, có vẻ như trừ khi tôi biết/kiểm soát ban đầu của các lớp tôi kế thừa từ (

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

8 và

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

9), tôi không thể đưa ra lựa chọn an toàn cho lớp tôi đang viết (

class A(object):
    def __init__(self):
        print("-> A")
        print("<- A")

class B(object):
    def __init__(self):
        print("-> B")
        super(B, self).__init__()
        print("<- B")

class Adapter(object):
    def __init__(self):
        print("-> C")
        A.__init__(self)
        super(Adapter, self).__init__()
        print("<- C")

class C(Adapter, B):
    pass

4).

Mặc dù bạn có thể xử lý các trường hợp mà bạn không kiểm soát mã nguồn của

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

>>> C()
-> C
-> A
<- A
-> B
<- B
<- C

Twitter

Linkedin

• Pinterest
• 2. Object class – lớp đối tượng là gì?
• 3. Python có hỗ trợ đã kế thừa – multiple inheritance không?
• 4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

Linkedin

• Pinterest
• 2. Object class – lớp đối tượng là gì?
• 3. Python có hỗ trợ đã kế thừa – multiple inheritance không?
• 4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

Linkedin

• Pinterest
• 2. Object class – lớp đối tượng là gì?
• 3. Python có hỗ trợ đã kế thừa – multiple inheritance không?
• 4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

Linkedin

• Pinterest
• 2. Object class – lớp đối tượng là gì?
• 3. Python có hỗ trợ đã kế thừa – multiple inheritance không?
• 4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

1. Sử dụng tên lớp cha

Đoạn code ví dụ cho thấy các thành viên của lớp cha có thể được truy cập tới từ bên trong các lớp con, bằng cách sử dụng tên của lớp cha.

2. Sử dụng hàm super()

Chúng ta cũng có thể truy cập tới các thành viên của lớp cha bằng cách sử dụng hàm super().

Đoạn code dưới đây sẽ mô tả cách sử dụng hàm super() để truy cập tới các thành viên của lớp cha, từ lớp con

# -----------------------------------------------------------
#Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
#@author cafedevn
#Contact: 
#Fanpage: https://www.facebook.com/cafedevn
#Instagram: https://instagram.com/cafedevn
#Twitter: https://twitter.com/CafedeVn
#Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
# -----------------------------------------------------------


# A Python program to demonstrate inheritance  
  
# Base or Super class. Note object in bracket. 
# (Generally, object is made ancestor of all classes) 
# In Python 3.x "class Person" is  
# equivalent to "class Person(object)" 
class Person(object): 
      
    # Constructor 
    def __init__(self, name): 
        self.name = name 
  
    # To get name 
    def getName(self): 
        return self.name 
  
    # To check if this person is employee 
    def isEmployee(self): 
        return False
  
  
# Inherited or Sub class (Note Person in bracket) 
class Employee(Person): 
  
    # Here we return true 
    def isEmployee(self): 
        return True
  
# Driver code 
emp = Person("Geek1")  # An Object of Person 
print(emp.getName(), emp.isEmployee()) 
  
emp = Employee("Geek2") # An Object of Employee 
print(emp.getName(), emp.isEmployee()) 

Kết quả in ra là:

('Geek1', False)
('Geek2', True)

• Pinterest
• 2. Object class – lớp đối tượng là gì?
• 3. Python có hỗ trợ đã kế thừa – multiple inheritance không?
• 4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

Pinterest

Trang chủ

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Kết quả in ra là:

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

2. Object class – lớp đối tượng là gì?

Cũng giống như lớp đối tượng trong Java, bắt đầu từ phiên bản 3.x của Python, đối tượng là gốc rễ của tất cả các lớp.

Trong Python 3.x, “class Test(object)” và “class Test” là như nhau.

Trong Python 2.x, “class Test(object)” sẽ tạo ra một lớp có đối tượng object làm lớp cha (được gọi là new style class), còn “class Test” sẽ tạo ra một old style class – lớp bình thường (không có đối tượng nào làm lớp cha của nó)

3. Python có hỗ trợ đã kế thừa – multiple inheritance không?

Không giống như Java và giống như C++, Python có hỗ trợ đã kế thừa. Chúng ta có thể chỉ định nhiều lớp cha, phân cách nhau bởi dấu phẩy, và tất cả được bao trong một cặp dấu ngoặc tròn () để thực hiện đa kế thừa. 

Dưới đây là ví dụ mô tả cách thức hoạt động của đa kế thừa trong Python

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Kết quả in ra là:

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

1. Sử dụng tên lớp cha

Đoạn code ví dụ cho thấy các thành viên của lớp cha có thể được truy cập tới từ bên trong các lớp con, bằng cách sử dụng tên của lớp cha.

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Kết quả in ra là:

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

1. Sử dụng tên lớp cha

Đoạn code ví dụ cho thấy các thành viên của lớp cha có thể được truy cập tới từ bên trong các lớp con, bằng cách sử dụng tên của lớp cha.

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

Kết quả in ra là:

>>> C()
-> C
-> A
-> B
<- B
<- A
<- C

4. Làm thế nào để truy cập tới các thành viên của lớp cha, tại lớp con?

1. Sử dụng tên lớp cha

Đoạn code ví dụ cho thấy các thành viên của lớp cha có thể được truy cập tới từ bên trong các lớp con, bằng cách sử dụng tên của lớp cha.

2. Sử dụng hàm super()

• Chúng ta cũng có thể truy cập tới các thành viên của lớp cha bằng cách sử dụng hàm super().
• python.org
• Đoạn code dưới đây sẽ mô tả cách sử dụng hàm super() để truy cập tới các thành viên của lớp cha, từ lớp con

Lưu ý rằng, hai phương thức ở trên không hoàn toàn giống nhau. Trong bài học tiếp theo về kế thừa, chúng ta sẽ thảo luận tiếp hai chủ đề sau:

• – Cách thức hoạt động của super? Làm thế nào mà việc truy cập tới thành viên (biến thành viên, hàm thành viên) của lớp cha, thông qua super và tên lớp cha lại khác nhau?
• – Vấn đề Diamon (kim cương) được giải quyết thế nào trong Python?
• Nguồn và Tài liệu tiếng anh tham khảo:

w3school

• geeksforgeeks
• Tài liệu từ cafedev:
• Full series tự học Python từ cơ bản tới nâng cao tại đây nha.
• Ebook về python tại đây.
• Các series tự học lập trình khác
• Nếu bạn thấy hay và hữu ích, bạn có thể tham gia các kênh sau của cafedev để nhận được nhiều hơn nữa:
• Group Facebook
• Fanpage

Youtube

Instagram