Type hints allow you to define what types of arguments a function expects and what type it returns. However, the Python runtime does not enforce function and variable type annotations. They can be used by third party tools such as type checkers, IDEs, linters, etc.
Here is a basic example of type annotations:
def greeting(name: str) -> str:
return 'Hello ' + name
print(greeting('Alice'))Hello Alice
Predict the Output: What happens if we pass strings to a function annotated to take integers?
If you guessed it throws a TypeError, you’re not alone! But click Run below to see what Python actually does.
def add(x: int, y: int) -> int:
return x + y
# Python runtime ignores the incorrect type
print(add('a', 'b'))ab
Python will happily execute the code above because runtime doesn’t enforce annotations. This is a common misconception! Python won’t throw an error if you pass the wrong type; the tools are meant for static analysis, like mypy.
|)Sometimes a variable can be one of several types. To define a union, use e.g. Union[int, str] or the shorthand int | str.
def process(data: int | str) -> str:
return str(data) * 2
print(process(3))33
Similarly, if a variable can be None, you can use Optional.
from typing import Optional
def greet(name: Optional[str] = None) -> str:
if name:
return f'Hi, {name}'
return 'Hi'
print(greet())Hi
Generic functions and classes can be parameterized by using type parameter syntax:
def get_first[T](items: list[T]) -> T:
return items[0]
print(get_first([1, 2, 3]))1
Generic classes have __class_getitem__() methods, meaning they can be parameterised at runtime (e.g. list[int] below):
MyList = list[int]
nums: MyList = [1, 2, 3]
print(nums)[1, 2, 3]
Now test your understanding with the challenges below!
How does the Python runtime use type annotations?
It completely ignores them. — Python type hints are completely ignored at runtime by standard Python; they don't affect performance or throw errors. They are checked by third-party tools like mypy.
Which syntax is valid in Python 3.10+ to express that a variable can be an integer or a string?
int | str — Python 3.10 introduced the `|` operator for Union types, making `int | str` the standard modern syntax.
What is the primary purpose of generic classes like `list[T]`?
To parameterize the class so type checkers know what type of elements it contains. — Generics allow type checkers to verify the types of items stored in containers, preventing type-related bugs without changing runtime behavior.
Fix the function signature using the `|` operator so that `value` can be either an `int` or a `float`.
def double(value: int | float) -> float:
return float(value * 2)
print(double(3.5))Update the function signature to specify that it takes a `list` of `str` and returns a `str`.
def combine(items: list[str]) -> str:
return ''.join(items)
print(combine(['a', 'b']))