Hướng dẫn in python 3 or higher if no class is inherited it implicitly inherits the object class - trong python 3 hoặc cao hơn nếu không có lớp nào được kế thừa thì nó sẽ kế thừa lớp đối tượng một cách ngầm định

Có bất kỳ lý do cho một tuyên bố lớp để kế thừa từ class ClassicSpam: pass 6?

Trong Python 3, ngoài khả năng tương thích giữa Python 2 và 3, không có lý do. Trong Python 2, nhiều lý do.

Python 2.x Story:

Trong Python 2.x (từ 2.2 trở đi) có hai kiểu lớp tùy thuộc vào sự hiện diện hoặc vắng mặt của

class ClassicSpam:
    pass

1. Các lớp kiểu "cổ điển": Họ không có

   class ClassicSpam:
       pass
   

   6 làm lớp cơ sở: classes: they don't have

   class ClassicSpam:
       pass
   

   6 as a base class:

   >>> class ClassicSpam:      # no base class
   ...     pass
   >>> ClassicSpam.__bases__
   ()
   

2. Các lớp kiểu "mới": Họ có, trực tiếp hoặc gián tiếp (ví dụ: kế thừa từ loại tích hợp),

   class ClassicSpam:
       pass
   

   6 dưới dạng lớp cơ sở: classes: they have, directly or indirectly (e.g inherit from a built-in type),

   class ClassicSpam:
       pass
   

   6 as a base class:

   >>> class NewSpam(object):           # directly inherit from object
   ...    pass
   >>> NewSpam.__bases__
   (<type 'object'>,)
   >>> class IntSpam(int):              # indirectly inherit from object...
   ...    pass
   >>> IntSpam.__bases__
   (<type 'int'>,) 
   >>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
   (<type 'object'>,)
   

Không còn nghi ngờ gì nữa, khi viết một lớp học, bạn sẽ luôn muốn tham gia các lớp học kiểu mới. Các đặc quyền của việc làm như vậy là rất nhiều, để liệt kê một số trong số chúng:

• Hỗ trợ cho các mô tả. Cụ thể, các cấu trúc sau được thực hiện với các mô tả:

  1. class NewSpam(object):
          pass
     

     0: Một phương thức nhận lớp như một đối số ngầm thay vì thể hiện.

  2. class NewSpam(object):
          pass
     

     1: Một phương thức không nhận được đối số ngầm

     class NewSpam(object):
          pass
     

     2 làm đối số đầu tiên.
  3. Các thuộc tính có

     class NewSpam(object):
          pass
     

     3: Tạo các chức năng để quản lý việc nhận, cài đặt và xóa thuộc tính.

  4. class NewSpam(object):
          pass
     

     4: Lưu các thỏa thuận bộ nhớ của một lớp và cũng dẫn đến quyền truy cập thuộc tính nhanh hơn. Tất nhiên, nó áp đặt những hạn chế.

• Phương thức tĩnh

  class NewSpam(object):
       pass
  

  5: Cho phép bạn tùy chỉnh cách tạo các phiên bản lớp mới.

• Thứ tự phân giải phương thức (MRO): Theo thứ tự nào các lớp cơ sở của một lớp sẽ được tìm kiếm khi cố gắng giải quyết phương thức nào để gọi.

• Liên quan đến MRO,

  class NewSpam(object):
       pass
  

  6 cuộc gọi. Cũng xem,

  class NewSpam(object):
       pass
  

  7 được coi là siêu.

Nếu bạn không thừa kế từ

class ClassicSpam:
    pass

Một trong những nhược điểm của các lớp kiểu mới là bản thân lớp học đòi hỏi nhiều hơn. Tuy nhiên, trừ khi bạn tạo ra nhiều đối tượng lớp, tôi nghi ngờ đây sẽ là một vấn đề và đó là một vụ chìm tiêu cực trong một biển tích cực.

Python 3.x Story:

Trong Python 3, mọi thứ được đơn giản hóa. Chỉ các lớp kiểu mới tồn tại (được gọi rõ ràng là các lớp) vì vậy, sự khác biệt duy nhất trong việc thêm

class ClassicSpam:
    pass

class ClassicSpam:
    pass

hoàn toàn tương đương (ngoài tên của họ :-) với điều này:

class NewSpam(object):
     pass

Và về điều này:

class Spam():
    pass

Tất cả đều có

class ClassicSpam:
    pass

class Spam():
    pass

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

Vậy bạn nên làm gì?

Trong Python 2: Luôn thừa kế từ

class ClassicSpam:
    pass

class ClassicSpam:
    pass

Trong Python 3: kế thừa từ

class ClassicSpam:
    pass

class ClassicSpam:
    pass

Giới thiệu

Lập trình hướng đối tượng tạo ra các mẫu mã có thể tái sử dụng để hạn chế dự phòng trong các dự án phát triển. Một cách mà lập trình hướng đối tượng đạt được mã có thể tái chế là thông qua kế thừa, khi một lớp con có thể tận dụng mã từ một lớp cơ sở khác.

Hướng dẫn này sẽ trải qua một số khía cạnh chính của thừa kế trong Python, bao gồm cách các lớp cha và lớp con hoạt động, cách ghi đè các phương thức và thuộc tính, cách sử dụng hàm

class NewSpam(object):
     pass

Điều kiện tiên quyết

Bạn nên cài đặt Python 3 và môi trường lập trình được thiết lập trên máy tính hoặc máy chủ của bạn. Nếu bạn không có môi trường lập trình được thiết lập, bạn có thể tham khảo hướng dẫn cài đặt và thiết lập cho môi trường lập trình cục bộ hoặc cho môi trường lập trình trên máy chủ của bạn phù hợp với hệ điều hành của bạn (Ubuntu, Centos, Debian, v.v.)

Thừa kế là gì?

Kế thừa là khi một lớp sử dụng mã được xây dựng trong một lớp khác. Nếu chúng ta nghĩ về sự kế thừa về mặt sinh học, chúng ta có thể nghĩ về một đứa trẻ thừa hưởng những đặc điểm nhất định từ cha mẹ của chúng. Đó là, một đứa trẻ có thể thừa hưởng chiều cao hoặc màu mắt của cha mẹ. Trẻ em cũng có thể chia sẻ cùng họ với cha mẹ của chúng. is when a class uses code constructed within another class. If we think of inheritance in terms of biology, we can think of a child inheriting certain traits from their parent. That is, a child can inherit a parent’s height or eye color. Children also may share the same last name with their parents.

Các lớp được gọi là các lớp con hoặc các lớp con kế thừa các phương thức và biến từ các lớp cha hoặc các lớp cơ sở.child classes or subclasses inherit methods and variables from parent classes or base classes.

Chúng ta có thể nghĩ về một lớp cha mẹ gọi là

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

Bởi vì lớp con

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

class Spam():
    pass

Lớp phụ huynh

Các lớp cha mẹ hoặc cơ sở tạo ra một mẫu trong đó con hoặc các lớp con có thể dựa trên. Các lớp mẹ cho phép chúng tôi tạo các lớp con thông qua kế thừa mà không phải viết lại mã tương tự mỗi lần. Bất kỳ lớp nào cũng có thể được thực hiện thành một lớp cha mẹ, vì vậy chúng là mỗi lớp đầy đủ chức năng theo cách riêng của họ, thay vì chỉ các mẫu.

Hãy nói rằng chúng tôi có một lớp phụ huynh

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

>>> [object in cls.__bases__ for cls in {Spam, NewSpam, ClassicSpam}]
[True, True, True]

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Tương tự, một lớp

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Hãy cùng tạo ra một lớp phụ huynh

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Thông tin: Để làm theo cùng với mã ví dụ trong hướng dẫn này, hãy mở một vỏ tương tác Python trên hệ thống cục bộ của bạn bằng cách chạy lệnh

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Chúng tôi sẽ tạo một tệp mới có tên

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Spam():
    pass

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

fish.py

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Chúng tôi đã khởi tạo biến

class Spam():
    pass

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Hãy để thêm một số phương pháp khác:

Cá.py

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Chúng tôi đã thêm các phương thức

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Vì hầu hết các loài cá chúng ta sẽ tạo ra được coi là cá xương (vì trong chúng có một bộ xương được làm từ xương) thay vì cá sụn (như trong chúng có một bộ xương được làm từ sụn), chúng ta có thể thêm một vài Nhiều thuộc tính hơn cho phương thức

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

fish.py

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Xây dựng một lớp cha theo phương pháp tương tự như xây dựng bất kỳ lớp nào khác, ngoại trừ chúng tôi đang suy nghĩ về những phương pháp mà các lớp con sẽ có thể sử dụng một khi chúng tôi tạo ra chúng.

Lớp trẻ em

Trẻ em hoặc các lớp con là các lớp sẽ kế thừa từ lớp cha. Điều đó có nghĩa là mỗi lớp trẻ sẽ có thể sử dụng các phương thức và biến của lớp cha.

Ví dụ: một lớp con

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Chúng ta có thể nghĩ về từng lớp trẻ là một lớp của lớp cha. Đó là, nếu chúng ta có một lớp con được gọi là

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Dòng đầu tiên của một lớp trẻ em trông hơi khác so với các lớp không phải con vì bạn phải chuyển lớp cha vào lớp con dưới dạng tham số:

class Trout(Fish):

Lớp

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Với các lớp con, chúng ta có thể chọn thêm nhiều phương thức hơn, ghi đè các phương thức cha mẹ hiện có hoặc chấp nhận các phương thức cha mẹ mặc định với từ khóa

class Trout(Fish):

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Bây giờ chúng ta có thể tạo một đối tượng

class Trout(Fish):

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Chúng tôi đã tạo một đối tượng

class Trout(Fish):

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Trout(Fish):

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Khi chúng tôi chạy chương trình, chúng tôi sẽ nhận được đầu ra sau:

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Tiếp theo, hãy để Lôi tạo một lớp trẻ khác bao gồm phương pháp riêng của nó. Chúng tôi sẽ gọi lớp này

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Tiếp theo, hãy để Lôi tạo một đối tượng

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Khi chúng tôi chạy chương trình, chúng tôi sẽ nhận được đầu ra sau:

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Tiếp theo, hãy để Lôi tạo một lớp trẻ khác bao gồm phương pháp riêng của nó. Chúng tôi sẽ gọi lớp này

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Tiếp theo, hãy để Lôi tạo một đối tượng

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Đầu ra cho thấy đối tượng ____102

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Nếu chúng ta cố gắng sử dụng phương thức

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Trout(Fish):

Điều này là do phương pháp >>> class NewSpam(object): # directly inherit from object ... pass >>> NewSpam.__bases__ (<type 'object'>,) >>> class IntSpam(int): # indirectly inherit from object... ... pass >>> IntSpam.__bases__ (<type 'int'>,) >>> IntSpam.__bases__[0].__bases__ # ... because int inherits from object (<type 'object'>,) 09 chỉ thuộc về lớp con >>> class NewSpam(object): # directly inherit from object ... pass >>> NewSpam.__bases__ (<type 'object'>,) >>> class IntSpam(int): # indirectly inherit from object... ... pass >>> IntSpam.__bases__ (<type 'int'>,) >>> IntSpam.__bases__[0].__bases__ # ... because int inherits from object (<type 'object'>,) 02 chứ không phải lớp phụ huynh class Fish: def __init__(self, first_name, last_name="Fish"): self.first_name = first_name self.last_name = last_name 7.

Các lớp con kế thừa các phương pháp của lớp cha mà nó thuộc về, vì vậy mỗi lớp con có thể sử dụng các phương pháp đó trong các chương trình.override them.

Ghi đè các phương thức cha mẹ

Cho đến nay, chúng tôi đã xem xét lớp con

class Trout(Fish):

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Khi xây dựng các lớp cha mẹ và con cái, điều quan trọng là phải ghi nhớ thiết kế chương trình để việc ghi đè không tạo ra mã không cần thiết hoặc dự phòng.

Theo điều này, chúng tôi sẽ ghi đè phương thức xây dựng

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Chúng tôi đã ghi đè các tham số được khởi tạo trong phương thức

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Spam():
    pass

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Phương pháp

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Bây giờ chúng ta có thể tạo một thể hiện của lớp con

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

fish.py

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Khi chúng tôi chạy mã này, chúng tôi sẽ nhận được đầu ra sau:

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Lớp con

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Khi sẽ có một số lượng hạn chế các lớp con độc đáo hơn các lớp khác, việc ghi đè các phương thức lớp phụ huynh có thể chứng minh là hữu ích.

Hàm class NewSpam(object): pass 7

Với chức năng

class NewSpam(object):
     pass

Khi chúng tôi sử dụng hàm

class NewSpam(object):
     pass

Trong một chương trình học sinh lớp, chúng tôi có thể muốn có một lớp con cho

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class NewSpam(object):
     pass

Hàm

class NewSpam(object):
     pass

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Để xem cách thức hoạt động của nó, hãy để sửa đổi lớp con

class Trout(Fish):

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

fish.py

class ClassicSpam:
    pass

Chúng tôi đã ghi đè phương thức

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

Bởi vì chúng tôi đã ghi đè phương thức, chúng tôi không còn cần phải vượt qua

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Trout(Fish):

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

Bây giờ chúng ta có thể gọi các biến khởi tạo của lớp cha và cũng sử dụng biến con duy nhất. Hãy để sử dụng điều này trong một ví dụ

class Trout(Fish):

fish.py

class ClassicSpam:
    pass

class ClassicSpam:
    pass

Đầu ra cho thấy đối tượng

class Trout(Fish):

class Trout(Fish):

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

class Fish:
    def __init__(self, first_name, last_name="Fish"):
        self.first_name = first_name
        self.last_name = last_name

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

class Spam():
    pass

Hàm Python tích hợp

class NewSpam(object):
     pass

Nhiều kế thừa

Nhiều kế thừa là khi một lớp có thể kế thừa các thuộc tính và phương thức từ nhiều lớp cha. Điều này có thể cho phép các chương trình giảm dự phòng, nhưng nó cũng có thể giới thiệu một số lượng phức tạp cũng như sự mơ hồ nhất định, vì vậy nó nên được thực hiện với suy nghĩ về thiết kế chương trình tổng thể. is when a class can inherit attributes and methods from more than one parent class. This can allow programs to reduce redundancy, but it can also introduce a certain amount of complexity as well as ambiguity, so it should be done with thought to overall program design.

Để hiển thị cách thức hoạt động của nhiều kế thừa, hãy để Lôi tạo một lớp con

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class Trout(Fish):

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

coral_reef.py

class ClassicSpam:
    pass

Lớp

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

Bây giờ hãy khởi tạo một đối tượng

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

coral_reef.py

class ClassicSpam:
    pass

Đối tượng

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

>>> class NewSpam(object):           # directly inherit from object
...    pass
>>> NewSpam.__bases__
(<type 'object'>,)
>>> class IntSpam(int):              # indirectly inherit from object...
...    pass
>>> IntSpam.__bases__
(<type 'int'>,) 
>>> IntSpam.__bases__[0].__bases__   # ... because int inherits from object  
(<type 'object'>,)

class ClassicSpam:
    pass

Đầu ra cho thấy các phương pháp từ cả hai lớp cha được sử dụng hiệu quả trong lớp con.

Nhiều kế thừa cho phép chúng tôi sử dụng mã từ nhiều lớp cha trong lớp con. Nếu cùng một phương thức được xác định trong nhiều phương thức cha mẹ, lớp con sẽ sử dụng phương thức của cha mẹ đầu tiên được khai báo trong danh sách tuple của nó.

Mặc dù nó có thể được sử dụng một cách hiệu quả, nên nhiều kế thừa nên được thực hiện một cách cẩn thận để các chương trình của chúng tôi không trở nên mơ hồ và khó hiểu đối với các lập trình viên khác.

Sự kết luận

Hướng dẫn này đã trải qua việc xây dựng các lớp cha và các lớp con, ghi đè các phương thức và thuộc tính cha mẹ trong các lớp con, sử dụng hàm

class NewSpam(object):
     pass

Kế thừa trong mã hóa hướng đối tượng có thể cho phép tuân thủ nguyên tắc phát triển phần mềm khô (không lặp lại), cho phép thực hiện nhiều hơn với ít mã và lặp lại. Kế thừa cũng buộc các lập trình viên phải suy nghĩ về cách họ đang thiết kế các chương trình họ đang tạo để đảm bảo rằng mã có hiệu quả và rõ ràng.

Bạn có cần phải thừa hưởng từ đối tượng Python 3?

Python có ngầm thừa kế lớp đối tượng không?

Các lớp Python có nên kế thừa đối tượng?

Tất cả các lớp có kế thừa từ đối tượng trong Python không?