What are some examples of using the typing module in Python 3?

What are some examples of using the typing module in Python 3?

The typing module in Python 3 provides support for type hints. Here are a few examples:

1. Basic Types: You can use List, Dict, and Tuple to specify types for collections.

   from typing import List, Dict
   def process_items(items: List[str]) -> Dict[str, int]:
       return {item: len(item) for item in items}
   

2. Optional Types: Use Optional to indicate that a value can be of a specified type or None.

   from typing import Optional
   def find_item(name: str) -> Optional[str]:
       return name if name in items else None
   

3. Union Types: Use Union to specify that a variable can be one of several types.

   from typing import Union
   def handle_value(value: Union[int, str]) -> None:
       print(value)
   

4. Type Aliases: You can create type aliases for more complex types.

   from typing import List
   Vector = List[float]
   def scale(v: Vector, factor: float) -> Vector:
       return [x * factor for x in v]
   

5. Callable Types: Specify types for functions or methods.

   from typing import Callable
   def apply_function(func: Callable[[int], int], value: int) -> int:
       return func(value)
   

Would you like to see more examples or details on a specific type?

Yes, can you explain more about Optional types?

Sure! The Optional type is used to indicate that a variable can either hold a value of a specified type or be None. This is particularly useful for function return types where a value may not always be present. For example:

from typing import Optional

def get_user_age(user_id: int) -> Optional[int]:
    if user_id in user_database:
        return user_database[user_id]['age']
    return None

In this example, get_user_age returns an int if the user is found, or None if the user does not exist. This helps in making the code more explicit and easier to understand.

That makes sense! Can you give me an example of using Union types?

Absolutely! The Union type allows you to specify that a variable can be one of several types. Here's a simple example:

from typing import Union

def process_input(data: Union[int, str]) -> str:
    if isinstance(data, int):
        return f'Integer: {data}'
    elif isinstance(data, str):
        return f'String: {data}'
    return 'Invalid input'

In this function, data can be either an int or a str. Depending on the type of data, the function processes it accordingly. This is useful when you want to handle multiple types in a flexible way.