Python Type Hints Tutorial – Complete Guide

Python has steadily emerged as one of the most versatile and vibrant programming languages in the tech world. Its simplicity and readability have made it the top choice for beginner coders and professionals alike. However, while Python’s dynamic typing feature adds to its flexibility, it sometimes leaves developers guessing the type of variables. This is where Python Type Hints come into play, adding a powerful tool to a python coder’s arsenal.

What are Python Type Hints?

Python Type Hints, introduced in Python 3.5 with PEP 484, provide a way for developers to specify the expected type of function arguments and return values. It’s important to note that they are just hints – Python is still dynamically typed, and the interpreter won’t enforce the types.

Type hints are incredibly beneficial because they improve code readability and allow more accurate error checking. With these hints, you can express the intended types of function arguments and return values clearly, making it easier for others (or your future self) to understand the code. Moreover, advanced integrated development environments (IDEs) and linters can use these hints to detect potential type errors before runtime, saving precious debugging time.

Why should I learn Python Type Hints?

While Python Type Hints is not a mandatory tool, it’s definitely a game changer. Learning type hints can cut debugging time and make your code more easily understandable to others. Moreover, because most modern organizations and open-source projects use type hints, understanding and employing them will make you a more competent and efficient developer.

CTA Small Image

Python Type Hints Basics

Let’s dive right into some simple examples of Python Type Hints. To start, we’ll look into how to use type hints with function arguments and return values.

def greet(name: str) -> str:
    return "Hello, " + name

In the above code snippet, name: str hints that the function argument name should be a string, while -> str denotes that the function should return a string.

Using Type Hints with Lists

Lists are a commonly used data structure in Python, and type hints can be very useful here too. You can specify the type of elements in the list. Here’s how:

from typing import List

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

In the above example, List[int] signifies that the function expects a list of integers as an argument.

Python Type Hints with Dictionaries

For dictionaries, you can specify the type of both keys and values. Here’s an example of a function that takes a dictionary with string keys and integer values:

from typing import Dict

def get_value(my_dict: Dict[str, int], key: str) -> int:
    return my_dict.get(key, 0)

Type Hints with Classes

Type hints can be used with classes to specify the expected class type of an argument:

class MyClass:
    def hello(self):
        return "Hello, world!"

def greet(obj: MyClass):
    return obj.hello()

In the above example, the greet function expects an instance of MyClass as an argument.

Type Checking with ‘mypy’

We mentioned earlier that Python itself does not enforce type hints. However, third-party tools like ‘mypy’ can check the types in your code based on your type hints. Here is a simple example:

from typing import List

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

total(["a", "b", "c"])  # Using a list of strings instead of integers

If we run ‘mypy’ on the above code, it will throw an error indicating that a list of strings was used instead of a list of integers.

Type Hints with Functions

You can use the ‘Callable’ type hint to specify a function type. This is particularly useful when you’re passing a function as an argument to another function. Here’s how:

from typing import Callable

def call_hello(func: Callable[[], str]):
    return func()

def hello() -> str:
    return "Hello, world!"

print(call_hello(hello))  # Outputs: "Hello, world!"

Type Hints with Optional Values

Many times, certain function arguments or return values can be of a particular type or None. You can indicate this using the ‘Optional’ type hint.

from typing import Optional

def find_even(numbers: List[int]) -> Optional[int]:
    for num in numbers:
        if num % 2 == 0:
            return num
    return None

print(find_even([1, 3, 5, 7]))  # Returns: None
print(find_even([1, 3, 5, 7, 8]))  # Returns: 8

Type Hints with Generators

Generators, used for lazy evaluation in Python, can also have type hints. The ‘Generator’ type hint allows you to specify the type of values it yields, the type of value it receives, and the return type.

from typing import Generator

def count_up_to(n: int) -> Generator[int, None, None]:
    i = 1
    while i <= n:
        yield i
        i += 1

for number in count_up_to(5):
    print(number)  # Outputs: 1, 2, 3, 4, 5

As illustrated above, type hints add a layer of readability and robustness to your Python code, whether it’s for a small-scale project or a large codebase. Happy coding!

Where to Go Next with Python

Now that you’ve grasped the basics of Python Type Hints, you may wonder where to go next on your Python journey. One of your best options is to deepen your Python knowledge and skills with our excellent Python Mini-Degree.

The Python Mini-Degree offered by Zenva Academy is an extensive series of courses on Python programming. This mini-degree program covers various facets of Python, ranging from coding basics and algorithms to object-oriented programming, game development, and app creation. Whether you’re a beginner or an experienced programmer, our course contents are tailored for all levels.

By successfully completing these courses, you can develop the skills to design your games, algorithms, and real-world applications. Python is a significant player in several industries, including game development, data science, and robotics, thus this knowledge can open up various opportunities for you.

Our courses are flexible and can be accessed anytime, allowing you to study at your convenience. The instructors are experienced and certified, offering live coding lessons, quizzes, and interactive lessons to reinforce your understanding of Python.

Upon completion, you will receive a certificate and be equipped with the skills that can help you launch a new career, start a business, or publish your own games and websites.

For a more comprehensive collection, you can explore our catalog of Python courses. Happy learning!


Python Type Hints can be a major asset in your coding toolkit, bolstering your coding skills and enhancing the readability of your Python code. With type hints, you get the advantage of specifying expected types, making the code self-explanatory and reducing the time spent on debugging.

The good news is, now that you’re aware of the benefits, you can delve deeper into Python with Zenva’s Python Mini-Degree. Our course bundles are designed to strengthen your Python expertise, gearing you up to take on various real-world projects effectively. Happy coding!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.