Type Hints in Python

Type hints are a feature in Python that allow developers to annotate their code with expected types for variables and function arguments. This helps to improve code readability and provides an opportunity to catch errors before runtime using type checkers like mypy.

Using Type Hints in Python

1. Variable and Function Type Hints

Type hints define the expected type for variables and function arguments. Example:

age: int = 25
def greet(name: str) -> str:
    return f"Hello, {name}!"

Explanation:

• age is an integer (int).
• greet function expects a string (name: str) and returns a string (-> str).

2. Function Return Type

The return type of a function can be specified using ->. Example:

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

Explanation: The add_numbers function expects two integers (x: int, y: int) and returns an integer (-> int).

3. Optional Types and Collections

Use Optional for values that can be None, and define types for collections like lists and tuples. Example:

from typing import Optional, List, Tuple

def get_user(id: int) -> Optional[str]:
    return None if id == 0 else "User"

def sum(num: List[int]) -> int:
    return sum(num)

def get_name_and_age() -> Tuple[str, int]:
    return ("Abc", 25)

Explanation:

• Optional[str]: The get_user function can return either a string or None.
• List[int]: The sum_numbers function expects a list of integers.
• Tuple[str, int]: The get_name_and_age function returns a tuple with a string and an integer.

Example Without Type Hints

Here’s an example of a factorial function without type hints:

def factorial(i):
    if i < 0:
        return None
    if i == 0:
        return 1
    return i * factorial(i - 1)

print(factorial(4))
print(factorial("4"))
print(factorial(5.01))

Output

Explanation:

• The function works fine with integers.
• It throws an error if a string is passed (since you cannot perform mathematical operations on strings).
• It also throws an error with floating-point numbers. For instance, passing 5.01 will eventually lead to an issue where the function tries to decrement the number until it reaches a non-integer value, causing it to return None and break the logic.

Adding Type Hints

By adding type hints, we can make the function’s expected behavior more clear. Here’s the modified code with type hints:

def factorial(i: int) -> int:
    if not isinstance(i, int):  
        return None
    if i < 0:
        return None
    if i == 0:
        return 1
    return i * factorial(i - 1)

print(factorial(5.01)) 

None

Explanation: In this version, if the input isn't an integer, the function will return None instead of causing an error.

Why Type Hints Don’t Prevent Errors

Type hints are not enforced by the Python interpreter; they are purely for static analysis by external tools like mypy. So, even with type hints, the code will still run with errors unless a static type checker is used. Python won’t prevent you from passing a string or floating-point number to the function at runtime.

Using mypy for Type Checking

To actually check if your code violates any type hints, you can use a tool like mypy, a static type checker for Python. Running mypy on your script will not execute the code but will analyze it for type hint violations. For example, let's check the factorial function with mypy:

1. Install mypy: If you don't have mypy installed, you can install it using pip:

pip install mypy

2. Run mypy on your script: Now, you can run the following command:

mypy ranking.py

This will analyze your code and give a clear error message if the types don’t match, like: