typing - Support for type hints in Python

Type hints are a game-changer for Python developers. They're like tiny instructions that tell your code exactly what kind of data it should expect. This makes your code:

• Easier to Understand: No more confusion about what goes where.
• Less Error-Prone: Catch mistakes before your code even runs.
• Smarter with IDEs: Get better suggestions and autocompletion.

Let's explore type hints together! In this series, we'll break down the basics, see them in action, and show you how to write cleaner, more reliable Python code.

type hint - An annotation that specifies the expected type for a variable, a class attribute, or a function parameter or return value.

typing is a python module added in python 3.5 , to support for type hints . Consider the below code

from typing import float

def area(side : float) -> float:
        return side**2        

• from typing import float: This line imports the float type from the typing module.
• side: float: This specifies that the side argument is expected to be a float (a floating-point number).
• -> float: This indicates that the function will return a value of type float.

The function area takes the arguement expected to be an instance of float , and expected to return an instance of float.

Now let's explore some more features available in typing module.

Union type hints

Sometimes, a function argument or variable can hold one of several possible types. The Union type hint allows you to specify this flexibility. See the below code

from typing import Union
def get_user_input(prompt: str) -> Union[str, int]:
        user_input = input(prompt)
        try:
              return int(user_input)
       except ValueError:
             return user_input        

In this example, the get_user_input function can receive either a str (string prompt) and return a str (user input as a string) or an int (user input converted to an integer).

Type Aliases

For complex type annotations we can create aliases using TypeAlias

example :

from typing import TypeAlias
Vector : TypeAlias = list[float]        

From python 3.11 ,'type' statement can be used for creating TypeAlias instance

type Vector2 = list[float]        

In the above code snippet both list[float] and Vector are treated equivalently by static type checkers.

NewType

In Python, NewType (introduced in version 3.5.2) is a class constructor used to create subtypes of existing types. It provides a way to define a new type name that acts as an alias for an existing type, but with the potential for additional semantic meaning. However, it's important to understand that NewType doesn't create a new type in the traditional sense; it's primarily for adding clarity and potentially enabling type checking.

Example

from typing import NewType
PositiveInt = NewType('PositiveInt',int)
p = PositiveInt(2)        

• NewType doesn't create a new data type or perform any data validation. Values of a NewType are still just regular instances of the underlying type (e.g., PositiveInt values are still int values).
• The primary benefit is clarity. For example, PositiveInt explicitly conveys the intent of using an integer only for positive values, even though the underlying data type remains int.
• No runtime enforcement: NewType doesn't prevent assigning negative values to a PositiveInt variable, for instance. It can be used for better code readability.

Generics

Generics are templates for functions and classes. You define them using placeholders called type variables, which can be replaced with specific data types when you use the function or class. This enables you to create reusable code that can handle different data types without needing separate implementations.

Here's a basic syntax for defining a generic function with a type variable T

from typing import TypeVar
T = TypeVar('T')  # Create a type variable
def identity(value: T) -> T:
        return value        

# Usage examplesidentity("Hello")  # T is replaced with str
identity(3.14)  # T is replaced with float        

Generic types are widely used in standard library collections like List[T], Dict[K, V], and Set[T], where T, K, and V represent the data types of elements, keys, and values, respectively.

Type hints are a powerful tool for writing cleaner, more robust Python code. They enhance readability, aid in early error detection, and provide better IDE support

Explore the typing module documentation for a comprehensive reference on available type hints. Practice implementing different type hints in your projects to experience their benefits firsthand. Stay tuned for further explorations into advanced Python concepts!