Introduction

MyPy¹ is a static type checker for Python. Unlike statically-typed languages like C++ or Java, Python is dynamically typed. This means that in Python, you don't have to explicitly declare the type of a variable; it is inferred at runtime. For example:

Python (Dynamically Typed)

num = 4                # `num` is inferred as an integer
newString = "new string"  # `newString` is inferred as a string

In contrast, statically-typed languages require you to specify the type of each variable at compile time. This helps catch type-related errors during development rather than at runtime.

C++ (Statically Typed)

int num = 4;            // `num` is declared as an integer
std::string newString = "new string";  // `newString` is declared as a string

Why Use MyPy?

In dynamically typed languages like Python, type errors can occur at runtime, which may lead to bugs that are harder to trace. MyPy addresses this by allowing you to add type hints to your Python code, which can be checked statically before execution. This offers several advantages:

• Early Error Detection: Identify type-related errors during development rather than encountering them at runtime.
• Improved Code Readability: Type hints clarify the expected types of variables and function arguments, enhancing code readability.
• Better IDE Support: Provides improved code completion and inline documentation in IDEs that support type hints.

Example with MyPy

Here’s a simple example demonstrating the use of type hints with MyPy:

Without Type Hints

def add(a, b):
    return a + b

print(add(5, 3))      # Output: 8
print(add("hello", "world"))  # Output: helloworld

In the code above, the add function can accept both integers and strings, which might not be the intended behavior.

With Type Hints

def add(a: int, b: int) -> int:
    return a + b

print(add(5, 3))      # Output: 8
# mypy will report an error for the following line:
# print(add("hello", "world"))  # TypeError: Expected int, got str

By including type hints (a: int, b: int), you specify that add should work with integers only. MyPy checks the code against these type hints, catching potential type-related issues early.

Installing and Running MyPy

To get started with MyPy:

1. Installation: Install MyPy using pip:

   python3 -m pip install mypy

1. Running MyPy: Once installed, you can run MyPy to check your code for type errors. Use the following command:

   mypy program.py

This command will check your code statically, similar to how a compiler checks syntax in C++. It will report any type errors it finds without actually running the code.

Using MyPy effectively allows you to integrate the benefits of static typing into Python, while still enjoying the flexibility of its dynamic nature.

Let's Code an Example with MyPy

Without MyPy

def greeting(name):
    return 'Hello ' + name

# These calls will fail when the program runs, but MyPy will not report an error
greeting(123)
greeting(b"Aniket")

With MyPy

By adding type annotations (also known as type hints), MyPy can detect potential issues:

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

greeting(3)         # mypy will report: Argument 1 to "greeting" has incompatible type "int"; expected "str"
greeting(b'Alice')  # mypy will report: Argument 1 to "greeting" has incompatible type "bytes"; expected "str"
greeting("World!")  # No error

Here:

• name: str annotation specifies that the name argument should be a string.
• -> str annotation specifies that the function greeting will return a string.

When to Use MyPy

MyPy is useful in several situations:

• Catch Errors Early: Use MyPy to find type-related errors before running your code. This helps catch mistakes early and improves code reliability.

• Make Code Clearer: Adding type hints makes your code easier to understand. It shows what types of values are expected, which helps others (and your future self) understand your code better.

• Upgrade Old Code: When updating old code, MyPy helps find type issues as you add type hints, making the transition smoother.

• Improve Prototypes: When building new features or prototypes, MyPy helps ensure that the new code works correctly with existing code by enforcing type rules.

• Maintain Large Projects: In big projects with many contributors, MyPy helps keep code consistent and prevents type-related bugs.

• Boost IDE Features: If you use an IDE, MyPy improves features like code completion and navigation, making development easier.

Using MyPy helps you write better, more reliable Python code while still enjoying Python's flexibility.

A official quick cheatsheet for mypy

1. Official Documentation ↩