I have a function in python that can either return a bool or a list. Is there a way to specify the types using type hints?
For example, is this the correct way to do it?
def foo(id) -> list or bool:
...
-
34@PadraicCunningham Perhaps the implementation is I'll send you my Id, you send me either a list or a boolean :DBhargav Rao– Bhargav Rao2015-11-26 19:10:20 +00:00Commented Nov 26, 2015 at 19:10
-
8@PadraicCunningham Polymorphism. If your function performs a check on the input, whatever it is, you want to get a boolean when you feed one variable or get a list of booleans when you feed a list of variables.Guimoute– Guimoute2020-02-20 16:33:17 +00:00Commented Feb 20, 2020 at 16:33
-
5seems like a XY problem. I'd ask why a function would return a list or a bool in the first place.Carlo– Carlo2022-10-05 17:52:21 +00:00Commented Oct 5, 2022 at 17:52
-
To return multiple types, you have to use a Tuple stackoverflow.com/questions/58101021/…Nav– Nav2023-02-05 06:42:25 +00:00Commented Feb 5, 2023 at 6:42
Add a comment
|
4 Answers
From the documentation - Union Type:
A union object holds the value of the
|(bitwise or) operation on multiple type objects. These types are intended primarily for type annotations. The union type expression enables cleaner type hinting syntax compared totyping.Union.
This use of | was added in Python 3.10. Hence the proper way to represent more than one return data type is:
def foo(client_id: str) -> list | bool:
For earlier versions, use typing.Union:
from typing import Union
def foo(client_id: str) -> Union[list, bool]:
But do note that typing is not enforced. Python continues to remain a dynamically-typed language. The annotation syntax has been developed to help during the development of the code prior to being released into production. As PEP 484 states, "no type checking happens at runtime."
>>> def foo(a: str) -> list:
... return "Works"
...
>>> foo(1)
'Works'
As you can see I am passing an int value and returning a str. However the __annotations__ will be set to the respective values.
>>> foo.__annotations__
{'return': <class 'list'>, 'a': <class 'str'>}
Please go through PEP 483 for more about Type hints. Also see What are type hints in Python 3.5??
Kindly note that this is available only for Python 3.5 and upwards. This is mentioned clearly in PEP 484.
8 Comments
Bhargav Rao
@YahyaUddin Nope - PEP 484 :'( .... It's only for Python3.5 upwards.
Bhargav Rao
@YahyaUddin Quite surprising. Did you mean Function Annotations by any chance?
Yahya Uddin
So let me see if I got this. Python 3.4 has function annotations that dosen't do anything other than annotate that is NOT enforced. But in Python 3.5 this is actual type checking.
sourcream
@YahyaUddin no. It's 2022 and Python 3.10 is still dynamic and doesn't enforce any typing.
Donald Duck is with Ukraine
If you want typing to be enforced, there are several modules that do that, the one I use is typeguard (I have no association with its author). To use it, do
from typeguard import typechecked, then add @typechecked on a new line before any function or class for which you want typing to be enforced. You may need to do pip install typeguard for this to work. |
Python 3.10 or newer: Use |. Example for a function which takes a single argument that is either an int or str and returns either an int or str:
def func(arg: int | str) -> int | str:
# ^^^^^^^^^ ^^^^^^^^^
# type of arg return type
Python 3.5 - 3.9: Use typing.Union:
from typing import Union
def func(arg: Union[int, str]) -> Union[int, str]:
# ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
# type of arg return type
For the special case of X | None you can use Optional[X].
5 Comments
bballdave025
This answer, to me, is the most helpful and illuminating. It has basically all the other answers' information (except those answers or comments that suggest a non-multiple-type alternative) in a very concise form. Though the OP did not specifically ask about multiple argument types, the description of how to use them as well as multiple return types makes the answer much more complete. Though I give a single-typed example, I also appreciate that the answer removes any confusion (such as I had) as to specifically what was different (if anything) between
foo( bar: int ) and foo( bar ) -> int
xjcl
Thanks for the praise (: I tried to give an answer that was short and visual
Floella
If I use
|, will it be compatible with prior Python versions (since type hinting is just a "hint")? Thanks.
mfurseman
@Floella it will not be compatible, the syntax changed in 3.10 to include the Union operator, before that it is a syntax error.
wjandrea
@mfurseman Actually, it's the operator semantics that changed. It was a
TypeError before, not a syntax error.In case anyone landed here in search of "how to specify types of multiple return values?", use a tuple of [type_value1, ..., type_valueN].
In Python 3.9+:
def f() -> tuple[dict, str]:
a = {1: 2}
b = "hello"
return a, b
In earlier versions, use typing.Tuple:
from typing import Tuple
def f() -> Tuple[dict, str]:
...
3 Comments
Nico Villanueva
As per the docs, this is the correct way to do it (returning N types): docs.python.org/3/library/typing.html#typing.Tuple; whereas returning an Union should actually return ONE of N type values.
CristiFati
What does this have to do with the question?
Anton Khodak
@CristiFati it is a similar question that people may search for and land here. In this case, they don't need to look further. As you see by the number of upvotes, it proved to be useful.
The statement def foo(client_id: str) -> list or bool: when evaluated is equivalent to
def foo(client_id: str) -> list: and will therefore not do what you want.
The native way to describe a "either A or B" type hint is Union (thanks to Bhargav Rao):
def foo(client_id: str) -> Union[list, bool]:
Or, starting with Python 3.10 and beyond, using the | operator:
def foo(client_id: str) -> list | bool:
I do not want to be the "Why do you want to do this anyway" guy, but maybe having 2 return types isn't what you want:
If you want to return a bool to indicate some type of special error-case, consider using Exceptions instead. If you want to return a bool as some special value, maybe an empty list would be a good representation.
You can also indicate that None could be returned with Optional[list]
4 Comments
Nathaniel Ford
There are uses where returning multiple types may be what you want: for instance if you need to return one of some set of subtypes, but not other subtypes, or if you are attempting to process data and want to return the raw form if processing isn't available. Also, if you are wrapping legacy code it can be quite useful, because it helps the upgrade process and/or see awkward places.
Yahya Uddin
The exceptions and empty list idea was helpful as well. thanks
muxevola
The
| operator doesn't work when I try to indicate I'm allowing my function to return both str and None (i.e. -> str | None). In this case, I get TypeError: unsupported operand type(s) for |: 'type' and 'NoneType'. Union works properly, though.
Felk
as xjcl described in their answer, in case of "X or None" you can also use
Optional[X]