Các kiểu trả về của hàm Python

Biến

Về mặt kỹ thuật, nhiều chú thích loại hiển thị bên dưới là dư thừa, vì mypy thường có thể suy ra loại biến từ giá trị của nó. Xem để biết thêm chi tiết

# This is how you declare the type of a variable
age: int = 1

# You don't need to initialize a variable to annotate it
a: int  # Ok [no value at runtime until assigned]

# Doing so is useful in conditional branches
child: bool
if age  int:
    return num1 + num2

# If a function does not return a value, use None as the return type
# Default value for an argument goes after the type annotation
def show[value: str, excitement: int = 10] -> None:
    print[value + "!" * excitement]

# This is how you annotate a callable [function] value
x: Callable[[int, float], float] = f

# A generator function that yields ints is secretly just a function that
# returns an iterator of ints, so that's how we annotate it
def g[n: int] -> Iterator[int]:
    i = 0
    while i  bool:
    ...

# Mypy understands positional-only and keyword-only arguments
# Positional-only arguments can also be marked by using a name starting with
# two underscores
def quux[x: int, / *, y: int] -> None:
    pass

quux[3, y=5]  # Ok
quux[3, 5]  # error: Too many positional arguments for "quux"
quux[x=3, y=5]  # error: Unexpected keyword argument "x" for "quux"

# This says each positional arg and each keyword arg is a "str"
def call[self, *args: str, **kwargs: str] -> str:
    reveal_type[args]  # Revealed type is "tuple[str, ...]"
    reveal_type[kwargs]  # Revealed type is "dict[str, str]"
    request = make_request[*args, **kwargs]
    return self.do_api_query[request]

Các lớp học

class MyClass:
    # You can optionally declare instance variables in the class body
    attr: int
    # This is an instance variable with a default value
    charge_percent: int = 100

    # The "__init__" method doesn't return anything, so it gets return
    # type "None" just like any other method that doesn't return anything
    def __init__[self] -> None:
        ...

    # For instance methods, omit type for "self"
    def my_method[self, num: int, str1: str] -> str:
        return num * str1

# User-defined classes are valid as types in annotations
x: MyClass = MyClass[]

# You can also declare the type of an attribute in "__init__"
class Box:
    def __init__[self] -> None:
        self.items: list[str] = []

# You can use the ClassVar annotation to declare a class variable
class Car:
    seats: ClassVar[int] = 4
    passengers: ClassVar[list[str]]

# If you want dynamic attributes on your class, have it
# override "__setattr__" or "__getattr__":
# - "__getattr__" allows for dynamic access to names
# - "__setattr__" allows for dynamic assignment to names
class A:
    # This will allow assignment to any A.x, if x is the same type as "value"
    # [use "value: Any" to allow arbitrary types]
    def __setattr__[self, name: str, value: int] -> None: ...

    # This will allow access to any A.x, if x is compatible with the return type
    def __getattr__[self, name: str] -> int: ...

a.foo = 42  # Works
a.bar = 'Ex-parrot'  # Fails type checking

Khi bạn bối rối hoặc khi mọi thứ trở nên phức tạp

from typing import Union, Any, Optional, TYPE_CHECKING, cast

# To find out what type mypy infers for an expression anywhere in
# your program, wrap it in reveal_type[].  Mypy will print an error
# message with the type; remove it again before running the code.
reveal_type[1]  # Revealed type is "builtins.int"

# If you initialize a variable with an empty container or "None"
# you may have to help mypy a bit by providing an explicit type annotation
x: list[str] = []
x: Optional[str] = None

# Use Any if you don't know the type of something or it's too
# dynamic to write a type for
x: Any = mystery_function[]
# Mypy will let you do anything with x!
x.whatever[] * x["you"] + x["want"] - any[x] and all[x] is super  # no errors

# Use a "type: ignore" comment to suppress errors on a given line,
# when your code confuses mypy or runs into an outright bug in mypy.
# Good practice is to add a comment explaining the issue.
x = confusing_function[]  # type: ignore  # confusing_function won't return None here because ...

# "cast" is a helper function that lets you override the inferred
# type of an expression. It's only for mypy -- there's no runtime check.
a = [4]
b = cast[list[int], a]  # Passes fine
c = cast[list[str], a]  # Passes fine despite being a lie [no runtime check]
reveal_type[c]  # Revealed type is "builtins.list[builtins.str]"
print[c]  # Still prints [4] .. the object is not changed or casted at runtime

# Use "TYPE_CHECKING" if you want to have code that mypy can see but will not
# be executed at runtime [or to have code that mypy can't see]
if TYPE_CHECKING:
    import json
else:
    import orjson as json  # mypy is unaware of this

Trong một số trường hợp, chú thích loại có thể gây ra sự cố trong thời gian chạy, hãy xem cách xử lý vấn đề này

Các loại vịt tiêu chuẩn

Trong mã Python điển hình, nhiều hàm có thể lấy một danh sách hoặc một lệnh làm đối số chỉ cần đối số của chúng là “giống như danh sách” hoặc “giống như chính tả” bằng cách nào đó. Một ý nghĩa cụ thể của “list-like” hoặc “dict-like” [hoặc something-other-like] được gọi là “duck type” và một số loại duck phổ biến trong Python thành ngữ được chuẩn hóa

Hàm Python có thể trả về các loại khác nhau không?

4 loại hàm trong Python là gì?

Kiểu Python[] trả về cái gì?

Hàm có thể trả về một kiểu không?