Hướng dẫn can you define types in python? - bạn có thể định nghĩa các loại trong python không?
Tôi sử dụng các loại dữ liệu để khẳng định các giá trị duy nhất trong Python 2 và 3. Nếu không, tôi không thể làm cho chúng hoạt động như các loại STR hoặc INT. Tuy nhiên, nếu bạn cần kiểm tra một giá trị có thể có bất kỳ loại nào ngoại trừ một loại cụ thể, thì chúng rất hữu ích và làm cho mã đọc tốt hơn.except a specific one, then they are mighty useful and make code read better. Show
Đối tượng kế thừa sẽ tạo một loại trong Python.
Ví dụ Sử dụng: Bạn có thể muốn lọc có điều kiện hoặc in một giá trị bằng cách sử dụng một điều kiện hoặc trình xử lý hàm để sử dụng một loại làm giá trị mặc định sẽ hữu ích.: you might want to conditionally filter or print a value using a condition or a function handler so using a type as a default value will be useful.
Đầu ra
Nếu 27 là trường hợp sử dụng hoàn hảo cho việc này vì nó an toàn hơn và đọc tốt. Tôi cũng đã sử dụng chúng trong các enum mà không thực sự là một điều trong Python. Để có được loại biến trong Python, bạn có thể sử dụng hàm loại tích hợp (). Trong Python, mọi thứ đều là một đối tượng. Vì vậy, khi bạn sử dụng hàm loại () để in loại giá trị được lưu trữ trong một biến cho bàn điều khiển, nó sẽ trả về loại lớp của đối tượng.Chỉ định một loại biến Có thể có những lúc bạn muốn chỉ định một loại trên một biến. Điều này có thể được thực hiện với đúc. Python là một ngôn ngữ định hướng đối tượng và do đó, nó sử dụng các lớp để xác định các loại dữ liệu, bao gồm cả các loại nguyên thủy của nó.
Str () - Xây dựng một chuỗi từ nhiều loại dữ liệu khác nhau, bao gồm cả chuỗi, chữ số nguyên và nghĩa đenIntegers: Thí dụ x = int (1) & nbsp; & nbsp; # x sẽ là 1 y = int (2.8) # y sẽ là 2 z = int ("3") # z sẽ là 3 Str () - Xây dựng một chuỗi từ nhiều loại dữ liệu khác nhau, bao gồm cả chuỗi, chữ số nguyên và nghĩa đenFloats: Thí dụ x = int (1) & nbsp; & nbsp; # x sẽ là 1 y = int (2.8) # y sẽ là 2 z = int ("3") # z sẽ là 3 Str () - Xây dựng một chuỗi từ nhiều loại dữ liệu khác nhau, bao gồm cả chuỗi, chữ số nguyên và nghĩa đenStrings: Thí dụ x = int (1) & nbsp; & nbsp; # x sẽ là 1 y = int (2.8) # y sẽ là 2 z = int ("3") # z sẽ là 3 Để có được loại biến trong Python, bạn có thể sử dụng hàm loại tích hợp (). Trong Python, mọi thứ đều là một đối tượng. Vì vậy, khi bạn sử dụng hàm loại () để in loại giá trị được lưu trữ trong một biến cho bàn điều khiển, nó sẽ trả về loại lớp của đối tượng. Mới trong phiên bản 3.5. Lib/typing.py Ghi chú Mã nguồn: lib/gõ.py Thời gian chạy Python không thực thi chức năng và chú thích loại biến. Chúng có thể được sử dụng bởi các công cụ của bên thứ ba như trình kiểm tra loại, IDE, linter, v.v.PEP 484. For a simplified introduction to type hints, see PEP 483. Mô -đun này cung cấp hỗ trợ thời gian chạy cho các gợi ý loại. Hỗ trợ cơ bản nhất bao gồm các loại 28, 29, 30, 31 và 32. Để biết thông số kỹ thuật đầy đủ, vui lòng xem PEP 484. Để có phần giới thiệu đơn giản về các gợi ý loại, xem PEP 483.def greeting(name: str) -> str: return 'Hello ' + name Hàm bên dưới lấy và trả về một chuỗi và được chú thích như sau: Trong hàm 33, đối số 34 dự kiến sẽ thuộc loại 35 và loại trả về 35. Các kiểu con được chấp nhận là đối số.Các tính năng mới thường được thêm vào mô -đun 37. Gói typing_extensions cung cấp các bản sao của các tính năng mới này cho các phiên bản Python cũ hơn.Để biết tóm tắt các tính năng không dùng nữa và dòng thời gian không dùng nữa, vui lòng xem dòng thời gian không dùng nữa của các tính năng chính. Xem thêm Tài liệu tại https://typing.readthedocs.io/ làm tài liệu tham khảo hữu ích cho các tính năng hệ thống loại, gõ các công cụ liên quan hữu ích và gõ các thực tiễn tốt nhất.Peps¶ có liên quanPEP 484 and PEP 483, a number of PEPs have modified and enhanced Python’s framework for type annotations. These include:
Gõ bí danhMột bí danh loại được xác định bằng cách gán loại cho bí danh. Trong ví dụ này, 60 và 61 sẽ được coi là từ đồng nghĩa có thể hoán đổi cho nhau:Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4]) Bí danh loại rất hữu ích để đơn giản hóa chữ ký loại phức. Ví dụ: from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ... Lưu ý rằng 62 dưới dạng gợi ý loại là một trường hợp đặc biệt và được thay thế bằng 63.
Kiểu mới¶Sử dụng Trình trợ giúp 64 để tạo các loại khác biệt:from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313) Trình kiểm tra loại tĩnh sẽ xử lý loại mới như thể nó là một lớp con của loại ban đầu. Điều này rất hữu ích trong việc giúp bắt các lỗi logic: def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1) Bạn vẫn có thể thực hiện tất cả các hoạt động 65 trên một biến của loại 66, nhưng kết quả sẽ luôn luôn thuộc loại 65. Điều này cho phép bạn vượt qua trong một 66 bất cứ nơi nào có thể mong đợi 65, nhưng sẽ ngăn bạn vô tình tạo ra 66 theo cách không hợp lệ:# 'output' is of type 'int', not 'UserId' output = UserId(23413) + UserId(54341) Lưu ý rằng các kiểm tra này chỉ được thực thi bởi trình kiểm tra loại tĩnh. Trong thời gian chạy, câu lệnh 71 sẽ biến 72 có thể gọi được ngay lập tức trả về bất kỳ tham số nào bạn vượt qua. Điều đó có nghĩa là biểu thức 73 không tạo ra một lớp mới hoặc giới thiệu nhiều chi phí vượt ra ngoài cuộc gọi chức năng thông thường.Chính xác hơn, biểu thức 74 luôn đúng khi chạy.Nó không hợp lệ khi tạo một loại phụ của 72:from typing import NewType UserId = NewType('UserId', int) # Fails at runtime and does not pass type checking class AdminUserId(UserId): pass Tuy nhiên, có thể tạo ra một 64 dựa trên một ____ ____ ____ ____ ____164: 0và đánh máy cho 78 sẽ hoạt động như mong đợi.Xem PEP 484 để biết thêm chi tiết.PEP 484 for more details. Ghi chú Hãy nhớ lại rằng việc sử dụng một bí danh loại tuyên bố hai loại tương đương với nhau. Thực hiện 79 sẽ làm cho trình kiểm tra loại tĩnh điều trị 80 là chính xác tương đương với 81 trong mọi trường hợp. Điều này rất hữu ích khi bạn muốn đơn giản hóa chữ ký loại phức tạp.Ngược lại, 64 tuyên bố một loại là một loại phụ của loại khác. Thực hiện 83 sẽ làm cho trình kiểm tra loại tĩnh xử lý 72 dưới dạng lớp con của 81, có nghĩa là giá trị của loại 81 không thể được sử dụng ở những nơi dự kiến giá trị của loại 72. Điều này rất hữu ích khi bạn muốn ngăn chặn các lỗi logic với chi phí thời gian chạy tối thiểu.Mới trong phiên bản 3.5.2. Đã thay đổi trong phiên bản 3.10: 64 is now a class rather than a function. There is some additional runtime cost when calling 64 over a regular function. However, this cost will be reduced in 3.11.0.Gọi là có thể gọi đượcCác khung mong đợi các chức năng gọi lại của chữ ký cụ thể có thể được loại gợi ý bằng cách sử dụng 90.Ví dụ: 1Có thể khai báo loại trả về của một cuộc gọi có thể gọi mà không chỉ định chữ ký cuộc gọi bằng cách thay thế một dấu chấm lửng theo nghĩa đen cho danh sách các đối số trong loại gợi ý: 91.Các thiết bị gọi lấy các thiết bị gọi khác làm đối số có thể chỉ ra rằng các loại tham số của chúng phụ thuộc vào nhau bằng cách sử dụng 50. Ngoài ra, nếu có thể gọi được thêm hoặc xóa các đối số khỏi các loại gọi khác, toán tử 51 có thể được sử dụng. Họ lần lượt nhận dạng 94 và 95.Thuốc generics;Vì thông tin loại về các đối tượng được giữ trong các container không thể được suy ra tĩnh một cách chung, nên các lớp cơ sở trừu tượng đã được mở rộng để hỗ trợ đăng ký để biểu thị các loại dự kiến cho các yếu tố container. 2Generics có thể được tham số hóa bằng cách sử dụng một nhà máy có sẵn trong việc gõ gọi là 31. 3Các loại chung do người dùng xác địnhMột lớp do người dùng xác định có thể được định nghĩa là một lớp chung. 4 97 Là một lớp cơ sở định nghĩa rằng lớp 98 lấy một tham số loại duy nhất 99. Điều này cũng làm cho 99 có giá trị như một loại trong cơ thể lớp.Lớp cơ sở 32 xác định 02 để 03 hợp lệ dưới dạng loại: 5Một loại chung có thể có bất kỳ số lượng biến loại. Tất cả các loại của 31 đều được cho phép làm tham số cho một loại chung: 6Mỗi đối số biến loại thành 32 phải khác biệt. Điều này không hợp lệ: 7Bạn có thể sử dụng nhiều kế thừa với 32: 8Khi kế thừa từ các lớp chung, một số biến loại có thể được sửa: 9Trong trường hợp này 07 có một tham số duy nhất, 99.Sử dụng một lớp chung mà không chỉ định các tham số loại giả định 28 cho mỗi vị trí. Trong ví dụ sau, 10 không chung chung mà là kế thừa ngầm từ 11: 0Bí danh loại chung được xác định của người dùng cũng được hỗ trợ. Ví dụ: 1Đã thay đổi trong phiên bản 3.7: 32 no longer has a custom metaclass.Generics do người dùng xác định cho các biểu thức tham số cũng được hỗ trợ thông qua các biến đặc tả tham số ở dạng 13. Hành vi phù hợp với các biến loại, được mô tả ở trên là các biến đặc tả tham số được coi bởi mô -đun gõ là một biến loại chuyên dụng. Một ngoại lệ cho điều này là một danh sách các loại có thể được sử dụng để thay thế một 50: 2Hơn nữa, một chung chỉ có một biến đặc tả tham số sẽ chấp nhận danh sách tham số trong các biểu mẫu 15 và cả 16 vì lý do thẩm mỹ. Trong nội bộ, cái sau được chuyển đổi thành cái trước, vì vậy những điều sau đây là tương đương: 3Xin lưu ý rằng các chất generic với 50 có thể không đúng 18 sau khi thay thế trong một số trường hợp vì chúng được dự định chủ yếu để kiểm tra loại tĩnh.Đã thay đổi trong phiên bản 3.10: 32 can now be parameterized over parameter expressions. See 50 and PEP 612 for more details.
Một lớp chung do người dùng xác định có thể có ABC như các lớp cơ sở mà không có xung đột metaclass. Các metaclass chung không được hỗ trợ. Kết quả của việc chung hóa tham số hóa được lưu trữ và hầu hết các loại trong mô -đun gõ đều có thể băm và có thể so sánh cho sự bình đẳng. Loại from __future__ import print_function # make python2/3 compatible class unset(object): pass def some_func(a,b, show_if=unset): result = a + b ## just return it if show_if is unset: return result ## handle show_if to conditionally output something if hasattr(show_if,'__call__'): if show_if(result): print( "show_if %s = %s" % ( show_if.__name__ , result )) elif show_if: print(show_if, " condition met ", result) return result print("Are > 5)") for i in range(10): result = some_func(i,2, show_if= i>5 ) def is_even(val): return not val % 2 print("Are even") for i in range(10): result = some_func(i,2, show_if= is_even ) 28Một loại đặc biệt là 28. Một trình kiểm tra loại tĩnh sẽ coi mọi loại là tương thích với 28 và 28 là tương thích với mọi loại.Điều này có nghĩa là có thể thực hiện bất kỳ hoạt động hoặc phương thức gọi trên giá trị của loại 28 và gán nó cho bất kỳ biến nào: 4Lưu ý rằng không có kiểm tra loại nào được thực hiện khi gán giá trị loại 28 cho loại chính xác hơn. Ví dụ: Trình kiểm tra loại tĩnh đã không báo cáo lỗi khi gán 27 cho 28 mặc dù 28 đã được tuyên bố là loại 35 và nhận được giá trị 65 khi chạy!Hơn nữa, tất cả các chức năng mà không có loại trả về hoặc loại tham số sẽ mặc định sử dụng 28: 5Hành vi này cho phép 28 được sử dụng như một cửa thoát hiểm khi bạn cần trộn mã được đánh máy động và thống kê.Tương phản hành vi của 28 với hành vi của 35. Tương tự như 28, mọi loại là một loại phụ của 35. Tuy nhiên, không giống như 28, điều ngược lại không đúng: 35 không phải là một kiểu con của mọi loại khác.Điều đó có nghĩa là khi loại giá trị là 35, trình kiểm tra loại sẽ từ chối hầu hết tất cả các hoạt động trên đó và gán nó cho một biến (hoặc sử dụng nó làm giá trị trả về) của một loại chuyên dụng hơn là lỗi loại. Ví dụ: 6Sử dụng 35 để chỉ ra rằng giá trị có thể là bất kỳ loại nào theo cách kiểu an toàn. Sử dụng 28 để chỉ ra rằng một giá trị được gõ động.Danh nghĩa so với phân nhóm cấu trúcBan đầu PEP 484 xác định hệ thống loại tĩnh Python là sử dụng tiểu mục danh nghĩa. Điều này có nghĩa là một lớp 43 được cho phép trong đó một lớp 44 được mong đợi nếu và chỉ khi 43 là một lớp con của 44.PEP 484 defined the Python static type system as using nominal subtyping. This means that a class 43 is allowed where a class 44 is expected if and only if 43 is a subclass of 44.Yêu cầu này trước đây cũng áp dụng cho các lớp cơ sở trừu tượng, chẳng hạn như 47. Vấn đề với phương pháp này là một lớp phải được đánh dấu rõ ràng để hỗ trợ họ, điều này không có âm thanh và không giống như những gì người ta thường làm trong mã python được gõ động một cách tự động. Ví dụ, điều này phù hợp với PEP 484:PEP 484: 7PEP 544 cho phép giải quyết vấn đề này bằng cách cho phép người dùng viết mã trên mà không có các lớp cơ sở rõ ràng trong định nghĩa lớp, cho phép 48 to be implicitly considered a subtype of both 49 and 50 by static type checkers. This
is known as structural subtyping (or static duck-typing): 8Hơn nữa, bằng cách phân lớp một lớp đặc biệt 39, người dùng có thể xác định các giao thức tùy chỉnh mới để thưởng thức hoàn toàn phân nhóm cấu trúc (xem các ví dụ bên dưới).Nội dung mô -đunCác mô -đun xác định các lớp, chức năng và trang trí sau đây. Ghi chú Mô-đun này xác định một số loại là các lớp con của các lớp thư viện tiêu chuẩn có sẵn cũng mở rộng 32 để hỗ trợ các biến loại bên trong 53. Các loại này trở nên dư thừa trong Python 3.9 khi các lớp có sẵn tương ứng được tăng cường để hỗ trợ 53.Các loại dự phòng không được chấp nhận kể từ Python 3.9 nhưng không có cảnh báo phản đối nào sẽ được đưa ra bởi thông dịch viên. Dự kiến các trình kiểm tra loại sẽ gắn cờ các loại không dùng nữa khi chương trình được kiểm tra nhắm mục tiêu Python 3.9 hoặc mới hơn. Các loại không dùng sẽ được xóa khỏi mô -đun 37 trong phiên bản Python đầu tiên được phát hành 5 năm sau khi phát hành Python 3.9.0. Xem chi tiết trong PEP 585, Generics Generics trong các bộ sưu tập tiêu chuẩn.PEP 585—Type Hinting Generics In Standard Collections.Đặc biệt gõ nguyên thủyCác loại đặc biệtChúng có thể được sử dụng làm loại trong các chú thích và không hỗ trợ 53.
gõ.Any¶Loại đặc biệt chỉ ra một loại không bị ràng buộc.
Đã thay đổi trong phiên bản 3.11: 28 can now be used as a base class. This can be useful for avoiding type checker errors with classes that can duck type anywhere or are highly dynamic. Gõ.LiteralString¶Loại đặc biệt chỉ bao gồm các chuỗi theo nghĩa đen. Một chuỗi theo nghĩa đen tương thích với 58, như một 58 khác, nhưng một đối tượng được gõ chỉ là 35 thì không. Một chuỗi được tạo bằng cách soạn thảo các đối tượng gy ____ 158 cũng được chấp nhận dưới dạng 58.
Example: 9Điều này rất hữu ích cho các API nhạy cảm trong đó các chuỗi do người dùng tạo tùy ý có thể tạo ra vấn đề. Ví dụ, hai trường hợp trên đó tạo ra lỗi kiểm tra loại có thể dễ bị tấn công SQL. Xem PEP 675 để biết thêm chi tiết.PEP 675 for more details. Mới trong phiên bản 3.11. gõ. Không bao giờNever¶Loại dưới cùng, một loại không có thành viên. Điều này có thể được sử dụng để xác định một hàm không bao giờ được gọi hoặc một hàm không bao giờ trả về: def greeting(name: str) -> str: return 'Hello ' + name0 Mới trong phiên bản 3.11: Trên các phiên bản Python cũ hơn, 65 may be used to express the same concept. 66 was added to make the intended meaning more explicit. Gõ.Noreturn¶NoReturn¶Loại đặc biệt chỉ ra rằng một hàm không bao giờ trả về. Ví dụ: def greeting(name: str) -> str: return 'Hello ' + name1 65 cũng có thể được sử dụng như một loại dưới cùng, một loại không có giá trị. Bắt đầu trong Python 3.11, loại 66 nên được sử dụng cho khái niệm này. Loại kiểm tra nên đối xử với hai người tương đương.Mới trong phiên bản 3.5.4. Mới trong phiên bản 3.6.2. gõ.SelfSelf¶Loại đặc biệt để đại diện cho lớp kèm theo hiện tại. Ví dụ: def greeting(name: str) -> str: return 'Hello ' + name2 Chú thích này tương đương về mặt ngữ nghĩa với những điều sau đây, mặc dù theo kiểu cô đọng hơn: def greeting(name: str) -> str: return 'Hello ' + name3 Nói chung nếu một cái gì đó hiện đang tuân theo mô hình của: def greeting(name: str) -> str: return 'Hello ' + name4 Bạn nên sử dụng 57 làm cuộc gọi đến 70 sẽ có 71 dưới dạng loại trả về chứ không phải 72.Các trường hợp sử dụng phổ biến khác bao gồm:
Xem PEP 673 để biết thêm chi tiết.PEP 673 for more details. Mới trong phiên bản 3.11. gõ. Không bao giờTypeAlias¶Loại dưới cùng, một loại không có thành viên.type alias. For example: def greeting(name: str) -> str: return 'Hello ' + name5 Điều này có thể được sử dụng để xác định một hàm không bao giờ được gọi hoặc một hàm không bao giờ trả về:PEP 613 for more details about explicit type aliases. Mới trong phiên bản 3.11: Trên các phiên bản Python cũ hơn, Gõ.Noreturn¶Loại đặc biệt chỉ ra rằng một hàm không bao giờ trả về. Ví dụ: 65 cũng có thể được sử dụng như một loại dưới cùng, một loại không có giá trị. Bắt đầu trong Python 3.11, loại 66 nên được sử dụng cho khái niệm này. Loại kiểm tra nên đối xử với hai người tương đương.Tuple¶Mới trong phiên bản 3.5.4. Mới trong phiên bản 3.6.2. gõ.Self Loại đặc biệt để đại diện cho lớp kèm theo hiện tại. Ví dụ:Union¶Chú thích này tương đương về mặt ngữ nghĩa với những điều sau đây, mặc dù theo kiểu cô đọng hơn: def greeting(name: str) -> str: return 'Hello ' + name3
Chú thích đặc biệt để tuyên bố rõ ràng một bí danh. Ví dụ:Don’t remove explicit subclasses from unions at runtime. Xem PEP 613 để biết thêm chi tiết về các bí danh loại rõ ràng.Optional¶Mới trong phiên bản 3.10. Mẫu đặc biệt Chúng có thể được sử dụng làm loại trong các chú thích bằng cách sử dụng 53, mỗi loại có một cú pháp duy nhất.Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])0 Gõ.Tuple¶ Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])1 Loại tuple; 92. See union type expressions. Ví dụ: 79 là một bộ của hai yếu tố tương ứng với các biến loại T1 và T2. 80 là một bộ dữ liệu của int, float và một chuỗi.Callable¶Để chỉ định một tuple có độ dài thay đổi của loại đồng nhất, hãy sử dụng Ellipsis theo nghĩa đen, ví dụ: 81. Một đơn giản 82 tương đương với 83, và lần lượt 84.gõ.Union¶ Không có cú pháp để chỉ ra các đối số từ khóa hoặc tùy chọn; Các loại chức năng như vậy hiếm khi được sử dụng làm loại gọi lại. 91 (Ellipsis theo nghĩa đen) có thể được sử dụng để nhập gợi ý về việc gọi có thể gọi bất kỳ số lượng đối số nào và trả lại def greeting(name: str) -> str: return 'Hello ' + name00. Một đơn giản 30 tương đương với def greeting(name: str) -> str: return 'Hello ' + name02, và đến lượt def greeting(name: str) -> str: return 'Hello ' + name03. Các thiết bị gọi lấy các thiết bị gọi khác làm đối số có thể chỉ ra rằng các loại tham số của chúng phụ thuộc vào nhau bằng cách sử dụng 50. Ngoài ra, nếu có thể gọi được thêm hoặc xóa các đối số khỏi các loại gọi khác, toán tử 51 có thể được sử dụng. Họ lần lượt nhận dạng 94 và 95. gõ.concatenate¶Concatenate¶Được sử dụng với 30 và 50 để nhập chú thích một thứ tự cao hơn có thể gọi có thể thêm, xóa hoặc biến đổi các tham số của một người khác có thể gọi được. Việc sử dụng ở dạng def greeting(name: str) -> str: return 'Hello ' + name10. 51 hiện chỉ hợp lệ khi được sử dụng làm đối số đầu tiên cho 30. Tham số cuối cùng của 51 phải là 50 hoặc Ellipsis (def greeting(name: str) -> str: return 'Hello ' + name15). Ví dụ, để chú thích một người trang trí def greeting(name: str) -> str: return 'Hello ' + name16 cung cấp một def greeting(name: str) -> str: return 'Hello ' + name17 cho chức năng được trang trí, 51 có thể được sử dụng để chỉ ra rằng def greeting(name: str) -> str: return 'Hello ' + name16 mong đợi một cuộc gọi có thể gọi được trong một def greeting(name: str) -> str: return 'Hello ' + name20 là đối số đầu tiên và trả về một dấu hiệu có thể gọi với một loại khác nhau. Trong trường hợp này, 50 chỉ ra rằng các loại tham số được gọi là có thể gọi được phụ thuộc vào các loại tham số của có thể gọi được được truyền vào:Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])2 Mới trong phiên bản 3.10. Xem thêm
Một biến được chú thích bằng def greeting(name: str) -> str: return 'Hello ' + name26 có thể chấp nhận giá trị loại def greeting(name: str) -> str: return 'Hello ' + name26. Ngược lại, một biến được chú thích bằng def greeting(name: str) -> str: return 'Hello ' + name28 có thể chấp nhận các giá trị là bản thân các lớp - cụ thể, nó sẽ chấp nhận đối tượng lớp của def greeting(name: str) -> str: return 'Hello ' + name26. Ví dụ: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])3 Lưu ý rằng def greeting(name: str) -> str: return 'Hello ' + name28 là Covariant: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])4 Thực tế là def greeting(name: str) -> str: return 'Hello ' + name28 là hiệp phương sai ngụ ý rằng tất cả các lớp con của def greeting(name: str) -> str: return 'Hello ' + name26 nên thực hiện cùng một chữ ký của hàm tạo và chữ ký phương pháp lớp là def greeting(name: str) -> str: return 'Hello ' + name26. Trình kiểm tra loại nên gắn cờ vi phạm này, nhưng cũng nên cho phép các cuộc gọi xây dựng trong các lớp con phù hợp với các cuộc gọi xây dựng trong lớp cơ sở được chỉ định. Làm thế nào trình kiểm tra loại được yêu cầu để xử lý trường hợp cụ thể này có thể thay đổi trong các sửa đổi trong tương lai của PEP 484.PEP 484. Các tham số pháp lý duy nhất cho def greeting(name: str) -> str: return 'Hello ' + name34 là các lớp, 28, các biến loại và các công đoàn của bất kỳ loại nào trong số này. Ví dụ:type variables, and unions of any of these types. For example:Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])5 def greeting(name: str) -> str: return 'Hello ' + name36 tương đương với def greeting(name: str) -> str: return 'Hello ' + name34, lần lượt tương đương với def greeting(name: str) -> str: return 'Hello ' + name38, là gốc của hệ thống phân cấp Metaclass Python. Mới trong phiên bản 3.5.2. Gõ.Literal¶Literal¶Một loại có thể được sử dụng để chỉ ra các trình kiểm tra loại rằng biến hoặc tham số chức năng tương ứng có giá trị tương đương với nghĩa đen được cung cấp (hoặc một trong một số nghĩa đen). Ví dụ: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])6 def greeting(name: str) -> str: return 'Hello ' + name39 không thể được phân nhóm. Trong thời gian chạy, một giá trị tùy ý được cho phép là đối số loại thành def greeting(name: str) -> str: return 'Hello ' + name39, nhưng người kiểm tra loại có thể áp đặt các hạn chế. Xem PEP 586 để biết thêm chi tiết về các loại nghĩa đen.PEP 586 for more details about literal types. Mới trong phiên bản 3.8. Đã thay đổi trong phiên bản 3.9.1: 42 now de-duplicates parameters. Equality comparisons of 42 objects are no longer order dependent. 42 objects will now raise a
def greeting(name: str) -> str: return 'Hello ' + name44 exception during equality comparisons if one of their parameters are not hashable. Gõ.Classvar¶ClassVar¶ Loại cấu trúc đặc biệt để đánh dấu các biến lớp. Như được giới thiệu trong PEP 526, một chú thích thay đổi được bọc trong classvar chỉ ra rằng một thuộc tính nhất định được dự định sẽ được sử dụng làm biến lớp và không nên được đặt trên các trường hợp của lớp đó. Cách sử dụng:PEP 526, a variable annotation wrapped in ClassVar indicates that a given attribute is intended to be used as a class variable and should not be set on instances of that class. Usage: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])7 38 chỉ chấp nhận các loại và không thể được đăng ký thêm. 38 không phải là một lớp và không nên được sử dụng với def greeting(name: str) -> str: return 'Hello ' + name47 hoặc def greeting(name: str) -> str: return 'Hello ' + name48. 38 không thay đổi hành vi thời gian chạy Python, nhưng nó có thể được sử dụng bởi các trình kiểm tra loại bên thứ ba. Ví dụ: Trình kiểm tra loại có thể gắn cờ mã sau là lỗi:Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])8 Mới trong phiên bản 3.5.3. gõ.final¶Final¶Một cấu trúc gõ đặc biệt để chỉ ra để nhập trình kiểm tra rằng một tên không thể được gán lại hoặc ghi đè trong một lớp con. Ví dụ: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])9 Không có kiểm tra thời gian chạy của các thuộc tính này. Xem PEP 591 để biết thêm chi tiết.PEP 591 for more details. Mới trong phiên bản 3.8. Đã thay đổi trong phiên bản 3.9.1: 42 hiện đã khử trùng các tham số. So sánh bình đẳng của các đối tượng 42 không còn phụ thuộc vào thứ tự. Các đối tượng 42 hiện sẽ tăng ngoại lệ def greeting(name: str) -> str: return 'Hello ' + name44 trong quá trình so sánh bình đẳng nếu một trong các tham số của chúng không thể băm.Required¶ typing.NotRequired¶ Gõ.Classvar¶ Loại cấu trúc đặc biệt để đánh dấu các biến lớp.PEP 655 for more details. Như được giới thiệu trong PEP 526, một chú thích thay đổi được bọc trong classvar chỉ ra rằng một thuộc tính nhất định được dự định sẽ được sử dụng làm biến lớp và không nên được đặt trên các trường hợp của lớp đó. Cách sử dụng: 38 chỉ chấp nhận các loại và không thể được đăng ký thêm.Annotated¶Một loại, được giới thiệu trong PEP 593 ( def greeting(name: str) -> str: return 'Hello ' + name52), để trang trí các loại hiện có với siêu dữ liệu cụ thể theo ngữ cảnh (có thể là nhiều phần của nó, vì 46 là variadic). Cụ thể, loại 99 có thể được chú thích bằng siêu dữ liệu def greeting(name: str) -> str: return 'Hello ' + name55 thông qua TypeHint def greeting(name: str) -> str: return 'Hello ' + name56. Siêu dữ liệu này có thể được sử dụng để phân tích tĩnh hoặc trong thời gian chạy. Nếu một thư viện (hoặc công cụ) gặp phải một kiểu chữ def greeting(name: str) -> str: return 'Hello ' + name56 và không có logic đặc biệt cho siêu dữ liệu def greeting(name: str) -> str: return 'Hello ' + name55, nó sẽ bỏ qua nó và chỉ coi loại này là 99. Không giống như chức năng def greeting(name: str) -> str: return 'Hello ' + name60 hiện đang tồn tại trong mô -đun 37, vô hiệu hóa hoàn toàn các chú thích đánh máy trên một hàm hoặc một lớp, loại 46 cho phép cả hai lần kiểm tra typic của 99 (có thể bỏ qua def greeting(name: str) -> str: return 'Hello ' + name55) .PEP 593 ( def greeting(name: str) -> str: return 'Hello ' + name52), to decorate existing types with context-specific metadata (possibly multiple pieces of it, as 46 is variadic). Specifically, a type
99 can be annotated with metadata def greeting(name: str) -> str: return 'Hello ' + name55 via the typehint def greeting(name: str) -> str: return 'Hello ' + name56. This metadata can be used for either static analysis or at runtime. If a library (or tool) encounters a typehint def greeting(name: str) -> str: return 'Hello ' + name56 and has no special logic for metadata def greeting(name: str) -> str: return 'Hello ' + name55, it should ignore it and simply treat the type as 99. Unlike the def greeting(name: str) -> str: return 'Hello ' + name60 functionality that currently exists in the 37 module which completely disables typechecking annotations on a function or a class, the 46 type allows for both
static typechecking of 99 (which can safely ignore def greeting(name: str) -> str: return 'Hello ' + name55) together with runtime access to def greeting(name: str) -> str: return 'Hello ' + name55 within a specific application. Cuối cùng, trách nhiệm của cách diễn giải các chú thích (nếu có) là trách nhiệm của công cụ hoặc thư viện gặp phải loại 46. Một công cụ hoặc thư viện gặp phải loại 46 có thể quét qua các chú thích để xác định xem chúng có được quan tâm không (ví dụ: sử dụng def greeting(name: str) -> str: return 'Hello ' + name47). Khi một công cụ hoặc thư viện không hỗ trợ chú thích hoặc gặp một chú thích không xác định, nó chỉ nên bỏ qua nó và coi loại chú thích là loại cơ bản. Nó tùy thuộc vào công cụ tiêu thụ các chú thích để quyết định xem khách hàng có được phép có nhiều chú thích trên một loại hay không và làm thế nào để hợp nhất các chú thích đó. Vì loại 46 cho phép bạn đặt một số chú thích giống nhau (hoặc khác nhau) trên bất kỳ nút nào, nên các công cụ hoặc thư viện tiêu thụ các chú thích đó chịu trách nhiệm đối phó với các bản sao tiềm năng. Ví dụ: nếu bạn đang thực hiện phân tích phạm vi giá trị, bạn có thể cho phép điều này:from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...0 Chuyển def greeting(name: str) -> str: return 'Hello ' + name70 đến def greeting(name: str) -> str: return 'Hello ' + name71 cho phép người ta truy cập vào các chú thích bổ sung khi chạy. Các chi tiết của cú pháp:
Mới trong phiên bản 3.9. gõ.typeguard¶TypeGuard¶Biểu mẫu gõ đặc biệt được sử dụng để chú thích loại trả về của chức năng bảo vệ loại do người dùng xác định. 54 chỉ chấp nhận một đối số loại duy nhất. Trong thời gian chạy, các chức năng được đánh dấu theo cách này sẽ trả về Boolean. 54 nhằm mục đích thu hẹp loại lợi ích - Một kỹ thuật được sử dụng bởi các trình kiểm tra loại tĩnh để xác định một loại biểu thức chính xác hơn trong luồng mã chương trình. Thông thường thu hẹp loại được thực hiện bằng cách phân tích luồng mã có điều kiện và áp dụng việc thu hẹp vào một khối mã. Biểu thức có điều kiện ở đây đôi khi được gọi là một người bảo vệ kiểu người khác:from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...6 Đôi khi sẽ thuận tiện khi sử dụng chức năng Boolean do người dùng định nghĩa làm người bảo vệ loại. Một chức năng như vậy nên sử dụng def greeting(name: str) -> str: return 'Hello ' + name80 làm loại trả về của nó để cảnh báo các trình kiểm tra loại tĩnh cho ý định này. Sử dụng def greeting(name: str) -> str: return 'Hello ' + name81 nói với trình kiểm tra loại tĩnh rằng đối với một hàm đã cho:
Ví dụ: from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...7 Nếu def greeting(name: str) -> str: return 'Hello ' + name84 là phương thức lớp hoặc phiên bản, thì loại trong 54 bản đồ theo loại tham số thứ hai sau 74 hoặc def greeting(name: str) -> str: return 'Hello ' + name87. Nói tóm lại, mẫu ____388, có nghĩa là nếu def greeting(name: str) -> str: return 'Hello ' + name89 trả về def greeting(name: str) -> str: return 'Hello ' + name82, thì def greeting(name: str) -> str: return 'Hello ' + name91 thu hẹp từ def greeting(name: str) -> str: return 'Hello ' + name92 đến def greeting(name: str) -> str: return 'Hello ' + name93. Ghi chú def greeting(name: str) -> str: return 'Hello ' + name93 không cần phải là một dạng hẹp hơn của def greeting(name: str) -> str: return 'Hello ' + name92 - nó thậm chí có thể là một hình thức rộng hơn. Lý do chính là để cho phép những thứ như thu hẹp def greeting(name: str) -> str: return 'Hello ' + name96 đến def greeting(name: str) -> str: return 'Hello ' + name97 mặc dù sau này không phải là một loại phụ của cái trước, vì def greeting(name: str) -> str: return 'Hello ' + name98 là bất biến. Trách nhiệm của việc viết bộ bảo vệ loại an toàn loại được để lại cho người dùng. 54 cũng hoạt động với các biến loại. Xem PEP 647 để biết thêm chi tiết.PEP 647 for more details.Mới trong phiên bản 3.10. Xây dựng các loại chung chungChúng không được sử dụng trong các chú thích. Họ đang xây dựng các khối để tạo ra các loại chung. classtyping.generic¶typing.Generic¶Lớp cơ sở trừu tượng cho các loại chung. Một loại chung thường được khai báo bằng cách kế thừa từ một khởi tạo của lớp này với một hoặc nhiều biến loại. Ví dụ: loại ánh xạ chung có thể được định nghĩa là: from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...8 Lớp này sau đó có thể được sử dụng như sau: from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...9 classtyping.typevar¶typing.TypeVar¶ Loại biến. Usage: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)0 Loại biến tồn tại chủ yếu vì lợi ích của người kiểm tra loại tĩnh. Chúng phục vụ như các tham số cho các loại chung cũng như các định nghĩa chức năng chung. Xem 32 để biết thêm thông tin về các loại chung. Chức năng chung hoạt động như sau:from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)1 Lưu ý rằng các biến loại có thể bị ràng buộc, bị ràng buộc hoặc không, nhưng không thể bị ràng buộc và bị ràng buộc. Các biến loại ràng buộc và các biến loại bị ràng buộc có ngữ nghĩa khác nhau theo nhiều cách quan trọng. Sử dụng biến loại ràng buộc có nghĩa là 31 sẽ được giải quyết bằng cách sử dụng loại cụ thể nhất có thể:from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)2 Các biến loại có thể được liên kết với các loại cụ thể, các loại trừu tượng (ABC hoặc giao thức) và thậm chí cả các công đoàn của các loại: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)3 Tuy nhiên, sử dụng một biến loại bị ràng buộc có nghĩa là 31 chỉ có thể được giải quyết là chính xác là một trong những ràng buộc đã đưa ra:from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)4 Trong thời gian chạy, Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])03 sẽ tăng def greeting(name: str) -> str: return 'Hello ' + name44. Nói chung, def greeting(name: str) -> str: return 'Hello ' + name47 và def greeting(name: str) -> str: return 'Hello ' + name48 không nên được sử dụng với các loại. Các biến loại có thể được đánh dấu hiệp phương sai hoặc contravariant bằng cách vượt qua Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])07 hoặc Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])08. Xem PEP 484 để biết thêm chi tiết. Theo mặc định, các biến loại là bất biến.PEP 484 for more details. By default, type variables are invariant. classtyping.typevartuple¶typing.TypeVarTuple¶ Loại biến tuple. Một hình thức chuyên dụng của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])09 cho phép các chất generic variadic. Một biến loại bình thường cho phép tham số hóa với một loại duy nhất. Ngược lại, một loại biến loại cho phép tham số hóa với số lượng loại tùy ý bằng cách hoạt động giống như một số lượng biến tùy ý được bọc trong một tuple. Ví dụ: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)5 Lưu ý việc sử dụng toán tử giải nén Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 trong Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])11. Về mặt khái niệm, bạn có thể nghĩ Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])12 như một bộ biến của các biến loại Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])13. Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])11 sau đó sẽ trở thành Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])15, tương đương với Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])16. . Loại Tuples biến phải luôn được giải nén. Điều này giúp phân biệt các loại biến loại với các biến loại bình thường: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)6 Loại Tuples biến có thể được sử dụng trong cùng một bối cảnh với các biến loại bình thường. Ví dụ: trong các định nghĩa lớp, đối số và loại trả về: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)7 Loại Tuples biến có thể được kết hợp vui vẻ với các biến loại bình thường: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)8 Tuy nhiên, lưu ý rằng nhiều nhất là một loại biến có thể xuất hiện trong một danh sách các đối số hoặc loại loại loại: from typing import NewType UserId = NewType('UserId', int) some_id = UserId(524313)9 Cuối cùng, một loại biến loại chưa đóng gói có thể được sử dụng làm chú thích loại của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])19: def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)0 Trái ngược với các chú thích không được đóng gói của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])19 - ví dụ: Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])21, trong đó sẽ chỉ định rằng tất cả các đối số là 65 - Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])23 cho phép tham chiếu đến các loại của các đối số riêng lẻ trong Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])19. Ở đây, điều này cho phép chúng tôi đảm bảo các loại của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])19 được chuyển cho Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])26 khớp với các loại đối số (vị trí) của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])27. Xem PEP 646 để biết thêm chi tiết về các bộ dữ liệu biến loại.PEP 646 for more details on type variable tuples. Mới trong phiên bản 3.11. gõ.unpack¶Unpack¶Một toán tử đánh máy đánh dấu một đối tượng là đã được giải nén. Ví dụ: sử dụng toán tử unpack Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 trên Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])29 tương đương với việc sử dụng Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 để đánh dấu loại biến loại loại đã được giải nén: def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)1 Trên thực tế, Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 có thể được sử dụng thay thế cho Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 trong bối cảnh của các loại. Bạn có thể thấy Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 đang được sử dụng rõ ràng trong các phiên bản cũ của Python, trong đó Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 không thể được sử dụng ở một số nơi nhất định: def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)2 Mới trong phiên bản 3.11. gõ.unpack¶typing.ParamSpec(name, *, bound=None, covariant=False, contravariant=False)¶Một toán tử đánh máy đánh dấu một đối tượng là đã được giải nén. Ví dụ: sử dụng toán tử unpack Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 trên Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])29 tương đương với việc sử dụng Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 để đánh dấu loại biến loại loại đã được giải nén: Usage: Trên thực tế, Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 có thể được sử dụng thay thế cho Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 trong bối cảnh của các loại. Bạn có thể thấy Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])17 đang được sử dụng rõ ràng trong các phiên bản cũ của Python, trong đó Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])10 không thể được sử dụng ở một số nơi nhất định: classtyping.paramspec (name, *, bound = none, covariant = false def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)3 Biến đặc tả tham số. Một phiên bản chuyên dụng của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])35.
Vì 50 nắm bắt cả các tham số vị trí và từ khóa, Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])52 và Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])53 có thể được sử dụng để chia 50 thành các thành phần của nó. Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])52 đại diện cho bộ dữ liệu của các tham số vị trí trong một cuộc gọi nhất định và chỉ nên được sử dụng để chú thích Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])19. Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])53 thể hiện ánh xạ các tham số từ khóa đến các giá trị của chúng trong một cuộc gọi nhất định và chỉ nên được sử dụng để chú thích Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])45. Cả hai thuộc tính đều yêu cầu tham số chú thích phải nằm trong phạm vi. Trong thời gian chạy, Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])52 và Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])53 là các trường hợp tương ứng của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])61 và Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])62. Các biến đặc tả tham số được tạo bằng Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])07 hoặc Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])08 có thể được sử dụng để khai báo các loại chung hiệp phương sai hoặc contravariant. Đối số Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])65 cũng được chấp nhận, tương tự như 31. Tuy nhiên, ngữ nghĩa thực tế của các từ khóa này vẫn chưa được quyết định.Mới trong phiên bản 3.10. Ghi chú Chỉ các biến đặc tả tham số được xác định trong phạm vi toàn cầu mới có thể được ngâm. Xem thêm
Đối số và từ khóa Các thuộc tính của A 50. Thuộc tính Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])52 của 50 là một ví dụ là Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])61 và Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])53 là một ví dụ của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])62. Chúng được dự định để hướng nội thời gian chạy và không có ý nghĩa đặc biệt đối với người kiểm tra loại tĩnh. Gọi Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])77 trên một trong hai đối tượng này sẽ trả về bản gốc 50:def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)4 Mới trong phiên bản 3.10. Ghi chúAnyStr¶Chỉ các biến đặc tả tham số được xác định trong phạm vi toàn cầu mới có thể được ngâm. Xem thêm def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)5 PEP 612 - Các biến đặc tả tham số (PEP đã giới thiệu 50 và 51).typing.Protocol(Generic)¶ 30 và 51.def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)6 Gõ.ParamSpecArgs¶ Gõ.ParamSpeckWargs¶ def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)7 Đối số và từ khóa Các thuộc tính của A 50. Thuộc tính Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])52 của 50 là một ví dụ là Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])61 và Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])53 là một ví dụ của Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])62. Chúng được dự định để hướng nội thời gian chạy và không có ý nghĩa đặc biệt đối với người kiểm tra loại tĩnh.PEP 544 for more details. Protocol classes decorated with Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])82 (described later) act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Gọi Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])77 trên một trong hai đối tượng này sẽ trả về bản gốc 50:def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)8 gõ.AnyStr¶ Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])79 là Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])80 được định nghĩa là Vector = list[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] # passes type checking; a list of floats qualifies as a Vector. new_vector = scale(2.0, [1.0, -4.2, 5.4])81.typing.runtime_checkable¶ Nó có nghĩa là được sử dụng cho các chức năng có thể chấp nhận bất kỳ loại chuỗi nào mà không cho phép các loại chuỗi khác nhau trộn. Ví dụ: classtyping.protocol (chung) ¶ def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)9 Ghi chú Chỉ các biến đặc tả tham số được xác định trong phạm vi toàn cầu mới có thể được ngâm. gõ.AnyStr¶
|
Tính năng | Phản đối trong | Loại bỏ dự kiến | PEP/issue |
---|---|---|---|
from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...78 và from collections.abc import Sequence ConnectionOptions = dict[str, str] Address = tuple[str, int] Server = tuple[Address, ConnectionOptions] def broadcast_message(message: str, servers: Sequence[Server]) -> None: ... # The static type checker will treat the previous type signature as # being exactly equivalent to this one. def broadcast_message( message: str, servers: Sequence[tuple[tuple[str, int], dict[str, str]]]) -> None: ...87 | 3.8 | 3.13 | bpo-38291 |
37 Phiên bản của các bộ sưu tập tiêu chuẩn
| 3.9 | Chưa quyết định | PEP 585 |
def get_user_name(user_id: UserId) -> str: ... # passes type checking user_a = get_user_name(UserId(42351)) # fails type checking; an int is not a UserId user_b = get_user_name(-1)80 | 3.11 | Chưa quyết định | gh-92332 |