Python Tutorial

In this tutorial, we will discuss about the type hinting concepts which is helpful to improve code readability and enhance the code structure. We will discuss some tips of type hinting which will make the Python program more readable.

As we know, Python is a dynamically-typed programming language. It means the interpreter checks the code line-by-line when the code runs and the variable types are allowed to change over its lifetime. Let's understand the following important concepts related to type hint.

1. Type Annotations

Type hints are performed using Python annotations and used to add types to variables, parameters, return values, class attributes, and methods. Type hints won't be affected at runtime as they are only hints. Python interpreters always ignore them.

1. Variable annotations -

Variable annotations follows the below syntax -

We can perform the type hint with one of the Python built-in data-types such as int, float, str, bool, bytes, list, tuple, dict, set, frozenset, and None.

Let's understand the following example.

Example -

a: int = 45
b: float = 12.4
c: bool = False
d: list = ["X", "Y", "Z"]
e: dict = {"a": "b"}
f: set = {"x", "y", "z"}
g: tuple = ("name", "age", "job")

2. Function Annotations

We can also use the type hint with the functions to specify the type so their arguments and their returned value. The previous syntax can be used to specify the types of arguments. Let's understand the following example -

Example -

def add_numbers(x: int, y: int, z: int= 100) -> int:
    return x + y + z

If a function doesn't return anything, you can set the return type (after the arrow) to None.

3. Class Annotations

We can even annotate attributes and methods inside the Python classes.

class Employee:
    first_name: str = "Glen"
    last_name: str = "Maxwell"
    age: int = 31

2. List

Suppose we are using a function that takes function complex argument consisting of a list of floats. We can annotate this as below.

Example -

def my_function(l: list[float]):
   return sum(l)

It seems correct but it doesn't work. To make it work, we need to replace the built-in standard list type with a List type that we can import from the typing module. The advantage of the List type is that it can hold any type inside it. Let's see the following modified example

Example -

from typing import List
def my_function(l: List[float]):
   return sum(l)

We can annotate the list of lists of string.

Example -

from typing import List
NestedList = List[List[str]]
my_list: NestedList = [["tomato", "carrot"], ["melon", "apples"]]

3. Dict

To ensure control over the types of keys and values inside dictionaries, you can utilize the `Dict` type from the `typing` module in Python. This allows you to specify the expected types for both the keys and values within the dictionary.

By using the `Dict` type, you can define a dictionary with specific key and value types, providing clarity and enforcing the desired schema. For example, you can create a dictionary with string keys and dictionary values by using `Dict[str, Dict]`. This indicates that the keys should be of type `str`, while the values should be of type `Dict` (which in this case indicates a nested dictionary structure).

Using the `Dict` type helps in maintaining the expected types and structure of the dictionary, making it easier to understand and work with the data.

We are dealing with the dictionary with the string keys and dict values.

my_dict = {
    "IT": {"Devansh": 1, "Advard": 2},
    "HR": {"Smith": 3, "John": 4},
    "Finance": {"Bollinger": 5, "Drik": 6}
}

To use type hint, we can pass two arguments to Dict where the first one is the type of the keys and the second one is the type of the values.

from typing import Dict
my_dict_type = Dict[str, dict]

4. Union

In the new version of Python 3.10, Union is replaced by | which means that Union[X. Y] is equivalent to X | Y. Let's understand the following example.

Example -

from typing import Union
from pathlib import Path

def load_model(filename: str, cache_folder: Union[str, Path]):
    if isinstance(cache_folder, Path):
        cache_folder = str(cache_folder)
    
    
    return None

We have a function that reads a file from a cache directory. This cache directory location can either be a string value or a Path object from the Pathlib library.

4. TypedDict

The TypedDict type from the typing module allows us to declare a dictionary type with a specific set of keys, where each key is associated with a value of a consistent type. Here is an example that demonstrates the usage of TypedDict.

Example -

from typing import TypedDict
class Person(TypedDict):
    name: str
    age: int
    address: str

# Creating an instance of the Person TypedDict
person: Person = {
    "name": "John Doe",
    "age": 30,
    "address": "123 Main St"
}

# Accessing and printing the values
print(person["name"])     
print(person["age"])      
print(person["address"])  

Output:

John Doe
30
123 Main St

Explanation -

In the above example, we define a Person class that inherits from TypedDict. Inside the class, we declare the expected keys (name, age, and address) along with their corresponding value types (str, int, and str, respectively).

We then create an instance of the Person TypedDict called person, where we assign values to each key. The values must adhere to the declared value types.

Finally, we can access and print the values from the person dictionary using the respective keys.

It is noted that TypedDict is available starting from Python 3.8. If you are using an older version, you may need to use third-party libraries like typing_extensions to get similar functionality.

5. Callable

The Callable type hint in Python allows you to specify that a variable or function parameter should be a callable object, such as a function or a method. It allows you to define the expected signature of the callable, including the types of its arguments and return value.

from typing import Callable
def apply_operation(a: int, b: int, operation: Callable[[int, int], int]) -> int:
    result = operation(a, b)
    return result
def multiply(x: int, y: int) -> int:
    return x * y
# Calling the apply_operation function
result = apply_operation(4, 5, multiply)
print(result) 

Output:

Explanation -

In the example above, we have a function apply_operation that takes two integers (a and b) and a callable operation as arguments. The operation parameter is annotated with the Callable type hint, specifying that it should be a callable object that takes two int arguments and returns an int.

We define a separate function multiply that matches the signature specified by the Callable type hint. It takes two integers and returns their multiplication.

When calling apply_operation with 4, 5, and multiply, the function is invoked with the provided arguments. It applies the multiply function as the operation and returns the result, which is then printed (20 in this case).

The Callable type hint provides a way to define and enforce the expected behavior of callable objects, making your code more expressive and enabling better type checking.

6. Any

The Any type hint in Python represents a value of any type. It is used when you want to indicate that a variable, function parameter, or return value can be of any type. Let's understand the following code.

Example -

from typing import Any
def process_data(data: Any) -> str:
    processed_data = perform_processing(data)
    return str(processed_data)
# Calling the process_data function
result = process_data(42)
print(result)  

Output:

"42"

7. Optional

In Python, you can use optional type hints to indicate that a variable or function parameter may have a specific type or may be None. Optional type hints are denoted by the Union type hint, which allows for multiple possible types, including None.

Here is an example of how we can use optional type hints:

Example -

from typing import Optional
def greet(name: Optional[str]) -> str:
    if name is None:
        return "Hello!"
    else:
        return f"Hello, {name}!"

result1 = greet("Alice")  # Type hint indicates a string
result2 = greet(None)     # Type hint indicates None

print(result1)  
print(result2)  

Output:

Hello, Alice!
Hello!

Example -

In the example above, the name parameter of the greet function is annotated with Optional[str], indicating that it can be either a string or None. Inside the function, we check if the `name` is None and return a generic greeting if it is, or a personalized greeting if a name is provided.

Using optional type hints can help improve code readability and catch potential type-related errors during static analysis with type checkers like mypy. However, it's important to note that type hints in Python are optional and do not affect the runtime behavior of the code. They are primarily used for documentation and static analysis purposes.

8. Sequence

A Sequence type hints can be any type of sequence like a list, a tuple, a string, a list of objects, etc. The typing module provides the Sequence type hint of this purpose. Let's understand the following example.

Example -

from typing import Sequence
def process_numbers(numbers: Sequence[int]) -> int:
    total = 0
    for num in numbers:
        total += num
    return total

my_list = [1, 2, 3, 4, 5]
result = process_numbers(my_list)
print(result)  

Output:

Explanation -

In the above example, the numbers parameter of the process_numbers function is annotated with Sequence[int], indicating that it should be a sequence (list, tuple, etc.) containing integers. Inside the function, we iterate over the elements of the sequence and calculate their sum.

By using the Sequence type hint, you make it clear to other developers and static analyzers that the expected input is a sequence. It helps improve code readability and can catch potential type-related errors during static analysis.

It's important to note that the Sequence type hint is a generic type hint, and you can specify the type of elements in the sequence by providing a type argument inside square brackets, as shown in the example (Sequence [int]).

9. Tuple

In Python, we can use tuple type hints to indicate that a variable or function parameter should be a tuple. The typing module provides the `Tuple` type hint for this purpose.

Here is an example of how you can use the `Tuple` type hint:

Example -

from typing import Tuple
def process_coordinates(coordinates: Tuple[float, float]) -> float:
    x, y = coordinates
    distance = (x ** 2 + y ** 2) ** 0.5
    return distance

my_coordinates = (3.0, 4.0)
result = process_coordinates(my_coordinates)
print(result)  

Output:

5.0

Explanation -

In the above example, the coordinates parameter of the process_coordinates() function is annotated with Tuple[float, float], indicating that it should be a tuple containing two floats. Inside the function, we unpack the tuple into x and y variables and calculate the Euclidean distance using the Pythagorean theorem.

By using the Tuple type hint, you make it clear to other developers and static analyzers that the expected input is a tuple. It helps improve code readability and can catch potential type-related errors during static analysis.

It's important to note that the Tuple type hint is a generic type hint, and we can specify the types of elements in the tuple by providing type arguments inside square brackets, as shown in the example (Tuple[float, float]). The number and order of type arguments should match the number and order of elements in the tuple.

Advantages of Using Type Hint in the Code

Following are the main advantages of type hint.

Type hints are very useful with the function where we can provide the informative signature that clarifies the assumption about the function arguments and returned result.
Type hint enhances the readability, maintainability, and debugging of the code. The explicit type of information reduces cognitive overhead, allowing for easier reasoning about objects and their relationships, leading to more robust and reliable software development.

Conclusion

Type hints introduce an additional layer of abstraction to our code, serving multiple purposes. They act as documentation, clarifying the assumptions about inputs and outputs, while also helping to detect subtle errors during static code analysis, such as with tools like mypy.

By including type hints, we provide a form of self-documentation within our code. The hints describe the expected types of variables, function parameters, and return values, making it easier for others (including your future self) to understand the intended usage and behavior of the code.

There are certain scenarios where it may be advisable to avoid adding type hints, particularly if you're using an older version of Python, if you're new to the programming language, or if performance is a critical concern. It's worth noting that type hints can introduce a slight overhead in terms of start-up time.

Next TopicVectorization in Python

← prev next →