Python có hỗ trợ tất cả các quyền thừa kế không?

9. 1. Đôi lời về tên và đối tượng¶

Các đối tượng có tính riêng biệt và nhiều tên (trong nhiều phạm vi) có thể được liên kết với cùng một đối tượng. Điều này được gọi là bí danh trong các ngôn ngữ khác. Điều này thường không được đánh giá cao trong cái nhìn đầu tiên về Python và có thể được bỏ qua một cách an toàn khi xử lý các loại cơ bản không thay đổi (số, chuỗi, bộ dữ liệu). Tuy nhiên, bí danh có thể có tác động đáng ngạc nhiên đối với ngữ nghĩa của mã Python liên quan đến các đối tượng có thể thay đổi như danh sách, từ điển và hầu hết các loại khác. Điều này thường được sử dụng vì lợi ích của chương trình, vì bí danh hoạt động giống như con trỏ ở một số khía cạnh. Ví dụ, việc truyền một đối tượng là rẻ vì quá trình thực hiện chỉ truyền một con trỏ;

9. 2. Phạm vi Python và không gian tên¶

Trước khi giới thiệu các lớp học, trước tiên tôi phải nói với bạn đôi điều về quy tắc phạm vi của Python. Định nghĩa lớp chơi một số thủ thuật gọn gàng với không gian tên và bạn cần biết cách phạm vi và không gian tên hoạt động để hiểu đầy đủ những gì đang diễn ra. Ngẫu nhiên, kiến ​​thức về chủ đề này rất hữu ích cho bất kỳ lập trình viên Python nâng cao nào

Hãy bắt đầu với một số định nghĩa

Một không gian tên là ánh xạ từ tên đến đối tượng. Hầu hết các không gian tên hiện được triển khai dưới dạng từ điển Python, nhưng điều đó thường không đáng chú ý theo bất kỳ cách nào (ngoại trừ hiệu suất) và nó có thể thay đổi trong tương lai. Ví dụ về không gian tên là. tập hợp các tên dựng sẵn (chứa các hàm như

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Nhân tiện, tôi sử dụng thuộc tính từ cho bất kỳ tên nào sau dấu chấm — ví dụ: trong biểu thức

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các thuộc tính có thể là chỉ đọc hoặc ghi. Trong trường hợp sau, có thể gán cho các thuộc tính. Thuộc tính mô-đun có thể ghi. bạn có thể viết

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Không gian tên được tạo tại các thời điểm khác nhau và có thời gian tồn tại khác nhau. Không gian tên chứa tên dựng sẵn được tạo khi trình thông dịch Python khởi động và không bao giờ bị xóa. Không gian tên chung cho một mô-đun được tạo khi định nghĩa mô-đun được đọc vào; . Các câu lệnh được thực thi bởi lời gọi cấp cao nhất của trình thông dịch, được đọc từ tệp tập lệnh hoặc tương tác, được coi là một phần của mô-đun có tên là

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Không gian tên cục bộ cho một hàm được tạo khi hàm được gọi và bị xóa khi hàm trả về hoặc đưa ra một ngoại lệ không được xử lý trong hàm. (Thật ra, quên sẽ là cách tốt hơn để mô tả những gì thực sự xảy ra. ) Tất nhiên, mỗi lời gọi đệ quy đều có không gian tên cục bộ của riêng chúng

Phạm vi là một vùng văn bản của chương trình Python nơi không gian tên có thể truy cập trực tiếp. “Có thể truy cập trực tiếp” ở đây có nghĩa là một tham chiếu không đủ tiêu chuẩn đến một tên cố gắng tìm tên đó trong không gian tên

Mặc dù phạm vi được xác định tĩnh nhưng chúng được sử dụng động. Bất cứ lúc nào trong quá trình thực thi, có 3 hoặc 4 phạm vi lồng nhau có không gian tên có thể truy cập trực tiếp

• phạm vi trong cùng, được tìm kiếm đầu tiên, chứa tên địa phương

• phạm vi của bất kỳ chức năng kèm theo nào, được tìm kiếm bắt đầu bằng phạm vi kèm theo gần nhất, chứa các tên không cục bộ, nhưng cũng không phải toàn cầu

• phạm vi next-to-last chứa tên chung của mô-đun hiện tại

• phạm vi ngoài cùng (được tìm kiếm cuối cùng) là không gian tên chứa các tên dựng sẵn

Nếu một tên được khai báo là toàn cục, thì tất cả các tham chiếu và phép gán sẽ chuyển trực tiếp đến phạm vi giữa chứa các tên toàn cục của mô-đun. Để liên kết lại các biến được tìm thấy bên ngoài phạm vi trong cùng, có thể sử dụng câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Thông thường, phạm vi cục bộ tham chiếu tên cục bộ của hàm hiện tại (theo văn bản). Các chức năng bên ngoài, phạm vi cục bộ tham chiếu cùng một không gian tên với phạm vi toàn cầu. không gian tên của mô-đun. Định nghĩa lớp đặt một không gian tên khác trong phạm vi cục bộ

Điều quan trọng là phải nhận ra rằng phạm vi được xác định theo văn bản. phạm vi toàn cầu của một chức năng được xác định trong một mô-đun là không gian tên của mô-đun đó, bất kể chức năng được gọi từ đâu hoặc bằng bí danh nào. Mặt khác, việc tìm kiếm tên thực tế được thực hiện một cách linh hoạt, trong thời gian chạy — tuy nhiên, định nghĩa ngôn ngữ đang phát triển theo hướng phân giải tên tĩnh, tại thời điểm “biên dịch”, vì vậy đừng dựa vào độ phân giải tên động. (Thực tế, các biến cục bộ đã được xác định tĩnh. )

Một điều đặc biệt của Python là – nếu không có câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 3. Cái nhìn đầu tiên về lớp học¶

Các lớp giới thiệu một chút cú pháp mới, ba loại đối tượng mới và một số ngữ nghĩa mới

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 4. Nhận xét ngẫu nhiên¶

Nếu cùng một tên thuộc tính xảy ra trong cả một thực thể và trong một lớp, thì việc tra cứu thuộc tính sẽ ưu tiên thực thể đó

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các thuộc tính dữ liệu có thể được tham chiếu bởi các phương thức cũng như bởi những người dùng thông thường (“khách hàng”) của một đối tượng. Nói cách khác, các lớp không thể sử dụng để triển khai các kiểu dữ liệu trừu tượng thuần túy. Trên thực tế, không có gì trong Python có thể thực thi ẩn dữ liệu — tất cả đều dựa trên quy ước. (Mặt khác, việc triển khai Python, được viết bằng C, hoàn toàn có thể ẩn các chi tiết triển khai và kiểm soát quyền truy cập vào một đối tượng nếu cần; điều này có thể được sử dụng bởi các phần mở rộng cho Python được viết bằng C. )

Khách hàng nên sử dụng các thuộc tính dữ liệu một cách cẩn thận - khách hàng có thể làm rối tung các bất biến được duy trì bởi các phương thức bằng cách đóng dấu vào các thuộc tính dữ liệu của họ. Lưu ý rằng các máy khách có thể thêm các thuộc tính dữ liệu của riêng chúng vào một đối tượng thể hiện mà không ảnh hưởng đến tính hợp lệ của các phương thức, miễn là tránh xung đột về tên — một lần nữa, quy ước đặt tên có thể giúp bạn đỡ phải đau đầu hơn ở đây

Không có cách viết tắt để tham chiếu các thuộc tính dữ liệu (hoặc các phương thức khác. ) từ bên trong phương pháp. Tôi thấy rằng điều này thực sự làm tăng khả năng đọc của các phương pháp. không có khả năng nhầm lẫn giữa biến cục bộ và biến thể hiện khi lướt qua một phương thức

Thông thường, đối số đầu tiên của một phương thức được gọi là

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Bất kỳ đối tượng hàm nào là thuộc tính của lớp đều định nghĩa một phương thức cho các thể hiện của lớp đó. Không nhất thiết định nghĩa hàm phải được đính kèm theo văn bản trong định nghĩa lớp. gán một đối tượng hàm cho một biến cục bộ trong lớp cũng được. Ví dụ

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Bây giờ

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các phương thức có thể gọi các phương thức khác bằng cách sử dụng các thuộc tính phương thức của đối số

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các phương thức có thể tham chiếu các tên toàn cục giống như các hàm thông thường. Phạm vi toàn cầu được liên kết với một phương thức là mô-đun chứa định nghĩa của nó. (Một lớp không bao giờ được sử dụng như một phạm vi toàn cầu. ) Mặc dù người ta hiếm khi gặp lý do chính đáng để sử dụng dữ liệu toàn cầu trong một phương thức, nhưng có nhiều cách sử dụng hợp pháp phạm vi toàn cầu. đối với một điều, các hàm và mô-đun được nhập vào phạm vi toàn cầu có thể được sử dụng bởi các phương thức, cũng như các hàm và lớp được định nghĩa trong đó. Thông thường, lớp chứa phương thức tự nó được định nghĩa trong phạm vi toàn cục này, và trong phần tiếp theo, chúng ta sẽ tìm thấy một số lý do chính đáng khiến một phương thức muốn tham chiếu đến lớp của chính nó

Mỗi giá trị là một đối tượng và do đó có một lớp (còn được gọi là loại của nó). Nó được lưu trữ dưới dạng

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 5. Kế thừa¶

Tất nhiên, một tính năng ngôn ngữ sẽ không xứng với cái tên “đẳng cấp” nếu không hỗ trợ tính kế thừa. Cú pháp cho một định nghĩa lớp dẫn xuất trông như thế này

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Tên

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Việc thực thi định nghĩa lớp dẫn xuất tiến hành giống như đối với lớp cơ sở. Khi đối tượng lớp được xây dựng, lớp cơ sở được ghi nhớ. Điều này được sử dụng để giải quyết các tham chiếu thuộc tính. nếu không tìm thấy thuộc tính được yêu cầu trong lớp, quá trình tìm kiếm sẽ tiếp tục tìm trong lớp cơ sở. Quy tắc này được áp dụng đệ quy nếu bản thân lớp cơ sở được dẫn xuất từ ​​một số lớp khác

Không có gì đặc biệt về việc khởi tạo các lớp dẫn xuất.

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các lớp dẫn xuất có thể ghi đè các phương thức của các lớp cơ sở của chúng. Bởi vì các phương thức không có đặc quyền đặc biệt khi gọi các phương thức khác của cùng một đối tượng, nên một phương thức của lớp cơ sở gọi một phương thức khác được định nghĩa trong cùng một lớp cơ sở có thể sẽ gọi một phương thức của lớp dẫn xuất ghi đè lên nó. (Dành cho lập trình viên C++. tất cả các phương thức trong Python đều có hiệu quả

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Trên thực tế, một phương thức ghi đè trong lớp dẫn xuất có thể muốn mở rộng hơn là chỉ thay thế phương thức cùng tên của lớp cơ sở. Có một cách đơn giản để gọi trực tiếp phương thức của lớp cơ sở. chỉ cần gọi

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Python có hai hàm tích hợp hoạt động với tính kế thừa

• Sử dụng

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  605 để kiểm tra loại phiên bản.

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  606 sẽ chỉ là

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  607 nếu

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  608 là

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  609 hoặc một số lớp bắt nguồn từ

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  609

• Sử dụng

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  611 để kiểm tra tính kế thừa của lớp.

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  612 là

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  607 vì

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  614 là một lớp con của

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  609. Tuy nhiên,

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  616 là

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  617 vì

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  618 không phải là lớp con của

  class MyClass:
      """A simple example class"""
      i = 12345
  
      def f(self):
          return 'hello world'
  

  609

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 6. Biến riêng¶

Các biến thể hiện “Riêng tư” không thể truy cập được ngoại trừ từ bên trong một đối tượng không tồn tại trong Python. Tuy nhiên, có một quy ước được tuân theo bởi hầu hết mã Python. một tên bắt đầu bằng dấu gạch dưới (e. g.

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Vì có một trường hợp sử dụng hợp lệ cho các thành viên lớp-riêng (cụ thể là để tránh xung đột tên của các tên với các tên được xác định bởi các lớp con), nên có một số hỗ trợ hạn chế cho một cơ chế như vậy, được gọi là xáo trộn tên. Bất kỳ mã định danh nào có dạng

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Xáo trộn tên rất hữu ích để cho phép các lớp con ghi đè các phương thức mà không phá vỡ các cuộc gọi phương thức nội bộ. Ví dụ

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Ví dụ trên sẽ hoạt động ngay cả khi

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Lưu ý rằng các quy tắc xáo trộn được thiết kế chủ yếu để tránh tai nạn; . Điều này thậm chí có thể hữu ích trong các trường hợp đặc biệt, chẳng hạn như trong trình gỡ lỗi

Lưu ý rằng mã được chuyển đến

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 7. Tỷ lệ cược và Kết quả¶

Đôi khi sẽ rất hữu ích khi có một kiểu dữ liệu tương tự như Pascal “record” hoặc C “struct”, kết hợp một vài mục dữ liệu đã đặt tên lại với nhau. Một định nghĩa lớp trống sẽ làm tốt

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Thay vào đó, một đoạn mã Python mong đợi một kiểu dữ liệu trừu tượng cụ thể có thể được chuyển qua một lớp mô phỏng các phương thức của kiểu dữ liệu đó. Chẳng hạn, nếu bạn có một hàm định dạng một số dữ liệu từ một đối tượng tệp, bạn có thể định nghĩa một lớp bằng các phương thức

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Các đối tượng phương thức sơ thẩm cũng có các thuộc tính.

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 8. Trình lặp¶

Bây giờ bạn có thể nhận thấy rằng hầu hết các đối tượng vùng chứa có thể được lặp lại bằng cách sử dụng câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Phong cách truy cập này rõ ràng, ngắn gọn và thuận tiện. Việc sử dụng các trình lặp tràn ngập và thống nhất Python. Đằng sau hậu trường, câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Đã xem cơ chế đằng sau giao thức trình lặp, thật dễ dàng để thêm hành vi của trình lặp vào các lớp của bạn. Xác định một phương thức

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

9. 9. Máy phát điện¶

Trình tạo là một công cụ đơn giản và mạnh mẽ để tạo trình vòng lặp. Chúng được viết giống như các hàm thông thường nhưng sử dụng câu lệnh

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Bất cứ điều gì có thể được thực hiện với trình tạo cũng có thể được thực hiện với trình vòng lặp dựa trên lớp như được mô tả trong phần trước. Điều làm cho các trình tạo trở nên nhỏ gọn là các phương thức

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Một tính năng quan trọng khác là các biến cục bộ và trạng thái thực thi được lưu tự động giữa các lần gọi. Điều này làm cho hàm dễ viết hơn và rõ ràng hơn nhiều so với cách tiếp cận sử dụng các biến thể hiện như

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Ngoài việc tạo phương thức tự động và lưu trạng thái chương trình, khi các trình tạo kết thúc, chúng sẽ tự động tăng

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

9. 10. Biểu thức trình tạo¶

Một số trình tạo đơn giản có thể được mã hóa ngắn gọn dưới dạng biểu thức bằng cách sử dụng cú pháp tương tự như cách hiểu danh sách nhưng có dấu ngoặc đơn thay vì dấu ngoặc vuông. Các biểu thức này được thiết kế cho các tình huống mà trình tạo được sử dụng ngay lập tức bởi một hàm kèm theo. Các biểu thức trình tạo nhỏ gọn hơn nhưng kém linh hoạt hơn các định nghĩa trình tạo đầy đủ và có xu hướng thân thiện với bộ nhớ hơn so với việc hiểu danh sách tương đương

ví dụ

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

chú thích

Ngoại trừ một điều. Các đối tượng mô-đun có thuộc tính chỉ đọc bí mật được gọi là

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

Python có hỗ trợ tất cả các loại kế thừa không?

Python hỗ trợ bao nhiêu kế thừa?

Kế thừa nào không được hỗ trợ trong Python?

Python có hỗ trợ đa kế thừa không?