Gõ python có thể gọi được là gì?

Nhập động

Python là một ngôn ngữ được gõ động. Điều này có nghĩa là trình thông dịch Python chỉ kiểm tra kiểu khi mã chạy và kiểu của một biến được phép thay đổi trong suốt thời gian tồn tại của nó. Các ví dụ giả sau đây chứng minh rằng Python có kiểu gõ động

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Trong ví dụ đầu tiên, nhánh

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Tiếp theo, hãy xem liệu các biến có thể thay đổi loại không

>>>

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Nhập tĩnh

Ngược lại với gõ động là gõ tĩnh. Kiểm tra loại tĩnh được thực hiện mà không cần chạy chương trình. Trong hầu hết các ngôn ngữ được nhập tĩnh, chẳng hạn như C và Java, điều này được thực hiện khi chương trình của bạn được biên dịch

Với kiểu gõ tĩnh, các biến thường không được phép thay đổi loại, mặc dù có thể tồn tại các cơ chế chuyển một biến sang một loại khác

Hãy xem một ví dụ nhanh từ một ngôn ngữ được gõ tĩnh. Hãy xem xét đoạn mã Java sau

String thing;
thing = "Hello";

Dòng đầu tiên tuyên bố rằng tên biến

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Python sẽ luôn là một ngôn ngữ được gõ động. Tuy nhiên, PEP 484 đã giới thiệu các gợi ý về kiểu, cho phép thực hiện kiểm tra kiểu tĩnh của mã Python

Không giống như cách các loại hoạt động trong hầu hết các ngôn ngữ được nhập tĩnh khác, bản thân các gợi ý nhập không khiến Python thực thi các loại. Đúng như tên gọi, gợi ý nhập chỉ đề xuất các loại. Có những công cụ khác mà bạn sẽ thấy sau, thực hiện kiểm tra kiểu tĩnh bằng gợi ý kiểu

gõ vịt

Một thuật ngữ khác thường được sử dụng khi nói về Python là duck typing. Biệt danh này xuất phát từ câu "nếu nó đi như vịt và kêu quạc quạc như vịt, thì nó phải là vịt" [hoặc bất kỳ biến thể nào của nó]

Gõ vịt là một khái niệm liên quan đến gõ động, trong đó loại hoặc lớp của một đối tượng ít quan trọng hơn các phương thức mà nó định nghĩa. Sử dụng cách gõ vịt bạn hoàn toàn không kiểm tra các loại. Thay vào đó, bạn kiểm tra sự hiện diện của một phương thức hoặc thuộc tính nhất định

Ví dụ, bạn có thể gọi

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>>

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Lưu ý rằng cuộc gọi đến _____120 cho giá trị trả về của phương thức _______121. Trên thực tế, việc triển khai

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Để gọi

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Kiểu gõ vịt được hỗ trợ phần nào khi thực hiện kiểm tra kiểu tĩnh của mã Python, sử dụng kiểu con cấu trúc. Bạn sẽ tìm hiểu thêm về cách gõ vịt sau

Chú thích chức năng

Đối với các hàm, bạn có thể chú thích đối số và giá trị trả về. Điều này được thực hiện như sau

String thing;
thing = "Hello";

Đối với các đối số, cú pháp là

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Ví dụ đơn giản sau đây thêm chú thích cho hàm tính chu vi hình tròn

String thing;
thing = "Hello";

Khi chạy mã, bạn cũng có thể kiểm tra các chú thích. Chúng được lưu trữ trong một thuộc tính

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>>

String thing;
thing = "Hello";

Đôi khi bạn có thể bối rối về cách Mypy diễn giải các gợi ý loại của bạn. Đối với những trường hợp đó, có các biểu thức Mypy đặc biệt.

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Tiếp theo, chạy mã này thông qua Mypy

String thing;
thing = "Hello";

Ngay cả khi không có bất kỳ chú thích nào, Mypy đã suy ra chính xác các loại của

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Ghi chú. Các biểu thức tiết lộ chỉ có nghĩa là một công cụ giúp bạn thêm các loại và gỡ lỗi các gợi ý về loại của bạn. Nếu bạn cố chạy tệp

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Nếu Mypy nói rằng "Tên '

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Chú thích biến

Trong định nghĩa của

String thing;
thing = "Hello";

Tuy nhiên, đôi khi trình kiểm tra loại cũng cần trợ giúp trong việc tìm ra các loại biến. Các chú thích biến được định nghĩa trong PEP 526 và được giới thiệu trong Python 3. 6. Cú pháp giống như đối với chú thích đối số hàm

String thing;
thing = "Hello";

Biến

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Ghi chú. Trình kiểm tra loại tĩnh có nhiều khả năng phát hiện ra rằng

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Chú thích của các biến được lưu trữ trong từ điển

String thing;
thing = "Hello";

>>>

String thing;
thing = "Hello";

Bạn được phép chú thích một biến mà không cần đặt giá trị cho nó. Điều này thêm chú thích vào từ điển

String thing;
thing = "Hello";

>>>

String thing;
thing = "Hello";

Vì không có giá trị nào được gán cho

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Loại Nhận xét

Như đã đề cập, các chú thích đã được giới thiệu trong Python 3 và chúng chưa được nhập vào Python 2. Điều này có nghĩa là nếu bạn đang viết mã cần hỗ trợ Python cũ, thì bạn không thể sử dụng chú thích

Thay vào đó, bạn có thể sử dụng loại bình luận. Đây là những nhận xét được định dạng đặc biệt có thể được sử dụng để thêm gợi ý loại tương thích với mã cũ hơn. Để thêm nhận xét loại vào một chức năng, bạn làm như thế này

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Các nhận xét loại chỉ là nhận xét, vì vậy chúng có thể được sử dụng trong bất kỳ phiên bản Python nào

Nhận xét loại được xử lý trực tiếp bởi trình kiểm tra loại, vì vậy những loại này không có trong từ điển

String thing;
thing = "Hello";

>>>

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Một nhận xét loại phải bắt đầu bằng chữ

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Bạn cũng được phép viết mỗi đối số trên một dòng riêng biệt với chú thích riêng của nó

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Chạy ví dụ thông qua Python và Mypy

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Nếu bạn gặp lỗi, chẳng hạn nếu bạn tình cờ gọi cho

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Bạn cũng có thể thêm nhận xét kiểu vào biến. Điều này được thực hiện tương tự như cách bạn thêm nhận xét loại vào đối số

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Trong ví dụ này,

String thing;
thing = "Hello";

Vì vậy, Nhập Chú thích hoặc Nhập Nhận xét?

Bạn có nên sử dụng chú thích hoặc nhập nhận xét khi thêm gợi ý loại vào mã của riêng mình không? . Sử dụng chú thích nếu bạn có thể, sử dụng nhận xét loại nếu bạn phải

Chú thích cung cấp cú pháp rõ ràng hơn để giữ thông tin loại gần với mã của bạn hơn. Chúng cũng là cách viết gợi ý loại chính thức được đề xuất và sẽ được phát triển thêm cũng như duy trì đúng cách trong tương lai

Loại nhận xét dài dòng hơn và có thể xung đột với các loại nhận xét khác trong mã của bạn như chỉ thị kẻ nói dối. Tuy nhiên, chúng có thể được sử dụng trong các cơ sở mã không hỗ trợ chú thích

Ngoài ra còn có tùy chọn ẩn số ba. tập tin sơ khai. Bạn sẽ tìm hiểu về những điều này sau, khi chúng ta thảo luận về việc thêm các loại vào thư viện của bên thứ ba

Các tệp sơ khai sẽ hoạt động trong mọi phiên bản Python, với chi phí phải duy trì một bộ tệp thứ hai. Nói chung, bạn chỉ muốn sử dụng các tệp sơ khai nếu bạn không thể thay đổi mã nguồn ban đầu

Ví dụ. Một cỗ bài

Ví dụ sau đây cho thấy việc triển khai một bộ bài thông thường [tiếng Pháp]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Mỗi thẻ được biểu diễn dưới dạng một bộ chuỗi biểu thị chất và thứ hạng. Bộ bài được thể hiện dưới dạng một danh sách các quân bài.

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Cuối cùng,

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Bạn sẽ thấy cách mở rộng ví dụ này thành một trò chơi thú vị hơn khi chúng ta tiếp tục

Trình tự và ánh xạ

Hãy thêm gợi ý loại vào trò chơi bài của chúng tôi. Nói cách khác, hãy chú thích các hàm

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Với các loại đơn giản như

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>>

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Với các loại hỗn hợp, bạn được phép làm tương tự

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Tuy nhiên, điều này không thực sự nói lên toàn bộ câu chuyện. Các loại

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Thay vào đó, bạn nên sử dụng các loại đặc biệt được xác định trong mô-đun

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Lưu ý rằng mỗi loại trong số này bắt đầu bằng chữ in hoa và tất cả chúng đều sử dụng dấu ngoặc vuông để xác định loại mục

• String thing;
  thing = "Hello";
  

  38 là một danh sách các chuỗi

• String thing;
  thing = "Hello";
  

  39 là một bộ 3 bao gồm ba số nguyên

• String thing;
  thing = "Hello";
  

  40 là một chuỗi từ điển ánh xạ tới các giá trị Boolean

Mô-đun

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Hãy trở lại với trò chơi bài. Một thẻ được đại diện bởi một bộ gồm hai chuỗi. Bạn có thể viết cái này là

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Ngoài giá trị trả về, bạn cũng đã thêm loại

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Ghi chú. Tuples và danh sách được chú thích khác nhau

Bộ dữ liệu là một chuỗi bất biến và thường bao gồm một số lượng cố định các phần tử có thể được nhập khác nhau. Ví dụ: chúng tôi đại diện cho một thẻ dưới dạng một bộ phù hợp và xếp hạng. Nói chung, bạn viết

String thing;
thing = "Hello";

Danh sách là một dãy có thể thay đổi và thường bao gồm một số phần tử cùng loại không xác định, ví dụ: danh sách các thẻ. Cho dù có bao nhiêu phần tử trong danh sách thì chỉ có một loại trong chú thích.

String thing;
thing = "Hello";

Trong nhiều trường hợp, các chức năng của bạn sẽ mong đợi một số loại trình tự và không thực sự quan tâm đó là danh sách hay bộ dữ liệu. In these cases you should use

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Sử dụng

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Nhập bí danh

The type hints might become quite oblique when working with nested types like the deck of cards. Bạn có thể cần phải nhìn chằm chằm vào

String thing;
thing = "Hello";

Now consider how you would annotate

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

That’s just terrible

Recall that type annotations are regular Python expressions. That means that you can define your own type aliases by assigning them to new variables. Ví dụ, bạn có thể tạo bí danh loại

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Sử dụng các bí danh này, các chú thích của

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Bí danh loại rất tốt để làm cho mã của bạn và ý định của nó rõ ràng hơn. Đồng thời, những bí danh này có thể được kiểm tra để xem những gì chúng đại diện

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Lưu ý rằng khi in

String thing;
thing = "Hello";

Các hàm không có giá trị trả về

Bạn có thể biết rằng các hàm không có trả về rõ ràng vẫn trả về

String thing;
thing = "Hello";

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Mặc dù các chức năng như vậy về mặt kỹ thuật trả về một cái gì đó, nhưng giá trị trả về đó không hữu ích. Bạn nên thêm gợi ý loại bằng cách sử dụng

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Các chú thích giúp phát hiện các loại lỗi tinh vi mà bạn đang cố gắng sử dụng một giá trị trả về vô nghĩa. Mypy sẽ cung cấp cho bạn một cảnh báo hữu ích

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Lưu ý rằng rõ ràng về một hàm không trả về bất cứ thứ gì khác với việc không thêm gợi ý kiểu về giá trị trả về

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Trong trường hợp sau này, Mypy không có thông tin về giá trị trả về nên nó sẽ không tạo ra bất kỳ cảnh báo nào

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Trong một trường hợp kỳ lạ hơn, lưu ý rằng bạn cũng có thể chú thích các chức năng không bao giờ được mong đợi sẽ trở lại bình thường. Điều này được thực hiện bằng cách sử dụng

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Vì

String thing;
thing = "Hello";

Ví dụ. Chơi một số thẻ

Hãy quay lại ví dụ về trò chơi bài của chúng tôi. Trong phiên bản thứ hai này của trò chơi, chúng tôi chia bài cho mỗi người chơi như trước đây. Sau đó, một người chơi bắt đầu được chọn và những người chơi lần lượt chơi bài của họ. Tuy nhiên, thực sự không có bất kỳ quy tắc nào trong trò chơi, vì vậy người chơi sẽ chỉ chơi các quân bài ngẫu nhiên.

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Lưu ý rằng ngoài việc thay đổi

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Trong ví dụ này, người chơi

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Loại

String thing;
thing = "Hello";

79

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Điều này ít nhiều có nghĩa là những gì nó nói.

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Mặc dù Mypy sẽ suy luận chính xác rằng

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Bạn sẽ sớm thấy một cách tốt hơn. Tuy nhiên, trước tiên, chúng ta hãy có một cái nhìn lý thuyết hơn về hệ thống kiểu Python và vai trò đặc biệt của

String thing;
thing = "Hello";

tiểu loại

Một khái niệm quan trọng là các kiểu con. Chính thức, chúng tôi nói rằng một loại

String thing;
thing = "Hello";

String thing;
thing = "Hello";

• Mọi giá trị từ

  String thing;
  thing = "Hello";
  

  87 cũng nằm trong tập hợp các giá trị của loại

  String thing;
  thing = "Hello";
  

  88
• Mọi chức năng từ loại

  String thing;
  thing = "Hello";
  

  88 cũng nằm trong tập hợp các chức năng của loại

  String thing;
  thing = "Hello";
  

  87

Hai điều kiện này đảm bảo rằng ngay cả khi loại

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Để có một ví dụ cụ thể, hãy xem xét

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>>

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Vì 0 và 1 đều là số nguyên nên điều kiện đầu tiên thỏa mãn. Ở trên, bạn có thể thấy rằng Booleans có thể được cộng lại với nhau, nhưng chúng cũng có thể làm bất cứ điều gì khác mà số nguyên có thể. Đây là điều kiện thứ hai ở trên. Nói cách khác,

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Tầm quan trọng của các kiểu con là một kiểu con luôn có thể giả vờ là siêu kiểu của nó. Chẳng hạn, loại mã sau đây kiểm tra là chính xác

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Các kiểu con có phần nào liên quan đến các lớp con. Trên thực tế, tất cả các lớp con tương ứng với các kiểu con và

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Covariant, Contravariant, và Invariant

What happens when you use subtypes inside composite types? For instance, is

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

• >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  716 là hiệp phương sai. Điều này có nghĩa là nó duy trì phân cấp loại của các loại mục của nó.

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  714 is a subtype of

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  715 because

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  39 is a subtype of

  String thing;
  thing = "Hello";
  

  35

• >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  721 là bất biến. Các kiểu bất biến không đảm bảo về các kiểu con. Mặc dù tất cả các giá trị của

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  722 đều là giá trị của

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  723, nhưng bạn có thể nối thêm

  String thing;
  thing = "Hello";
  

  35 vào

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  723 chứ không phải vào

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  722. Nói cách khác, điều kiện thứ hai cho các kiểu con không thỏa mãn và

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  722 không phải là kiểu con của

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  723

• >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  729 is contravariant in its arguments. Điều này có nghĩa là nó đảo ngược hệ thống phân cấp loại. You will see how

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  729 works later, but for now think of

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  731 as a function with its only argument being of type

  String thing;
  thing = "Hello";
  

  87. Một ví dụ về

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  733 là hàm

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  734 được xác định ở trên. Ngược lại có nghĩa là nếu một chức năng hoạt động trên

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  39 được mong đợi, thì một chức năng hoạt động trên

  String thing;
  thing = "Hello";
  

  35 sẽ được chấp nhận

Nói chung, bạn không cần phải giữ những biểu thức này thẳng. Tuy nhiên, bạn nên lưu ý rằng các kiểu con và kiểu tổng hợp có thể không đơn giản và trực quan

Nhập dần dần và các loại nhất quán

Earlier we mentioned that Python supports gradual typing, where you can gradually add type hints to your Python code. Gradual typing is essentially made possible by the

String thing;
thing = "Hello";

Somehow

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

Loại

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

The type checker only complains about inconsistent types. The takeaway is therefore that you will never see type errors arising from the

String thing;
thing = "Hello";

This means that you can use

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Do remember, though, if you use

String thing;
thing = "Hello";

Type Variables

A type variable is a special variable that can take on any type, depending on the situation

Let’s create a type variable that will effectively encapsulate the behavior of

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

A type variable must be defined using

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Consider a few other examples

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

The first two examples should have type

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

As you’ve already seen

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Note that none of these examples raised a type error. Is there a way to tell the type checker that

String thing;
thing = "Hello";

You can constrain type variables by listing the acceptable types

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Now

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Also note that in the second example the type is considered

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

String thing;
thing = "Hello";

In our card game we want to restrict

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

We briefly mentioned that

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

String thing;
thing = "Hello";

Duck Types and Protocols

Recall the following example from the introduction

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

The answer hides behind the academic sounding term structural subtyping. One way to categorize type systems is by whether they are nominal or structural

• In a nominal system, comparisons between types are based on names and declarations. The Python type system is mostly nominal, where an

  String thing;
  thing = "Hello";
  

  35 can be used in place of a

  String thing;
  thing = "Hello";
  

  07 because of their subtype relationship

• In a structural system, comparisons between types are based on structure. You could define a structural type

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  793 that includes all instances that define

  >>> thing = "Hello"
  >>> type[thing]
  
  
  >>> thing = 28.1
  >>> type[thing]
  
  

  21, irrespective of their nominal type

There is ongoing work to bring a full-fledged structural type system to Python through PEP 544 which aims at adding a concept called protocols. Most of PEP 544 is already implemented in Mypy though

A protocol specifies one or more methods that must be implemented. For example, all classes defining

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Other examples of protocols defined in the

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

You can also define your own protocols. This is done by inheriting from

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

At the time of writing the support for self-defined protocols is still experimental and only available through the

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

The

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

108 Type

A common pattern in Python is to use

String thing;
thing = "Hello";

In the card example, the

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

The challenge this creates for type hinting is that in general

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

String thing;
thing = "Hello";

In order to annotate such arguments you can use the

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

The

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Lưu ý rằng khi sử dụng

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Mypy tells you that you have not taken care of the case where

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Note. Việc sử dụng

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Nếu bạn không muốn Mypy đưa ra giả định này, bạn có thể tắt nó bằng tùy chọn dòng lệnh

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

Ví dụ. Mục tiêu] của trò chơi

Hãy viết lại trò chơi bài để hướng đối tượng hơn. Điều này sẽ cho phép chúng ta thảo luận về cách chú thích đúng các lớp và phương thức

Một bản dịch ít nhiều trực tiếp trò chơi bài của chúng tôi thành mã sử dụng các lớp cho

String thing;
thing = "Hello";

String thing;
thing = "Hello";

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]

Bây giờ hãy thêm các loại vào mã này

Nhập gợi ý cho phương pháp

Trước hết, các gợi ý kiểu cho các phương thức hoạt động giống như các gợi ý kiểu cho các hàm. Sự khác biệt duy nhất là đối số

>>> if False:
..     1 + "two"  # This line never runs, so no TypeError is raised
.. else:
..     1 + 2
...
3

>>> 1 + "two"  # Now this is type checked, and a TypeError is raised
TypeError: unsupported operand type[s] for +: 'int' and 'str'

String thing;
thing = "Hello";

>>> thing = "Hello"
>>> type[thing]


>>> thing = 28.1
>>> type[thing]