Using type prompts in Python improves code readability and maintainability and supports static checking. 1. Basic type prompts such as def greet(name: str, age: int) -> str: return f"Hello, {name}. You are {age} years old." 2. Complex types need to be imported List, Dict, and Optional, such as List[Dict[str, Optional[int]]] represents a dictionary list, the value can be int or None, and the return Optional[str] means that the parameter or return value can be int or str, Python 3.10 can be abbreviated as int | str; 4. Callable[[int, int], int] is used for function parameters, representing a function that accepts two ints and returns int; 5. Type alias can be defined such as Student = Dict[str, int] and Students = List[Student] to enhance readability; 6. Python 3.9 supports the direct use of built-in generics such as list[str], dict[str, int]. Type prompts do not affect the operation, but they help team collaboration and error detection, ultimately improving the quality of the code.

Using Type Hints in Python can make functions clearer and easier to maintain, and also facilitate error detection by static type checking tools such as mypy . Below is a typical function example with type prompts covering common type usage.

? Basic function type prompt example

 def greet(name: str, age: int) -> str:
    return f"Hello, {name}. You are {age} years old."

• name: str means that the parameter name should be of string type.
• age: int means that the parameter age should be of integer type.
• -> str means that the return value of the function is of string type.

? Use complex types (List, Dict, Optional)

 from typing import List, Dict, Optional

def process_students(
    students: List[Dict[str, Optional[int]]]
) -> Optional[str]:
    If not students:
        return None
    total = sum(s["age"] for s in students if s["age"] is not None)
    return f"Total age: {total}"

illustrate:

• List[Dict[str, Optional[int]]] : represents a list, each element is a dictionary, the dictionary's key is a string, and the value is an integer or None .
• Optional[str] : equivalent to Union[str, None] , indicating that the return value can be a string or None .

?Using Union (multiple possible types)

 from typing import Union

def square_or_repeat(value: Union[int, str]) -> Union[int, str]:
    if isinstance(value, int):
        return value ** 2
    elif isinstance(value, str):
        return value * 2
    else:
        raise TypeError("Value must be int or str")

• Union[int, str] means that the parameter or return value can be int or str .

?? In Python 3.10, it can be written more concisely:

 def square_or_repeat(value: int | str) -> int | str:
    ...

? Function as parameter (Callable)

 from typing import Callable

def apply_operation(x: int, y: int, op: Callable[[int, int], int]) -> int:
    return op(x, y)

# Use example result = apply_operation(3, 4, lambda a, b: ab) # Return 7

• Callable[[int, int], int] means: a function that accepts two int parameters and returns int .

? Custom Type Alias

 from typing import List, Dict

Student = Dict[str, int]
Students = List[Student]

def average_age(students: Students) -> float:
    If not students:
        return 0.0
    return sum(s["age"] for s in students) / len(students)

• Students is a type alias that improves code readability.

Summary: Common Type Import

 from typing import List, Dict, Tuple, Set, Optional, Union, Callable, Any

Or in Python 3.9, the built-in types already support generics (such as list , dict ), and you can use it directly:

 def example(items: list[str]) -> dict[str, int]:
    return {item: len(item) for item in items}

Basically these common uses. Type prompts don't affect the run, but are very helpful for team collaboration and code quality.

The above is the detailed content of python type hint function example. For more information, please follow other related articles on the PHP Chinese website!