programming python

Biến cuối cùng trong python

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, linters, v.v.

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 ________ 08, ________ 09, ________ 200, ________ 201 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02. Để 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ề gợi ý nhập, hãy xem PEP 483

Hàm bên dưới nhận và trả về một chuỗi và được chú thích như sau

def greeting[name: str] -> str:
    return 'Hello ' + name

Trong hàm

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

03, đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

04 dự kiến sẽ thuộc loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

05 và loại trả về là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

05. Các kiểu con được chấp nhận làm đối số

Các tính năng mới thường xuyên được thêm vào mô-đun

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

07. 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

Xem thêm

Tài liệu tại https. //đánh máy. đọcthedocs. io/ đóng vai trò là tài liệu tham khảo hữu ích cho các tính năng của hệ thống nhập, các công cụ liên quan đến đánh máy hữu ích và các phương pháp hay nhất về đánh máy

PEP liên quan¶

Kể từ lần đầu giới thiệu các gợi ý loại trong PEP 484 và PEP 483, một số PEP đã sửa đổi và nâng cao khung của Python cho các chú thích loại. Bao gồm các

PEP 526. Cú pháp cho chú thích biến

Giới thiệu cú pháp để chú thích các biến bên ngoài định nghĩa hàm và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 544. giao thức. Phân loại cấu trúc [gõ vịt tĩnh]

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

09 và trang trí

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 585. Nhập gợi ý chung trong bộ sưu tập tiêu chuẩn

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

11 và khả năng sử dụng các lớp thư viện tiêu chuẩn làm các loại chung

PEP 586. Các loại chữ

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 589. đã gõDict. Nhập gợi ý cho từ điển với một bộ phím cố định

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 591. Thêm một vòng loại cuối cùng để gõ

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

14 và trang trí

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 593. Chức năng linh hoạt và chú thích biến

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 604. Cho phép viết các kiểu kết hợp là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

18 và khả năng sử dụng toán tử nhị phân hoặc toán tử

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

19 để biểu thị một kết hợp các loại

PEP 612. Tham số Thông số kỹ thuật Biến

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 613. Bí danh loại rõ ràng

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 647. Bảo vệ loại do người dùng xác định

Giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Nhập bí danh¶

Bí danh loại được xác định bằng cách gán loại cho bí danh. Trong ví dụ này,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

24 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

25 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]

# typechecks; 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 tạp. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lưu ý rằng ________ 226 dưới dạng gợi ý loại là trường hợp đặc biệt và được thay thế bằng ________ 227

Kiểu mới¶

Sử dụng trình trợ giúp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

28 để tạo các loại riêng biệt

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Trình kiểm tra kiểu tĩnh sẽ xử lý kiểu mới như thể nó là một lớp con của kiểu ban đầu. Điều này rất hữu ích trong việc giúp bắt các lỗi logic

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Bạn vẫn có thể thực hiện tất cả các thao tác

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

29 trên một biến kiểu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

30, nhưng kết quả sẽ luôn là kiểu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

29. Điều này cho phép bạn vượt qua một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

30 bất cứ nơi nào có thể mong đợi một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

29, nhưng sẽ ngăn bạn vô tình tạo một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

30 theo cách không hợp lệ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lưu ý rằng các kiểm tra này chỉ được thực thi bởi trình kiểm tra kiểu tĩnh. Trong thời gian chạy, câu lệnh

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

35 sẽ làm cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

36 có thể gọi được và ngay lập tức trả về bất kỳ tham số nào bạn truyền cho nó. Điều đó có nghĩa là biểu thức

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

37 không tạo ra một lớp mới hoặc giới thiệu nhiều chi phí ngoài cuộc gọi hàm thông thường

Chính xác hơn, biểu thức

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

38 luôn đúng trong thời gian chạy

Không hợp lệ để tạo một loại phụ của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Tuy nhiên, có thể tạo một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

28 dựa trên một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

28 'có nguồn gốc'

def greeting[name: str] -> str:
    return 'Hello ' + name

và kiểm tra đánh máy cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

42 sẽ hoạt động như mong đợi

Xem PEP 484 để biết thêm chi tiết

Ghi chú

Nhớ lại rằng việc sử dụng bí danh kiểu khai báo hai kiểu tương đương với nhau. Thực hiện

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

43 sẽ làm cho trình kiểm tra kiểu tĩnh coi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

44 hoàn toàn tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

45 trong mọi trường hợp. Điều này 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,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

28 tuyên bố một kiểu là kiểu con của kiểu khác. Thực hiện

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

47 sẽ làm cho trình kiểm tra kiểu tĩnh coi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

36 là một phân lớp của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

45, có nghĩa là giá trị của loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

45 không thể được sử dụng ở những nơi mong đợi giá trị của loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

36. Điều này hữu ích khi bạn muốn ngăn ngừa 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. ______228 bây giờ là một lớp chứ không phải là một hàm. Có một số chi phí thời gian chạy bổ sung khi gọi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

28 qua một chức năng thông thường. Tuy nhiên, chi phí này sẽ giảm trong 3. 11. 0.

Có thể gọi¶

Các khung mong đợi các chức năng gọi lại của các chữ ký cụ thể có thể được gợi ý loại bằng cách sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Có thể khai báo kiểu trả về của một hàm có thể gọi được mà không chỉ định chữ ký cuộc gọi bằng cách thay thế dấu chấm lửng bằng chữ cho danh sách các đối số trong gợi ý kiểu.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các khả năng gọi được lấy các khả năng 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20. Ngoài ra, nếu khả năng gọi đó thêm hoặc xóa đối số khỏi các khả năng gọi khác, toán tử

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 có thể được sử dụng. Chúng có dạng tương ứng là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

58 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Thuốc generic¶

Vì thông tin loại về các đối tượng được giữ trong vùng chứa không thể được suy luận tĩnh theo cách chung 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 phần tử vùng chứa

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Generics có thể được tham số hóa bằng cách sử dụng một nhà máy có sẵn trong cách gõ có tên là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Loại chung do người dùng định nghĩa¶

Một lớp do người dùng định nghĩa có thể được định nghĩa là một lớp chung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

61 với tư cách là một lớp cơ sở định nghĩa rằng lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

62 nhận một tham số kiểu duy nhất là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63. Điều này cũng làm cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63 hợp lệ như một loại trong nội dung lớp

Lớp cơ sở

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02 định nghĩa

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

66 để

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

67 có giá trị như một loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Một loại chung có thể có bất kỳ số lượng biến loại nào. Tất cả các biến thể của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

01 đều được phép làm tham số cho một loại chung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mỗi đối số biến loại cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02 phải khác biệt. Điều này là không hợp lệ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Bạn có thể sử dụng đa thừa kế với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Khi kế thừa từ các lớp chung, một số biến kiểu có thể được sửa

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Trong trường hợp này,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

71 có một tham số duy nhất,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Sử dụng một lớp chung mà không chỉ định các tham số loại giả sử

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 cho mỗi vị trí. Trong ví dụ sau,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

74 không phải là chung chung nhưng hoàn toàn kế thừa từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Bí danh loại chung do người dùng xác định cũng được hỗ trợ. ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Đã thay đổi trong phiên bản 3. 7. ______202 không còn có siêu dữ liệu tùy chỉnh.

Các khái quát do người dùng định nghĩa 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

77. Hành vi phù hợp với các biến kiểu’ được mô tả ở trên vì các biến đặc tả tham số được mô-đun gõ xử lý như một biến kiểu chuyên biệt. 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Hơn nữa, một biến chung chỉ có một biến đặc tả tham số sẽ chấp nhận danh sách tham số ở dạng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

79 và cả

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

80 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Xin lưu ý rằng thuốc generic có

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 có thể không có

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

82 chính xác sau khi thay thế trong một số trường hợp vì chúng chủ yếu dành cho kiểm tra loại tĩnh

Đã thay đổi trong phiên bản 3. 10. ______202 hiện có thể được tham số hóa qua các biểu thức tham số. Xem

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 và PEP 612 để biết thêm chi tiết.

Lớp chung do người dùng định nghĩa có thể có ABC làm lớp cơ sở mà không có xung đột siêu dữ liệu. Siêu dữ liệu chung không được hỗ trợ. Kết quả của việc tham số hóa các khái quát được lưu vào bộ đệm và hầu hết các loại trong mô-đun gõ đều có thể băm và có thể so sánh bằng nhau

Loại bất kỳ¶

Một loại đặc biệt của loại là

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8. Trình kiểm tra loại tĩnh sẽ coi mọi loại là tương thích với

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 và

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 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ỳ thao tác hoặc lệnh gọi phương thức nào trên một giá trị kiểu

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 và gán nó cho bất kỳ biến nào

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lư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 _______ 08 cho loại chính xác hơn. Ví dụ: trình kiểm tra kiểu tĩnh không báo lỗi khi gán

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

90 cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

91 mặc dù

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

91 được khai báo là kiểu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

05 và nhận giá trị

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

29 khi chạy

Hơn nữa, tất cả các hàm không có kiểu trả về hoặc kiểu tham số sẽ mặc định mặc định sử dụng

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Hành vi này cho phép sử dụng

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 làm lối thoát hiểm khi bạn cần kết hợp mã được nhập động và mã tĩnh

Đối chiếu hành vi của

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 với hành vi của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

98. Tương tự như

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8, mỗi loại là một kiểu con của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

98. Tuy nhiên, không giống như

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8, điều ngược lại không đúng.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

98 không phải là kiểu con của mọi kiểu khác

Điều đó có nghĩa là khi loại của một giá trị là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

98, trình kiểm tra loại sẽ từ chối hầu hết mọi hoạt động trên nó và gán nó cho một biến [hoặc sử dụng nó làm giá trị trả về] của loại chuyên biệt hơn là lỗi loại. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

98 để chỉ ra rằng một giá trị có thể là bất kỳ loại nào theo cách an toàn về kiểu. Sử dụng

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 để chỉ ra rằng một giá trị được nhập động

Phân nhóm danh nghĩa và phân nhóm cấu trúc¶

Ban đầu, PEP 484 đã định nghĩa hệ thống kiểu tĩnh Python là sử dụng kiểu con danh nghĩa. Điều này có nghĩa là một lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

006 được cho phép khi một lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

007 được mong đợi nếu và chỉ khi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

007

Yêu cầu này trước đây cũng được áp dụng cho các lớp cơ sở trừu tượng, chẳng hạn như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

010. Vấn đề với cách tiếp cận này là một lớp phải được đánh dấu rõ ràng để hỗ trợ chúng, điều này không phổ biến và không giống như những gì người ta thường làm trong mã Python được gõ động thành ngữ. Ví dụ: điều này phù hợp với PEP 484

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

PEP 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 đoạn mã trên mà không có lớp cơ sở rõ ràng trong định nghĩa lớp, cho phép

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

011 được coi là kiểu con của cả

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

012 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

013 bởi trình kiểm tra kiểu tĩnh. Điều này được gọi là phân nhóm cấu trúc [hoặc phân nhóm tĩnh]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Hơn nữa, bằng cách phân lớp một lớp đặc biệt

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

09, người dùng có thể xác định các giao thức tùy chỉnh mới để tận hưởng đầy đủ việc phân loại cấu trúc [xem ví dụ bên dưới]

Nội dung học phần¶

Mô-đun định nghĩa các lớp, chức năng và trình trang trí sau

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 đã tồn tại từ trước, lớp này cũng mở rộng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02 để hỗ trợ các biến loại bên trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

016. 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ợ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

016

Các loại dự phòng không được dùng nữa kể từ Python 3. 9 nhưng trình thông dịch sẽ không đưa ra cảnh báo phản đối nào. Dự kiến, 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 nữa sẽ bị xóa khỏi mô-đun

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

07 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—Type Gợi ý Generics Trong Bộ sưu tập Tiêu chuẩn

Kiểu gõ đặc biệt¶

Các loại đặc biệt¶

Chúng có thể được sử dụng làm loại trong chú thích và không hỗ trợ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

016

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

021¶

Loại đặc biệt cho biết loại không bị ràng buộc

Mọi loại đều tương thích với

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8 tương thích với mọi loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

025¶

Loại đặc biệt chỉ ra rằng một hàm không bao giờ trả về. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 2

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

027¶

Chú thích đặc biệt để khai báo rõ ràng một loại bí danh . Ví dụ.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Xem PEP 613 để biết thêm chi tiết về bí danh loại rõ ràng

Mới trong phiên bản 3. 10

Biểu mẫu đặc biệt¶

Chúng có thể được sử dụng làm loại trong chú thích bằng cách sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

016, 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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

030¶

Loại tuple; . Loại của bộ dữ liệu trống có thể được viết là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

032

Thí dụ.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

033 là một bộ gồm hai phần tử tương ứng với các biến kiểu T1 và T2.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

034 là một bộ gồm một số nguyên, một số float và một chuỗi

Để chỉ định một bộ có độ dài thay đổi thuộc loại đồng nhất, hãy sử dụng dấu chấm lửng bằng chữ, e. g.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

035. Một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

036 đơn giản tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

037 và lần lượt là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

038

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

040¶

loại hình công đoàn;

Để xác định một công đoàn, sử dụng e. g. ________ 3043 hoặc viết tắt là ________ 3044. Sử dụng tốc ký đó được khuyến khích. Thông tin chi tiết

Các đối số phải là các loại và phải có ít nhất một

Liên minh công đoàn bị san phẳng, đ. g

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Liên minh của một đối số duy nhất biến mất, e. g

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Đối số dư thừa được bỏ qua, e. g

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Khi so sánh các công đoàn, thứ tự đối số bị bỏ qua, e. g

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Bạn không thể phân lớp hoặc khởi tạo một

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Bạn không thể viết

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

046

Đã thay đổi trong phiên bản 3. 7. Không xóa các lớp con rõ ràng khỏi liên kết trong thời gian chạy.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

048¶

loại tùy chọn

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

049 tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

050 [hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

051]

Lưu ý rằng đây không phải là khái niệm giống như đối số tùy chọn, là đối số có giá trị mặc định. Đối số tùy chọn với giá trị mặc định không yêu cầu từ hạn định

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

052 trên chú thích loại của nó chỉ vì nó là tùy chọn. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mặt khác, nếu giá trị rõ ràng của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

26 được cho phép, thì việc sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

052 là phù hợp, cho dù đối số có phải là tùy chọn hay không. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Đã thay đổi trong phiên bản 3. 10. Tùy chọn bây giờ có thể được viết là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

050. Xem biểu thức loại liên kết .

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

057¶

Loại có thể gọi được;

Cú pháp đăng ký phải luôn được sử dụng với chính xác hai giá trị. danh sách đối số và kiểu trả về. Danh sách đối số phải là một danh sách các loại hoặc dấu chấm lửng;

Không có cú pháp để chỉ ra các đối số tùy chọn hoặc từ khóa; .

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

55 [dấu chấm lửng theo nghĩa đen] có thể được sử dụng để nhập gợi ý có thể gọi được, lấy bất kỳ số lượng đối số nào và trả về

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

060. Một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00 đơn giản tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

062 và lần lượt là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

063

Các khả năng gọi được lấy các khả năng 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20. Ngoài ra, nếu khả năng gọi đó thêm hoặc xóa đối số khỏi các khả năng gọi khác, toán tử

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 có thể được sử dụng. Chúng có dạng tương ứng là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

58 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

069¶

Được sử dụng với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 để nhập chú thích cho một thứ có thể gọi được cao hơn, bổ sung, loại bỏ hoặc biến đổi các tham số của một thứ có thể gọi khác. Cách sử dụng có dạng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

072.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 hiện chỉ hợp lệ khi được sử dụng làm đối số đầu tiên cho một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00. Tham số cuối cùng của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 phải là một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ví dụ: để chú thích một trình trang trí

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

077 cung cấp một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

078 cho chức năng được trang trí, có thể sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 để chỉ ra rằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

077 mong đợi một hàm có thể gọi được lấy trong một đối số đầu tiên là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

081 và trả về một hàm có thể gọi được với một chữ ký kiểu khác. Trong trường hợp này,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 chỉ ra rằng các loại tham số có thể gọi được trả về phụ thuộc vào các loại tham số của có thể gọi được truyền vào

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 10

Xem thêm

PEP 612 – Biến thông số kỹ thuật tham số [PEP đã giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______3088 [ Chung[CT_co] ] ¶

Một biến được chú thích bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089 có thể chấp nhận giá trị loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089. Ngược lại, một biến được chú thích bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

091 có thể chấp nhận các giá trị là chính các lớp – cụ thể, nó sẽ chấp nhận đối tượng lớp là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lưu ý rằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

091 là hiệp phương sai

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Thực tế là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

091 là hiệp phương sai ngụ ý rằng tất cả các lớp con của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089 nên triển khai cùng chữ ký hàm tạo và chữ ký phương thức lớp như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089. Trình kiểm tra loại sẽ gắn cờ vi phạm điều này, nhưng cũng nên cho phép các lệnh gọi hàm tạo trong các lớp con khớp với các lệnh gọi hàm tạo trong lớp cơ sở được chỉ định. Cách 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 phiên bản PEP 484 trong tương lai

Các tham số pháp lý duy nhất cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

097 là các lớp,

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

8, biến loại và các liên kết của bất kỳ loại nào trong số này. Ví dụ.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

099 tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

097, đến lượt nó tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

401, là gốc của hệ thống phân cấp siêu dữ liệu của Python

Mới trong phiên bản 3. 5. 2

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

403¶

Loại có thể được sử dụng để chỉ báo cho người kiểm tra loại rằng tham số hàm hoặc biến tương ứng có giá trị tương đương với chữ được cung cấp [hoặc một trong số nhiều chữ]. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

404 không thể được phân lớp. Trong thời gian chạy, một giá trị tùy ý được phép làm đối số kiểu cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

404, nhưng trình kiểm tra kiểu có thể áp đặt các hạn chế. Xem PEP 586 để biết thêm chi tiết về các loại chữ

Mới trong phiên bản 3. 8

Đã thay đổi trong phiên bản 3. 9. 1. ______212 hiện loại bỏ các tham số trùng lặp. So sánh bình đẳng của các đối tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

12 không còn phụ thuộc vào thứ tự. Các đối tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

12 giờ đây sẽ đưa ra một ngoại lệ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

409 trong quá trình so sánh bằng nếu một trong các tham số của chúng không có thể băm .

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

411¶

Cấu trúc kiểu đặc biệt để đánh dấu các biến lớp

Như đã giới thiệu trong PEP 526, một chú thích biến được bao bọc trong ClassVar cho biết rằng một thuộc tính nhất định được dùng làm biến lớp và không được đặt trên các phiên bản của lớp đó. Cách sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

08 chỉ chấp nhận các loại và không thể đăng ký thêm

Bản thân

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

08 không phải là một lớp và không nên được sử dụng với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

414 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

415.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

08 không thay đổi hành vi thời gian chạy Python, nhưng nó có thể được sử dụng bởi trình kiểm tra loại của bên thứ ba. Ví dụ: trình kiểm tra loại có thể gắn cờ mã sau đây là lỗi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 5. 3

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

418¶

Một cấu trúc gõ đặc biệt để chỉ ra cho người kiểm tra loại 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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

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

Mới trong phiên bản 3. 8

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

420¶

Một loại, được giới thiệu trong PEP 593 [_______3421], để trang trí các loại hiện có với siêu dữ liệu theo ngữ cảnh cụ thể [có thể là nhiều phần của nó, vì

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 là biến thể]. Cụ thể, loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63 có thể được chú thích bằng siêu dữ liệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

424 thông qua gợi ý đánh máy

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

425. Siêu dữ liệu này có thể được sử dụng cho 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 một gợi ý đánh chữ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

425 và không có logic đặc biệt nào cho siêu dữ liệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

424, thì thư viện đó sẽ bỏ qua nó và chỉ coi loại đó là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63. Không giống như chức năng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

429 hiện có trong mô-đun

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

07 vô hiệu hóa hoàn toàn các chú thích kiểm tra đánh máy trên một hàm hoặc một lớp, loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 cho phép cả kiểm tra đánh máy tĩnh của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63 [có thể bỏ qua

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

424 một cách an toàn] cùng với quyền truy cập thời gian chạy vào

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

424 trong một ứng dụng cụ thể

Cuối cùng, trách nhiệm về cách giải thích 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16. Một công cụ hoặc thư viện gặp loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 có thể quét qua các chú thích để xác định xem chúng có đáng quan tâm hay không [e. g. , sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

414]

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

Tùy thuộc vào công cụ sử dụng các chú thích để quyết định xem máy khách có được phép có nhiều chú thích trên một loại hay không và cách hợp nhất các chú thích đó

Vì loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 cho phép bạn đặt một số chú thích cùng [hoặc khác] loại trên bất kỳ nút nào, nên các công cụ hoặc thư viện sử dụng các chú thích đó sẽ chịu trách nhiệm xử lý các bản sao tiềm ẩn. 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

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Chuyển

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

439 đến

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

440 cho phép một người truy cập các chú thích bổ sung khi chạy

Chi tiết cú pháp

Đối số đầu tiên của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 phải là loại hợp lệ

Nhiều loại chú thích được hỗ trợ [

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 hỗ trợ các đối số biến đổi]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 phải được gọi với ít nhất hai đối số [

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

444 không hợp lệ]

Thứ tự của các chú thích được giữ nguyên và các vấn đề cần kiểm tra bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 lồng nhau được làm phẳng, với siêu dữ liệu được sắp xếp bắt đầu bằng chú thích trong cùng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các chú thích trùng lặp không bị xóa

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 có thể được sử dụng với bí danh lồng nhau và bí danh chung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 9

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

448¶

Biểu mẫu nhập đặc biệt được sử dụng để chú thích kiểu trả về của hàm bảo vệ kiểu do người dùng xác định.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

23 chỉ chấp nhận một đối số loại duy nhất. Khi chạy, các hàm được đánh dấu theo cách này sẽ trả về một giá trị boolean

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

23 nhằm mục đích mang lại lợi ích cho việc thu hẹp loại – một kỹ thuật được sử dụng bởi trình kiểm tra loại tĩnh để xác định loại biểu thức chính xác hơn trong luồng mã của chương trình. Thông thường, việc 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 cho một khối mã. Biểu thức điều kiện ở đây đôi khi được gọi là "loại bảo vệ"

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Đôi khi sẽ thuận tiện khi sử dụng hàm boolean do người dùng định nghĩa làm bộ bảo vệ kiểu. Một chức năng như vậy nên sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

451 làm kiểu trả về của nó để cảnh báo những người kiểm tra kiểu tĩnh về ý định này

Sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

452 báo cho trình kiểm tra kiểu tĩnh rằng đối với một chức năng nhất định

Giá trị trả về là một boolean

Nếu giá trị trả về là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453, loại đối số của nó là loại bên trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Nếu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

455 là một phương thức lớp hoặc thể hiện, thì kiểu trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

23 ánh xạ tới kiểu của tham số thứ hai sau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

457 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

458

Tóm lại, dạng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

459, có nghĩa là nếu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

460 trả về

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453, thì

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

462 thu hẹp từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

463 thành

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

464

Ghi chú

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

464 không nhất thiết phải là dạng hẹp hơn của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

463 – nó thậm chí có thể là dạng rộng hơn. Lý do chính là để cho phép những thứ như thu hẹp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

467 thành

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

468 mặc dù cái sau không phải là kiểu con của cái trước, vì

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

469 là bất biến. Trách nhiệm viết các bộ bảo vệ loại an toàn thuộc về người dùng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

23 cũng hoạt động với các biến kiểu. Để biết thêm thông tin, hãy xem PEP 647 [Người dùng xác định loại bảo vệ]

Mới trong phiên bản 3. 10

Xây dựng các loại chung¶

Chúng không được sử dụng trong chú thích. Họ đang xây dựng các khối để tạo các loại chung

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

472¶

Lớp cơ sở trừu tượng cho các loại chung

Một kiểu chung thường được khai báo bằng cách kế thừa từ một phần khởi tạo của lớp này với một hoặc nhiều biến kiểu. Ví dụ: loại ánh xạ chung có thể được định nghĩa là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lớp này sau đó có thể được sử dụng như sau

Lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____3474¶

Loại biến

Cách sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Biến loại tồn tại chủ yếu vì lợi ích của trình kiểm tra loại tĩnh. Chúng đóng vai trò là tham số cho các kiểu chung cũng như cho các định nghĩa hàm chung. Xem

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02 để biết thêm thông tin về các loại chung. Các chức năng chung hoạt động như sau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

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ể vừa bị ràng buộc vừa bị ràng buộc

Biến kiểu ràng buộc và biến kiểu ràng buộc có ngữ nghĩa khác nhau theo một số cách quan trọng. Sử dụng một biến loại bị ràng buộc có nghĩa là chỉ có thể giải quyết vấn đề

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

01 như là một trong những ràng buộc đã cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Tuy nhiên, việc sử dụng một biến loại ràng buộc có nghĩa là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

01 sẽ được giải quyết bằng cách sử dụng loại cụ thể nhất có thể

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các biến loại có thể được liên kết với các loại cụ thể, loại trừu tượng [ABC hoặc giao thức] và thậm chí cả các loại kết hợp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các biến loại giới hạn đặc biệt hữu ích để chú thích

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

478 đóng vai trò là các hàm tạo thay thế. Trong ví dụ sau [của Raymond Hettinger], biến kiểu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089 được liên kết với lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

480 thông qua việc sử dụng tham chiếu chuyển tiếp. Sử dụng biến loại này để chú thích phương thức lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

481, thay vì mã hóa cứng loại trả về là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

480, có nghĩa là trình kiểm tra loại có thể suy luận chính xác loại trả về ngay cả khi phương thức được gọi trên một lớp con

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Khi chạy,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

483 sẽ tăng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

409. Nói chung, không nên sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

414 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

415 với các loại

Các biến loại có thể được đánh dấu hiệp biến hoặc chống biến bằng cách chuyển

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

487 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

488. 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

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______3490 [tên , *, bound=None, covariant=False, contravariant=False]¶

Thông số kỹ thuật biến. Một phiên bản chuyên biệt của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

491

Cách sử dụng

Các biến đặc tả tham số tồn tại chủ yếu vì lợi ích của trình kiểm tra kiểu tĩnh. Chúng được sử dụng để chuyển tiếp các loại tham số của một hàm có thể gọi này sang một hàm có thể gọi khác - một mẫu thường thấy trong các hàm và trình trang trí bậc cao hơn. Chúng chỉ hợp lệ khi được sử dụng trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21 hoặc làm đối số đầu tiên cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00 hoặc làm tham số cho Generics do người dùng xác định. Xem

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02 để biết thêm thông tin về các loại chung

Ví dụ: để thêm chức năng ghi nhật ký cơ bản, người ta có thể tạo trình trang trí

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

495 để ghi nhật ký các cuộc gọi chức năng. Biến đặc tả tham số cho trình kiểm tra kiểu biết rằng có thể gọi được chuyển vào trình trang trí và có thể gọi mới được trả về bởi nó có các tham số loại phụ thuộc lẫn nhau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Nếu không có

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20, cách đơn giản nhất để chú thích điều này trước đây là sử dụng một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

01 với ràng buộc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

062. Tuy nhiên điều này gây ra hai vấn đề

Trình kiểm tra loại không thể gõ kiểm tra chức năng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

499 vì

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

500 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

501 phải được gõ

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

503 có thể được yêu cầu trong phần thân của trình trang trí

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

495 khi trả về hàm

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

499 hoặc trình kiểm tra kiểu tĩnh phải được yêu cầu bỏ qua

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

506

________ 3507¶ ________ 3508¶

Vì

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 nắm bắt cả tham số vị trí và từ khóa, nên có thể sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

510 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

511 để chia một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

510 đại diện cho bộ 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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

500.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

511 đại diện cho ánh xạ của các tham số từ khóa với 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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

501. Cả hai thuộc tính đều yêu cầu tham số được chú thích nằm trong phạm vi. Khi chạy,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

510 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

511 lần lượt là các thể hiện của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

519 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

520

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]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

487 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

488 có thể được sử dụng để khai báo các loại chung biến thể hoặc phản biến. Đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

523 cũng được chấp nhận, tương tự như đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

01. Tuy nhiên, ngữ nghĩa thực tế của những 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 chọn

Xem thêm

PEP 612 – Biến thông số kỹ thuật tham số [PEP đã giới thiệu

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

21]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

530¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

532¶

Đối số và thuộc tính đối số từ khóa của một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20. Thuộc tính

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

510 của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

20 là một thể hiện của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

519 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

511 là một thể hiện của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

520. Chúng được dành cho nội quan thời gian chạy và không có ý nghĩa đặc biệt đối với trình kiểm tra kiểu tĩnh

Gọi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

539 trên một trong hai đối tượng này sẽ trả về bản gốc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 10

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

542¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

543 là một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

544 được định nghĩa là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

545

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 lẫn. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

80class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

547 [Chung] ¶

Lớp cơ sở cho các lớp giao thức. Các lớp giao thức được định nghĩa như thế này

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các lớp như vậy chủ yếu được sử dụng với các trình kiểm tra kiểu tĩnh nhận biết kiểu con cấu trúc [gõ vịt tĩnh], chẳng hạn

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Xem PEP 544 để biết chi tiết. Các lớp giao thức được trang trí bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

548 [được mô tả sau] hoạt động như các giao thức thời gian chạy có đầu óc đơn giản, chỉ kiểm tra sự hiện diện của các thuộc tính đã cho, bỏ qua chữ ký loại của chúng

Các lớp giao thức có thể chung chung, ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 8

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020______3551¶

Đánh dấu một lớp giao thức là một giao thức thời gian chạy

Một giao thức như vậy có thể được sử dụng với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

414 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

415. Điều này làm tăng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

409 khi áp dụng cho một lớp phi giao thức. Điều này cho phép kiểm tra cấu trúc đơn giản, rất giống với “one trick pony” trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

555 chẳng hạn như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

010. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ghi chú

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

548 sẽ chỉ kiểm tra sự hiện diện của các phương thức được yêu cầu, không phải chữ ký loại của chúng. Ví dụ:

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

558 là một lớp, do đó, nó vượt qua kiểm tra

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

415 đối với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

00. Tuy nhiên, phương thức

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

561 chỉ tồn tại để gọi một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

409 với thông báo nhiều thông tin hơn, do đó không thể gọi [khởi tạo]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

558

Mới trong phiên bản 3. 8

Các chỉ thị đặc biệt khác¶

Chúng không được sử dụng trong chú thích. Họ đang xây dựng các khối để khai báo các loại

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

565¶

Phiên bản đánh máy của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

566

Cách sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Điều này tương đương với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Để cung cấp cho một trường một giá trị mặc định, bạn có thể gán cho nó trong nội dung lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Các trường có giá trị mặc định phải xuất hiện sau bất kỳ trường nào không có giá trị mặc định

Lớp kết quả có một thuộc tính bổ sung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

567 đưa ra một lệnh ánh xạ tên trường với các loại trường. [Tên trường nằm trong thuộc tính ________ 3568 và các giá trị mặc định nằm trong thuộc tính ________ 3569, cả hai thuộc tính này đều là một phần của API

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

570. ]

Các lớp con

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

571 cũng có thể có các tài liệu và phương thức

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Sử dụng tương thích ngược

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Đã thay đổi trong phiên bản 3. 6. Đã thêm hỗ trợ cho cú pháp chú thích biến PEP 526.

Đã thay đổi trong phiên bản 3. 6. 1. Đã thêm hỗ trợ cho các giá trị, phương thức và chuỗi tài liệu mặc định.

Đã thay đổi trong phiên bản 3. 8. Các thuộc tính

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

572 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

567 hiện là từ điển thông thường thay vì phiên bản của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

574.

Đã thay đổi trong phiên bản 3. 9. Đã xóa thuộc tính

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

572 để sử dụng thuộc tính

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

567 tiêu chuẩn hơn có cùng thông tin.

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____3578 [tên , tp]¶

Một lớp trợ giúp để chỉ ra một loại riêng biệt cho trình kiểm tra đánh máy, hãy xem NewType . Khi chạy, nó trả về một đối tượng trả về đối số của nó khi được gọi. Cách sử dụng.

def greeting[name: str] -> str:
    return 'Hello ' + name

Mới trong phiên bản 3. 5. 2

Đã thay đổi trong phiên bản 3. 10. ______228 bây giờ là một lớp chứ không phải là một hàm.

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____3581 [dict] ¶

Cấu trúc đặc biệt để thêm gợi ý loại vào từ điển. Khi chạy nó là một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

582 đơn giản

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 khai báo một loại từ điển yêu cầu tất cả các phiên bản của nó có một bộ khóa nhất định, trong đó mỗi khóa được liên kết với một giá trị của một loại nhất quán. Kỳ vọng này không được kiểm tra trong thời gian chạy mà chỉ được thực thi bởi trình kiểm tra loại. Cách sử dụng

def greeting[name: str] -> str:
    return 'Hello ' + name

Để cho phép sử dụng tính năng này với các phiên bản Python cũ hơn không hỗ trợ PEP 526,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 hỗ trợ thêm hai dạng cú pháp tương đương

def greeting[name: str] -> str:
    return 'Hello ' + name

Cú pháp chức năng cũng nên được sử dụng khi bất kỳ khóa nào không có mã định danh hợp lệ, chẳng hạn như vì chúng là từ khóa hoặc chứa dấu gạch nối. Thí dụ.

def greeting[name: str] -> str:
    return 'Hello ' + name

Theo mặc định, tất cả các khóa phải có trong một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13. Có thể ghi đè điều này bằng cách chỉ định tổng số. Cách sử dụng

def greeting[name: str] -> str:
    return 'Hello ' + name

Điều này có nghĩa là một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

586

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 có thể bỏ qua bất kỳ phím nào. Trình kiểm tra loại chỉ được mong đợi để hỗ trợ một chữ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

588 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453 làm giá trị của đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

590.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453 là giá trị mặc định và yêu cầu tất cả các mục được xác định trong nội dung lớp

Loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 có thể kế thừa từ một hoặc nhiều loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 khác bằng cách sử dụng cú pháp dựa trên lớp. Cách sử dụng

def greeting[name: str] -> str:
    return 'Hello ' + name

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

594 có ba mục.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

424,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

596 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

597. Nó tương đương với định nghĩa này

def greeting[name: str] -> str:
    return 'Hello ' + name

Một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 không thể kế thừa từ một lớp không phải ____213, đáng chú ý là bao gồm cả

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

02. Ví dụ

def greeting[name: str] -> str:
    return 'Hello ' + name

Có thể xem xét nội quan một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 thông qua các lệnh chú thích [xem Các phương pháp hay nhất về chú thích để biết thêm thông tin về các phương pháp hay nhất về chú thích],

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

202,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

203 và .

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

205¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

206 đưa ra giá trị của đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

590. Thí dụ

def greeting[name: str] -> str:
    return 'Hello ' + name

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

208¶

Mới trong phiên bản 3. 9

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

209¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

210 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

211 lần lượt trả về các đối tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

212 chứa các khóa bắt buộc và không bắt buộc. Hiện tại, cách duy nhất để khai báo cả khóa bắt buộc và khóa không bắt buộc trong cùng một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 là kế thừa hỗn hợp, khai báo một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 với một giá trị cho đối số

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

590 và sau đó kế thừa nó từ một

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 khác với một giá trị khác cho

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

590. Cách sử dụng

def greeting[name: str] -> str:
    return 'Hello ' + name

Mới trong phiên bản 3. 9

Xem PEP 589 để biết thêm ví dụ và quy tắc chi tiết về việc sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 8

Bộ sưu tập bê tông chung¶

Tương ứng với các loại tích hợp¶

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4220 [ dict, MutableMapping[KT, VT] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

582. Hữu ích cho việc chú thích các loại trả lại. Để chú thích các đối số, nên sử dụng loại bộ sưu tập trừu tượng, chẳng hạn như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

222

Loại này có thể được sử dụng như sau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

50class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

224 [ list, MutableSequence[T] ]¶

Phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

225. Hữu ích cho việc chú thích các loại trả lại. Để chú thích các đối số, nên sử dụng loại tập hợp trừu tượng, chẳng hạn như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

226 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

010

Loại này có thể được sử dụng như sau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

51class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

229 [ set, MutableSet[T] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

230. Hữu ích cho việc chú thích các loại trả lại. Để chú thích các đối số, nên sử dụng loại bộ sưu tập trừu tượng, chẳng hạn như

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

231

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4233 [ frozenset, AbstractSet[T_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

234

Ghi chú

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

036 là một dạng đặc biệt

Tương ứng với các loại trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

236¶

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4238 [ bộ sưu tập. defaultdict, MutableMapping[KT, VT] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

239

Mới trong phiên bản 3. 5. 2

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4241 [ bộ sưu tập. OrderedDict, MutableMapping[KT, VT] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

242

Mới trong phiên bản 3. 7. 2

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4244 [ bộ sưu tập. ChainMap, MutableMapping[KT, VT] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

245

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 1

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4247 [ bộ sưu tập. Bộ đếm, Dict[T, int] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

248

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 1

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4250 [ deque, MutableSequence[T] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

251

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 1

Các loại bê tông khác¶

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

253¶ lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4255¶ lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

257¶

Loại chung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

258 và các lớp con của nó

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

259 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

260 đại diện cho các loại luồng I/O, chẳng hạn như được trả về bởi

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

261

Không dùng nữa kể từ phiên bản 3. 8, sẽ bị xóa trong phiên bản 3. 12. Không gian tên

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

262 không được dùng nữa và sẽ bị xóa. Thay vào đó, các loại này nên được nhập trực tiếp từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

07.

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4265¶ lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

267¶

Các bí danh loại này tương ứng với các loại trả về từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

268 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

269. Các loại này [và các chức năng tương ứng] là chung chung trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

543 và có thể được cụ thể hóa bằng cách viết

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

271,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

272,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

273 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

274

Không dùng nữa kể từ phiên bản 3. 8, sẽ bị xóa trong phiên bản 3. 12. Không gian tên

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

275 không được dùng nữa và sẽ bị xóa. Thay vào đó, các loại này nên được nhập trực tiếp từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

07.

Không dùng nữa kể từ phiên bản 3. 9. Các lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

277 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

278 từ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

279 hiện hỗ trợ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

016. Xem PEP 585 và Loại bí danh chung .

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

282¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

283 là bí danh của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

05. Nó được cung cấp để cung cấp đường dẫn tương thích chuyển tiếp cho mã Python 2. trong Python 2,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

283 là bí danh của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

286

Sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

283 để cho biết rằng một giá trị phải chứa chuỗi unicode theo cách tương thích với cả Python 2 và Python 3

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 5. 2

Các lớp cơ sở trừu tượng¶

Tương ứng với các bộ sưu tập trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

555¶

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4290 [ Sized, Collection[T_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

291

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4293 [ Sequence[int] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

294

Loại này đại diện cho các loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

295,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

296 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

297 của chuỗi byte

Là cách viết tắt của loại này, có thể sử dụng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

295 để chú thích các đối số thuộc bất kỳ loại nào được đề cập ở trên

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4800 [ Sized, Iterable[T_co], Container[T_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

801

Mới trong phiên bản 3. 6. 0

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4803 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

804

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4806 [ MappingView, Generic[KT_co, VT_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

807

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4809 [ MappingView[KT_co], AbstractSet[KT_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

810

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4812 [ Sized, Collection[KT], Generic[VT_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

813. Loại này có thể được sử dụng như sau

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

53class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

815 [ Sized, Iterable[T_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

816

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4818 [ Lập bản đồ[KT, VT] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

819

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4821 [ Sequence[T] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

822

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4824 [ AbstractSet[T] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

825

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4827 [ Có thể đảo ngược[T_co], Bộ sưu tập[T_co] ]¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

828

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4830 [ MappingView[VT_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

831

Tương ứng với các loại khác trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

555¶

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4834 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

835

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4837 [ Có thể lặp lại[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

838

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4840 [ Iterator[T_co], Generic[T_co, T_contra, V_co] ] Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]] 841. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Lưu ý rằng không giống như nhiều thuốc generic khác trong mô-đun đánh máy,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

842 của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

843 hoạt động trái ngược, không đồng biến hoặc bất biến

Nếu trình tạo của bạn chỉ mang lại giá trị, hãy đặt

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

842 và

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

060 thành

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ngoài ra, hãy chú thích trình tạo của bạn có kiểu trả về là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

847 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

848

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

56lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4850¶

Bí danh của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

851

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4853 [ Có thể lặp lại[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

854

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4856¶

Bí danh của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

857

Lập trình không đồng bộ¶

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4859 [ Awaitable[V_co], Generic[T_co, T_contra, V_co] ] Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]] 860. Ví dụ, phương sai và thứ tự của các biến loại tương ứng với biến của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

843

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Mới trong phiên bản 3. 5. 3

class

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4863 [ AsyncIterator[T_co], Generic[T_co, T_contra] ]¶

Trình tạo không đồng bộ có thể được chú thích theo loại chung

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

864. Ví dụ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Không giống như các trình tạo thông thường, trình tạo không đồng bộ không thể trả về giá trị, vì vậy không có tham số loại

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

060. Như với

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

843,

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

842 hoạt động trái ngược

Nếu trình tạo của bạn chỉ mang lại giá trị, hãy đặt

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

842 thành

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

Ngoài ra, hãy chú thích trình tạo của bạn có kiểu trả về là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

870 hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

871

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Mới trong phiên bản 3. 6. 1

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4873 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

874

Mới trong phiên bản 3. 5. 2

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4876 [ AsyncIterable[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

877

Mới trong phiên bản 3. 5. 2

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020_______4879 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

880

Mới trong phiên bản 3. 5. 2

Các loại trình quản lý ngữ cảnh¶

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4882 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

883

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 0

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4885 [ Chung[T_co] ] ¶

Một phiên bản chung của

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

886

Mới trong phiên bản 3. 5. 4

Mới trong phiên bản 3. 6. 2

Giao thức¶

Các giao thức này được trang trí bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

548

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____4889¶

Một ABC với một phương thức trừu tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

890 đồng biến trong kiểu trả về của nó

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

892¶

Một ABC với một phương pháp trừu tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

893

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

895¶

Một ABC với một phương pháp trừu tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

896

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

898¶

Một ABC với một phương pháp trừu tượng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

899

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

101¶

Một ABC với một phương pháp trừu tượng

def greeting[name: str] -> str:
    return 'Hello ' + name

102

Mới trong phiên bản 3. 8

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

104¶

Một ABC với một phương pháp trừu tượng

def greeting[name: str] -> str:
    return 'Hello ' + name

105

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

107¶

Một ABC với một phương thức trừu tượng

def greeting[name: str] -> str:
    return 'Hello ' + name

108 đồng biến trong kiểu trả về của nó

Chức năng và trang trí¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

110 [typ , val]¶

Truyền một giá trị cho một loại

Điều này trả về giá trị không thay đổi. Đối với trình kiểm tra loại, điều này báo hiệu rằng giá trị trả về có loại được chỉ định, nhưng trong thời gian chạy, chúng tôi cố tình không kiểm tra bất kỳ thứ gì [chúng tôi muốn điều này càng nhanh càng tốt]

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____5113¶

Trình trang trí

def greeting[name: str] -> str:
    return 'Hello ' + name

114 cho phép mô tả các hàm và phương thức hỗ trợ nhiều kiểu kết hợp đối số khác nhau. Một loạt các định nghĩa được trang trí ____5114 phải được theo sau bởi chính xác một định nghĩa không được trang trí ____5114 [cho cùng một chức năng/phương thức]. Các định nghĩa được trang trí ____5114 chỉ dành cho lợi ích của trình kiểm tra loại, vì chúng sẽ bị ghi đè bởi định nghĩa không được trang trí ____5114, trong khi định nghĩa sau được sử dụng trong thời gian chạy nhưng nên được trình kiểm tra loại bỏ qua. Khi chạy, gọi trực tiếp một hàm được trang trí bằng

def greeting[name: str] -> str:
    return 'Hello ' + name

114 sẽ tăng

def greeting[name: str] -> str:
    return 'Hello ' + name

120. Một ví dụ về quá tải cung cấp một loại chính xác hơn có thể được biểu thị bằng cách sử dụng liên kết hoặc biến loại

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Xem PEP 484 để biết chi tiết và so sánh với các ngữ nghĩa đánh máy khác

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____5123¶

Một trình trang trí để chỉ ra cho người kiểm tra loại rằng phương thức được trang trí không thể bị ghi đè và lớp được trang trí không thể được phân lớp. Ví dụ

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

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

Mới trong phiên bản 3. 8

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____5126¶

Trình trang trí để chỉ ra rằng các chú thích không phải là gợi ý loại

Cái này hoạt động như lớp hoặc chức năng trang trí . Với một lớp, nó áp dụng đệ quy cho tất cả các phương thức được định nghĩa trong lớp đó [nhưng không áp dụng cho các phương thức được định nghĩa trong lớp cha hoặc lớp con của nó].

Điều này làm thay đổi [các] chức năng tại chỗ

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____5129¶

Người trang trí để cung cấp cho người trang trí khác hiệu ứng

def greeting[name: str] -> str:
    return 'Hello ' + name

130

Điều này bao bọc công cụ trang trí bằng thứ gì đó bao bọc chức năng được trang trí trong

def greeting[name: str] -> str:
    return 'Hello ' + name

130

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

549

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020____5134¶

Trình trang trí để đánh dấu một lớp hoặc chức năng không khả dụng khi chạy

Bản thân trình trang trí này không có sẵn trong thời gian chạy. Nó chủ yếu nhằm đánh dấu các lớp được định nghĩa trong các tệp sơ khai kiểu nếu việc triển khai trả về một thể hiện của một lớp riêng

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Lưu ý rằng không nên trả lại các phiên bản của các lớp riêng tư. Tốt nhất là công khai các lớp như vậy

Người trợ giúp nội tâm¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

136 [obj , toàn cầu=None, localns=None, include_extras=False]¶

Trả về một từ điển chứa các gợi ý kiểu cho một hàm, phương thức, mô-đun hoặc đối tượng lớp

Điều này thường giống như

def greeting[name: str] -> str:
    return 'Hello ' + name

137. Ngoài ra, các tham chiếu chuyển tiếp được mã hóa dưới dạng chuỗi ký tự được xử lý bằng cách đánh giá chúng trong các không gian tên

def greeting[name: str] -> str:
    return 'Hello ' + name

138 và

def greeting[name: str] -> str:
    return 'Hello ' + name

139. Nếu cần,

def greeting[name: str] -> str:
    return 'Hello ' + name

140 được thêm vào cho chú thích hàm và phương thức nếu giá trị mặc định bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

26 được đặt. Đối với một lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

089, hãy trả về một từ điển được tạo bằng cách hợp nhất tất cả các

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

567 dọc theo

def greeting[name: str] -> str:
    return 'Hello ' + name

144 theo thứ tự ngược lại

Hàm thay thế đệ quy tất cả

def greeting[name: str] -> str:
    return 'Hello ' + name

145 bằng

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

63, trừ khi

def greeting[name: str] -> str:
    return 'Hello ' + name

147 được đặt thành

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453 [xem

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

16 để biết thêm thông tin]. Ví dụ

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Ghi chú

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

440 không hoạt động với loại bí danh đã nhập bao gồm tham chiếu chuyển tiếp. Cho phép đánh giá chú thích bị trì hoãn [PEP 563] có thể loại bỏ nhu cầu đối với hầu hết các tham chiếu chuyển tiếp.

Đã thay đổi trong phiên bản 3. 9. Đã thêm tham số

def greeting[name: str] -> str:
    return 'Hello ' + name

147 như một phần của PEP 593.

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

153 [tp] ¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

155 [tp]¶

Cung cấp nội quan cơ bản cho các loại chung và các hình thức gõ đặc biệt

Đối với một đối tượng gõ có dạng

def greeting[name: str] -> str:
    return 'Hello ' + name

156, các hàm này trả về

def greeting[name: str] -> str:
    return 'Hello ' + name

157 và

def greeting[name: str] -> str:
    return 'Hello ' + name

158. Nếu

def greeting[name: str] -> str:
    return 'Hello ' + name

157 là bí danh chung cho lớp dựng sẵn hoặc lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

236, thì nó sẽ được chuẩn hóa thành lớp ban đầu. Nếu

def greeting[name: str] -> str:
    return 'Hello ' + name

157 là một liên kết hoặc

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

12 được chứa trong một loại chung khác, thứ tự của

def greeting[name: str] -> str:
    return 'Hello ' + name

158 có thể khác với thứ tự của các đối số ban đầu

def greeting[name: str] -> str:
    return 'Hello ' + name

164 do bộ nhớ đệm loại. Đối với các đối tượng không được hỗ trợ, hãy trả về

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

26 và

def greeting[name: str] -> str:
    return 'Hello ' + name

166 tương ứng. ví dụ

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Mới trong phiên bản 3. 8

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

168 [tp] ¶

Kiểm tra xem một loại có phải là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

13 không

Ví dụ

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Mới trong phiên bản 3. 10

lớp

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

171¶

Một lớp được sử dụng để biểu diễn kiểu gõ bên trong của các tham chiếu chuyển tiếp chuỗi. Ví dụ:

def greeting[name: str] -> str:
    return 'Hello ' + name

172 được chuyển ngầm thành

def greeting[name: str] -> str:
    return 'Hello ' + name

173. Lớp này không nên được khởi tạo bởi người dùng, nhưng có thể được sử dụng bởi các công cụ hướng nội

Ghi chú

Các loại chung của PEP 585 chẳng hạn như

def greeting[name: str] -> str:
    return 'Hello ' + name

174 sẽ không được chuyển đổi hoàn toàn thành

def greeting[name: str] -> str:
    return 'Hello ' + name

175 và do đó sẽ không tự động phân giải thành

def greeting[name: str] -> str:
    return 'Hello ' + name

176

Mới trong phiên bản 3. 7. 4

Không thay đổi¶

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

020

def greeting[name: str] -> str:
    return 'Hello ' + name

178¶

Một hằng số đặc biệt được giả định là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

453 bởi trình kiểm tra loại tĩnh của bên thứ 3. Đó là

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

588 trong thời gian chạy. Cách sử dụng

from collections.abc import Mapping, Sequence

def notify_by_email[employees: Sequence[Employee],
                    overrides: Mapping[str, str]] -> None: ...

Chú thích loại đầu tiên phải được đặt trong dấu ngoặc kép, làm cho nó trở thành "tham chiếu chuyển tiếp", để ẩn tham chiếu

def greeting[name: str] -> str:
    return 'Hello ' + name

181 khỏi thời gian chạy trình thông dịch. Loại chú thích cho các biến cục bộ không được đánh giá, vì vậy chú thích thứ hai không cần phải được đặt trong dấu ngoặc kép

Ghi chú

Nếu sử dụng

def greeting[name: str] -> str:
    return 'Hello ' + name

182, các chú thích sẽ không được đánh giá tại thời điểm định nghĩa hàm. Thay vào đó, chúng được lưu trữ dưới dạng chuỗi trong

Vector = list[float]

def scale[scalar: float, vector: Vector] -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale[2.0, [1.0, -4.2, 5.4]]

567. Điều này làm cho việc sử dụng dấu ngoặc kép xung quanh chú thích là không cần thiết [xem PEP 563]

PEP liên quan¶

Nhập bí danh¶

Kiểu mới¶

Có thể gọi¶

Thuốc generic¶

Loại chung do người dùng định nghĩa¶

Loại bất kỳ¶

Phân nhóm danh nghĩa và phân nhóm cấu trúc¶

Nội dung học phần¶

Kiểu gõ đặc biệt¶

Các loại đặc biệt¶

Biểu mẫu đặc biệt¶

Xây dựng các loại chung¶

Các chỉ thị đặc biệt khác¶

Bộ sưu tập bê tông chung¶

Tương ứng với các loại tích hợp¶

Tương ứng với các loại trong Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]] 236¶

Các loại bê tông khác¶

Các lớp cơ sở trừu tượng¶

Tương ứng với các bộ sưu tập trong Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]] 555¶

Tương ứng với các loại khác trong Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]] 555¶

Lập trình không đồng bộ¶

Các loại trình quản lý ngữ cảnh¶

Giao thức¶

Chức năng và trang trí¶

Người trợ giúp nội tâm¶

Không thay đổi¶

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Tương ứng với các loại trong
Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]]
236¶

Tương ứng với các bộ sưu tập trong
Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]]
555¶

Tương ứng với các loại khác trong
Vector = list[float] def scale[scalar: float, vector: Vector] -> Vector: return [scalar * num for num in vector] # typechecks; a list of floats qualifies as a Vector. new_vector = scale[2.0, [1.0, -4.2, 5.4]]
555¶