Union
è destinato proprio per questa situazione. Si crea un nuovo tipo che può essere uno qualsiasi dei tipi di specificare:
from typing import Union, List
def my_function(list_arg: Union[List[str], List[int]]) -> None: ...
Se lo si utilizza spesso, fare un tipo alias:
MyList = Union[List[str], List[int]]
def my_function(list_arg: MyList) -> None: ...
non mi consiglia di utilizzare una funzione generica come La risposta @ user6269244 suggerisce a meno che non ne abbiate bisogno per qualche motivo specifico. Anche se T = TypeVar('T', int, str)
funzionerà in un caso semplice, sarà più restrittivo.
Ad esempio, si supponga di avere qualcosa di simile:
def apply_my_function(list_of_lists: List[MyList]) -> None:
# each item in list_of_lists is either a List[int] or List[str]
for arg in list_of_lists:
my_function(arg)
In questo codice, non avete scelta molto vasta: avete bisogno di un Union
(List[List[T]]
non ti permettono di memorizzare sia un elenco di int e un elenco di str perché T
non può passare tra str
e int
nella stessa espressione).
Ma dal momento che si utilizza Union
nel codice che chiama my_function
, dovrete anche utilizzare Union
nella firma di my_function
stessa.
Inoltre, i generici aumentano la complessità dei tipi e ad un certo punto si verificheranno le limitazioni del sistema di tipi. Quindi è meglio prenotare farmaci generici per i casi in cui si ha realmente bisogno di loro, per esempio, se si desidera che il tipo di ritorno di my_function
per dipendono dal tipo di argomento:
T = TypeVar("T", int, str)
# this can't be achieved with Union:
def my_function(list_arg: List[T]) -> T: ...
Immagino che questo sia più completo quindi sto marcando per gli altri ma grazie a @ user6269244 - ha risolto il problema abbastanza bene per me prima! – vahndi