📘 Mypy: Static Type Checking

🎯 Introduction

Welcome to this exciting tutorial on Mypy and static type checking in Python! 🎉 In this guide, we’ll explore how to add type safety to your Python projects and catch bugs before they bite!

You’ll discover how Mypy can transform your Python development experience. Whether you’re building web applications 🌐, data pipelines 📊, or machine learning models 🤖, understanding static type checking is essential for writing robust, maintainable code.

By the end of this tutorial, you’ll feel confident using Mypy to make your Python code safer and more professional! Let’s dive in! 🏊‍♂️

📚 Understanding Mypy and Static Type Checking

🤔 What is Mypy?

Mypy is like a spell-checker for your Python code’s types! 🪄 Think of it as a helpful assistant that reads your code before it runs and tells you “Hey, you’re trying to add a number to a string here - that won’t work!”

In Python terms, Mypy is a static type checker that analyzes your code without executing it. This means you can:

• ✨ Catch type-related bugs early
• 🚀 Get better IDE support with autocomplete
• 🛡️ Make your code self-documenting
• 📖 Improve code readability for your team

💡 Why Use Mypy?

Here’s why developers love static type checking:

1. Early Bug Detection 🐛: Find errors at development time, not runtime
2. Better Refactoring 🔧: Change code with confidence
3. Code Documentation 📖: Types serve as inline documentation
4. IDE Support 💻: Enhanced autocomplete and suggestions

Real-world example: Imagine building an e-commerce system 🛒. With Mypy, you can ensure that price calculations always use numbers, not accidentally mix strings!

🔧 Basic Syntax and Usage

📝 Installing and Using Mypy

Let’s start with getting Mypy set up:

# 👋 First, install mypy!
# pip install mypy

# 🎨 Create a simple typed Python file
def greet(name: str) -> str:
    """Say hello to someone! 👋"""
    return f"Hello, {name}! 🎉"

def calculate_total(price: float, quantity: int) -> float:
    """Calculate the total cost 💰"""
    return price * quantity

# 🎯 Type annotations for variables
user_name: str = "Alice"
item_price: float = 29.99
item_count: int = 3

# ✨ Using our typed functions
greeting = greet(user_name)
total = calculate_total(item_price, item_count)
print(f"{greeting} Your total is: ${total:.2f}")

To check this file with Mypy:

# 🚀 Run mypy on your file
mypy your_file.py

🎯 Common Type Patterns

Here are patterns you’ll use daily:

from typing import List, Dict, Optional, Union, Tuple

# 🏗️ Pattern 1: Lists and collections
def process_items(items: List[str]) -> List[str]:
    """Process a list of items 📦"""
    return [item.upper() for item in items]

# 🎨 Pattern 2: Dictionaries
def create_user(name: str, age: int) -> Dict[str, Union[str, int]]:
    """Create a user profile 👤"""
    return {
        "name": name,
        "age": age,
        "emoji": "😊"
    }

# 🔄 Pattern 3: Optional values
def find_item(items: List[str], target: str) -> Optional[int]:
    """Find an item's index, or None if not found 🔍"""
    try:
        return items.index(target)
    except ValueError:
        return None

# 🎯 Pattern 4: Tuples for multiple returns
def get_stats(numbers: List[float]) -> Tuple[float, float]:
    """Get min and max values 📊"""
    return min(numbers), max(numbers)

💡 Practical Examples

🛒 Example 1: Type-Safe Shopping Cart

Let’s build a shopping cart with proper types:

from typing import List, Dict, Optional
from dataclasses import dataclass
from datetime import datetime

# 🛍️ Define our product type
@dataclass
class Product:
    id: str
    name: str
    price: float
    emoji: str  # Every product needs an emoji! 
    category: str

# 🛒 Shopping cart with type safety
class ShoppingCart:
    def __init__(self) -> None:
        self.items: List[Product] = []
        self.discounts: Dict[str, float] = {}
        
    def add_item(self, product: Product) -> None:
        """Add item to cart ➕"""
        self.items.append(product)
        print(f"Added {product.emoji} {product.name} to cart!")
    
    def apply_discount(self, code: str, percentage: float) -> bool:
        """Apply a discount code 🎟️"""
        if 0 <= percentage <= 100:
            self.discounts[code] = percentage / 100
            print(f"✅ Applied {percentage}% discount!")
            return True
        print(f"❌ Invalid discount percentage!")
        return False
    
    def calculate_total(self) -> float:
        """Calculate total with discounts 💰"""
        subtotal = sum(item.price for item in self.items)
        discount_amount = sum(subtotal * disc for disc in self.discounts.values())
        return subtotal - discount_amount
    
    def get_summary(self) -> Dict[str, Union[int, float, List[str]]]:
        """Get cart summary 📋"""
        return {
            "item_count": len(self.items),
            "total": self.calculate_total(),
            "items": [f"{item.emoji} {item.name}" for item in self.items]
        }

# 🎮 Let's use it with type safety!
cart = ShoppingCart()

# ✅ This works - correct types
book = Product("1", "Python Book", 29.99, "📘", "books")
coffee = Product("2", "Coffee", 4.99, "☕", "beverages")

cart.add_item(book)
cart.add_item(coffee)
cart.apply_discount("SAVE10", 10)

# ❌ Mypy would catch these errors!
# cart.add_item("not a product")  # Type error!
# cart.apply_discount("INVALID", "twenty")  # Type error!

🎮 Example 2: Type-Safe Game System

Let’s create a game with proper type checking:

from typing import List, Dict, Optional, Protocol
from enum import Enum
from abc import ABC, abstractmethod

# 🎯 Define game types
class PlayerClass(Enum):
    WARRIOR = "warrior"
    MAGE = "mage"
    ROGUE = "rogue"

class ItemType(Enum):
    WEAPON = "weapon"
    ARMOR = "armor"
    POTION = "potion"

# 🎮 Item protocol
class GameItem(Protocol):
    name: str
    value: int
    emoji: str
    item_type: ItemType

@dataclass
class Weapon:
    name: str
    value: int
    emoji: str
    item_type: ItemType = ItemType.WEAPON
    damage: int = 10

@dataclass
class Armor:
    name: str
    value: int
    emoji: str
    item_type: ItemType = ItemType.ARMOR
    defense: int = 5

# 👤 Player class with types
class Player:
    def __init__(self, name: str, player_class: PlayerClass) -> None:
        self.name = name
        self.player_class = player_class
        self.level: int = 1
        self.health: int = 100
        self.inventory: List[GameItem] = []
        self.achievements: List[str] = ["🌟 First Steps"]
        
    def add_item(self, item: GameItem) -> bool:
        """Add item to inventory 🎒"""
        if len(self.inventory) < 20:  # Inventory limit
            self.inventory.append(item)
            print(f"✨ {self.name} found {item.emoji} {item.name}!")
            return True
        print(f"❌ Inventory full!")
        return False
    
    def use_potion(self, heal_amount: int) -> None:
        """Use a healing potion 🧪"""
        old_health = self.health
        self.health = min(100, self.health + heal_amount)
        healed = self.health - old_health
        print(f"💚 Healed for {healed} HP! Health: {self.health}/100")
    
    def level_up(self) -> None:
        """Level up the player 📈"""
        self.level += 1
        self.health = 100  # Full heal on level up
        self.achievements.append(f"🏆 Level {self.level} {self.player_class.value.title()}")
        print(f"🎉 {self.name} reached level {self.level}!")
    
    def get_stats(self) -> Dict[str, Union[str, int, List[str]]]:
        """Get player statistics 📊"""
        return {
            "name": self.name,
            "class": self.player_class.value,
            "level": self.level,
            "health": self.health,
            "items": len(self.inventory),
            "achievements": self.achievements
        }

# 🎮 Using the type-safe game system
player = Player("Hero", PlayerClass.WARRIOR)
sword = Weapon("Iron Sword", 50, "⚔️", damage=15)
shield = Armor("Wooden Shield", 30, "🛡️", defense=8)

player.add_item(sword)
player.add_item(shield)
player.use_potion(25)
player.level_up()

print(f"📊 Stats: {player.get_stats()}")

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Generics and Type Variables

When you’re ready to level up, try generic types:

from typing import TypeVar, Generic, List, Callable, Optional

# 🎯 Create a generic type variable
T = TypeVar('T')

# 🪄 Generic container class
class MagicBox(Generic[T]):
    def __init__(self) -> None:
        self._items: List[T] = []
        self.sparkles = "✨"
    
    def add(self, item: T) -> None:
        """Add an item to the magic box 📦"""
        self._items.append(item)
        print(f"{self.sparkles} Added item to magic box!")
    
    def get_all(self) -> List[T]:
        """Get all items from the box 🎁"""
        return self._items.copy()
    
    def transform(self, func: Callable[[T], T]) -> None:
        """Transform all items with magic! 🪄"""
        self._items = [func(item) for item in self._items]

# 🎮 Using generic types
number_box: MagicBox[int] = MagicBox()
number_box.add(42)
number_box.add(7)
number_box.transform(lambda x: x * 2)

string_box: MagicBox[str] = MagicBox()
string_box.add("Hello")
string_box.add("World")
string_box.transform(lambda s: s.upper())

🏗️ Advanced Topic 2: Protocols and Structural Subtyping

For the brave developers, here’s structural subtyping:

from typing import Protocol, runtime_checkable

# 🚀 Define a protocol
@runtime_checkable
class Drawable(Protocol):
    """Anything that can be drawn 🎨"""
    def draw(self) -> str: ...
    @property
    def color(self) -> str: ...

# 🎯 Classes that implement the protocol
class Circle:
    def __init__(self, radius: float, color: str) -> None:
        self.radius = radius
        self._color = color
    
    def draw(self) -> str:
        return f"⭕ Drawing a {self._color} circle!"
    
    @property
    def color(self) -> str:
        return self._color

class Square:
    def __init__(self, size: float, color: str) -> None:
        self.size = size
        self._color = color
    
    def draw(self) -> str:
        return f"⬜ Drawing a {self._color} square!"
    
    @property
    def color(self) -> str:
        return self._color

# 🎨 Function that accepts any drawable
def paint_shape(shape: Drawable) -> None:
    """Paint any drawable shape 🖌️"""
    print(shape.draw())
    print(f"Using {shape.color} paint 🎨")

# ✨ Both work with the protocol!
circle = Circle(5.0, "red")
square = Square(10.0, "blue")

paint_shape(circle)  # ✅ Works!
paint_shape(square)  # ✅ Also works!

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: The “Any” Escape Hatch

from typing import Any, List

# ❌ Wrong way - losing all type safety!
def process_data(data: Any) -> Any:
    """This could be anything 😰"""
    return data.do_something()  # No type checking!

# ✅ Correct way - be specific!
def process_numbers(data: List[int]) -> int:
    """Process a list of numbers safely 🛡️"""
    return sum(data)  # Type checker ensures this works!

🤯 Pitfall 2: Ignoring Optional Types

from typing import Optional

# ❌ Dangerous - might be None!
def get_user_age(user_id: str) -> int:
    user = find_user(user_id)  # Could return None!
    return user.age  # 💥 AttributeError if user is None!

# ✅ Safe - handle the None case!
def get_user_age(user_id: str) -> Optional[int]:
    user = find_user(user_id)
    if user is None:
        print("⚠️ User not found!")
        return None
    return user.age  # ✅ Safe now!

😵 Pitfall 3: Mutable Default Arguments

from typing import List, Optional

# ❌ Classic Python gotcha!
def add_item(item: str, items: List[str] = []) -> List[str]:
    items.append(item)  # 💥 Shared mutable default!
    return items

# ✅ Correct way - use None as default!
def add_item(item: str, items: Optional[List[str]] = None) -> List[str]:
    if items is None:
        items = []  # ✨ Fresh list each time!
    items.append(item)
    return items

🛠️ Best Practices

1. 🎯 Start Gradually: Add types to new code first, then existing code
2. 📝 Use Type Aliases: Make complex types readable
3. 🛡️ Enable Strict Mode: Use --strict flag for maximum safety
4. 🎨 Document with Types: Let types tell the story
5. ✨ Keep It Simple: Don’t over-engineer your type annotations

from typing import Dict, List, Union

# 🎨 Type aliases for clarity
UserId = str
UserData = Dict[str, Union[str, int, List[str]]]

# ✅ Clear and readable
def get_user_info(user_id: UserId) -> UserData:
    """Get user information by ID 👤"""
    return {
        "id": user_id,
        "name": "Alice",
        "age": 28,
        "hobbies": ["coding", "gaming", "reading"]
    }

🧪 Hands-On Exercise

🎯 Challenge: Build a Type-Safe Task Management System

Create a fully typed task management application:

📋 Requirements:

• ✅ Tasks with title, description, status, and priority
• 🏷️ Categories for tasks (work, personal, urgent)
• 👤 User assignment with type safety
• 📅 Due dates with proper datetime types
• 🎨 Each task needs an emoji based on priority!
• 🔍 Search functionality with type-safe filters

🚀 Bonus Points:

• Add type-safe sorting by different fields
• Implement a notification system with protocols
• Create custom type guards for task validation

💡 Solution

from typing import List, Dict, Optional, Protocol, TypedDict, Literal
from datetime import datetime
from enum import Enum
from dataclasses import dataclass, field

# 🎯 Define our type system
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    URGENT = "urgent"

class Status(Enum):
    TODO = "todo"
    IN_PROGRESS = "in_progress"
    DONE = "done"

class Category(Enum):
    WORK = "work"
    PERSONAL = "personal"
    URGENT = "urgent"

# 📝 Task type with all fields
@dataclass
class Task:
    title: str
    description: str
    status: Status = Status.TODO
    priority: Priority = Priority.MEDIUM
    category: Category = Category.PERSONAL
    assignee: Optional[str] = None
    due_date: Optional[datetime] = None
    created_at: datetime = field(default_factory=datetime.now)
    id: str = field(default_factory=lambda: str(datetime.now().timestamp()))
    
    @property
    def emoji(self) -> str:
        """Get emoji based on priority 🎨"""
        emoji_map = {
            Priority.LOW: "🟢",
            Priority.MEDIUM: "🟡",
            Priority.HIGH: "🟠",
            Priority.URGENT: "🔴"
        }
        return emoji_map[self.priority]

# 🔍 Search filters type
class TaskFilter(TypedDict, total=False):
    status: Optional[Status]
    priority: Optional[Priority]
    category: Optional[Category]
    assignee: Optional[str]

# 📊 Task manager with full type safety
class TaskManager:
    def __init__(self) -> None:
        self.tasks: List[Task] = []
        
    def add_task(self, task: Task) -> None:
        """Add a new task ➕"""
        self.tasks.append(task)
        print(f"{task.emoji} Added: {task.title}")
    
    def update_status(self, task_id: str, new_status: Status) -> bool:
        """Update task status 🔄"""
        for task in self.tasks:
            if task.id == task_id:
                old_status = task.status
                task.status = new_status
                print(f"✅ Updated {task.title}: {old_status.value} → {new_status.value}")
                return True
        print(f"❌ Task not found!")
        return False
    
    def search_tasks(self, **filters: TaskFilter) -> List[Task]:
        """Search tasks with type-safe filters 🔍"""
        results = self.tasks.copy()
        
        for key, value in filters.items():
            if value is not None:
                results = [t for t in results if getattr(t, key) == value]
        
        return results
    
    def get_stats(self) -> Dict[str, int]:
        """Get task statistics 📊"""
        stats = {
            "total": len(self.tasks),
            "todo": len([t for t in self.tasks if t.status == Status.TODO]),
            "in_progress": len([t for t in self.tasks if t.status == Status.IN_PROGRESS]),
            "done": len([t for t in self.tasks if t.status == Status.DONE]),
        }
        return stats
    
    def get_overdue_tasks(self) -> List[Task]:
        """Get overdue tasks ⏰"""
        now = datetime.now()
        return [
            task for task in self.tasks
            if task.due_date and task.due_date < now and task.status != Status.DONE
        ]

# 🎮 Custom type guard
def is_urgent_task(task: Task) -> bool:
    """Type guard for urgent tasks 🚨"""
    return task.priority == Priority.URGENT or task.category == Category.URGENT

# 🎯 Test it out!
manager = TaskManager()

# Add some tasks
task1 = Task(
    title="Learn Mypy",
    description="Master static type checking",
    priority=Priority.HIGH,
    category=Category.PERSONAL
)

task2 = Task(
    title="Code Review",
    description="Review team's pull requests",
    priority=Priority.URGENT,
    category=Category.WORK,
    assignee="Alice",
    due_date=datetime(2024, 12, 31)
)

manager.add_task(task1)
manager.add_task(task2)

# Search with type safety
work_tasks = manager.search_tasks(category=Category.WORK)
urgent_tasks = [t for t in manager.tasks if is_urgent_task(t)]

print(f"\n📊 Stats: {manager.get_stats()}")
print(f"🚨 Urgent tasks: {len(urgent_tasks)}")

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

• ✅ Add type annotations to your Python code 💪
• ✅ Run Mypy to catch bugs early 🛡️
• ✅ Use advanced types like Generics and Protocols 🎯
• ✅ Avoid common pitfalls that trip up beginners 🐛
• ✅ Build type-safe applications with confidence! 🚀

Remember: Static typing in Python is optional but powerful! Start small and gradually add more types as you get comfortable. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Mypy and static type checking!

Here’s what to do next:

1. 💻 Install Mypy and start adding types to your current project
2. 🏗️ Build a small type-safe application using what you learned
3. 📚 Configure Mypy with a mypy.ini file for your project
4. 🌟 Explore more advanced features like type stubs and plugins

Remember: Every Python expert started somewhere. Keep practicing, keep learning, and most importantly, have fun making your code safer! 🚀

Happy type checking! 🎉🚀✨