How Do You Specify Multiple Return Types with Type Hints in Python?

Specifying Multiple Return Types with Type Hints in Python

Python's type hints allow you to specify the expected data types for function parameters and return values. When a function can return multiple types, the question arises on how to accurately represent this in type hints.

Union Type (Python 3.10 and Later)

In Python 3.10 and subsequent versions, the | operator can be used to create a union type. This enables a concise and clear notation for multiple return types. For example:

def foo(client_id: str) -> list | bool:

This indicates that the foo function can return either a list or a boolean.

Typing.Union (Earlier Python Versions)

For earlier Python versions, the typing.Union class must be utilized:

from typing import Union

def foo(client_id: str) -> Union[list, bool]:

Limitations

It's important to note that type hinting in Python is not enforced at runtime. Therefore, it serves as a development-time aid rather than a strict type-checking mechanism. Functions can still return unexpected types, as exemplified below:

>>> def foo(a: str) -> list:
...     return "Works"
...

>>> foo(1)
'Works'

In this case, although the function is annotated to return a list, it returns a string. However, the annotations attribute will reflect the intended return type:

>>> foo.__annotations__ 
{'return': <class 'list'>, 'a': <class 'str'>}

Refer to PEP 483 for further details on type hints in Python. For additional insights, consider reading "What are type hints in Python 3.5??" With these techniques, you can accurately specify multiple return types in your Python code, enhancing its readability and maintainability.

The above is the detailed content of How Do You Specify Multiple Return Types with Type Hints in Python?. For more information, please follow other related articles on the PHP Chinese website!