Mypy Tutorial – Complete Guide

Ever heard the term “type checking” in Python scripts? If not, let’s make your day. Welcome to our comprehensive tutorial series on ‘mypy’, an optional static type checker for Python.

What is Mypy?

Mypy is a powerful tool that allows developers to utilize the concept of static typing in their Python programming journey. If you’re coming from a statically typed language like C or Java, you will remember having to declare variable types. Python, as a dynamically typed language, doesn’t require this. But with mypy, we can selectively add these type declarations to our Python data, enabling an additional layer of code reliability and robustness.

What is Mypy used for?

Primarily, mypy helps in reducing the odds of runtime errors in Python codes, which are normally caught during the execution of the script. Mypy does so even before the code runs, i.e., during the code-writing phase itself. This ‘compile-time’ error detection often leads to more reliable code, saving not only a headache but potentially hours of debug time later.

Why should you learn Mypy?

Python’s dynamic nature is both its strength and weakness, depending on how one uses it. Mypy offers the ‘best of both worlds’, combining Python’s dynamic typing with the benefits of static type checking. Moreover, it can improve code-readability as well. Thus, learning and mastering mypy gives you an edge in writing more robust, reliable, and efficient Python scripts.

CTA Small Image




How to get started with Mypy

Firstly, mypy is an external tool that is not shipped with your default Python installation, so you’ll need to install it manually. Open your terminal and type the following pip command:

pip install mypy

With mypy installed, let’s dive into some examples:

Writing Python with type hints

Just like you would in a statically-typed language such as Java, you start by declaring the types of your variables, functions, and methods.

Here’s a simple Python program with type hints:

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


The ‘:str’ in the function greet indicates that the ‘name’ argument should be of type string. With ‘->str’ we’re specifying that the function will return a string.

Using Mypy to check your Python scripts

After writing a script with type hints, use the mypy tool from command line to check your file. If your filename is ‘’, you’d type:


If everything is correctly typed, mypy will not return any information. This means your script is good to go! If there are issues, mypy will tell you exactly where and what the problem is.

A few more examples

Let’s look at some examples that will cause a type hint violation:

def double(number: int) -> int:
    return number * 2

double('string') # this will cause a type hint violation
def add(number1: int, number2: int) -> int:
    return number1 + number2

add(5, 'string') # this will cause a type hint violation

Mypy can also work with custom classes. Take a look at this:

class MyNumber:
    def __init__(self, number: int):
        self.number = number

def add(number1: MyNumber, number2: MyNumber) -> MyNumber:
    return MyNumber(number1.number + number2.number)

number1 = MyNumber(5)
number2 = MyNumber(10)
print(add(number1, number2).number) # this will work correctly
print(add(number1, 'string').number) # this will cause a type hint violation

Above, we have created our own class and used it in our type hinting. This allows us to gain the benefits of type hinting even with our custom objects.

Applying Mypy in Common Scenarios

As developers, we often find ourselves in common situations requiring specific pieces of code. Let’s see how mypy can be used in some such instances.

Using Mypy with Lists

Mypy allows the application of type hinting to lists as well. Here is how you use type hinting with lists:

from typing import List

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

print(addAll([1, 2, 3, 4, 5])) # this is okay
print(addAll([1, 2, "3", 4, 5])) # this will cause a violation

Type Hinting with Dictionaries

Just as with lists, we can also apply type hinting to dictionaries:

from typing import Dict

def printAll(student: Dict[str, str]) -> None:
    for key, value in student.items():
        print(key, value)

student = {
   "name": "John",
   "class": "IV",
   "roll_id": "42"

printAll(student) # this is okay

Mypy with Optional Types

There can be instances where variables can take a value of None. This situation calls for the use of Optional types:

from typing import Optional

def greet(name: Optional[str] = None) -> str:
    if name is not None:
        return "Hello, " + name
        return "Hello, Guest"

print(greet())            # this is okay
print(greet("John Doe"))  # this is okay too

By declaring the type as Optional[str], we’re telling mypy that “name” can either be a string or None.

Parameters with Default Values

If your function parameters have default values, you can still add type hints to them:

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

print(greet())             # This is okay
print(greet("John Doe"))   # This is okay too

Here, even though a default value has been provided for the “name” parameter, mypy will still enforce the type checking.

Where to go next

Well done! You’re on your way to mastering mypy, thereby enhancing the robustness and readability of your Python programs. Step up your journey with Python by delving deeper into other concepts. Remain curious, continue asking questions, and never stop learning!

An exemplary next step would be the Python Mini-Degree we offer at Zenva Academy. This collection of modules offers comprehensive dives into various aspects of Python programming. With it, you will get opportunities to learn and apply your knowledge through the development of games, real-world apps, and algorithms.

Why Zenva and the Python Mini-Degree?

At Zenva, we believe in transforming beginners into professionals. Our wide range of over 250 courses covers programming, game development, and AI, allowing students like you to dive into areas of interest and advance your skills at every level. Here, you’ll learn by doing and finish each course with a portfolio to show off your newly acquired skills.

Our Python Mini-Degree provides a learner-friendly approach to Python. It’s an ideal combination of Python basics, object-oriented programming, algorithms, game development, and app creation. With interactive modules, in-course quizzes, and live coding lessons, this program is designed to cater to beginners just stepping into the programming world, as well as experienced developers looking to sharpen and enhance their skills.

Broaden your Python skills with Zenva

If you wish to explore beyond our Python Mini-Degree or are looking for something more specific, browse through our expansive collection of other Python courses. From the fundamentals to more advanced topics, we’ve got you covered in every step of your learning journey.

At Zenva, we offer flexibility, up-to-date content, and certification. Our courses are tailor-made to fit your schedule, and we keep our material up to date to make sure you are learning the most relevant techniques. With Zenva, you can develop your skills and advance your career, going from beginner to professional. The sky’s the limit! Happy learning!


We are truly excited about your decision to step into the world of Python and enhance your prowess with mypy. We believe that it will add significant value to your programming journey by allowing you to develop readable, reliable, and robust Python scripts.

Embrace the power of mypy and continue your pursuit of knowledge and skill acquisition with us, here at Zenva. Stand out from the programming crowd and level up your resume with our comprehensive Python Mini-Degree or any of our specialized Python courses. Happy coding!


Python Blog Image

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