Python’s Framework for Type Annotations

in

But hey, who doesn’t love nerding out over some fancy syntax?

To set the stage: what are these so-called “type hints”? Well, they’re basically little notes you add to your Python functions and variables to let the computer know exactly what type of data it should expect from them. It’s like a secret language that only computers can understand but don’t worry, we’ll teach you how to speak it!

Here’s an example: instead of writing `def add_numbers(x, y):` and hoping for the best, you could write `def add_numbers(x: int, y: int) -> int:` this tells Python that both x and y should be integers (duh), and that the function will return an integer as well.

Now, some of you might be thinking “But wait a minute! This is just extra work for no reason!” And to that we say… yes, technically speaking, it’s true. But hear us out: type hints can actually help catch errors before they even happen which means less time spent debugging and more time spent doing fun stuff like playing video games or eating pizza (or both!).

Type hints also make your code easier to read for other people who might be working on it. Imagine you’re collaborating with someone on a project, and they see this: `def get_user(id):` what type of data is id supposed to be? A string? An integer? Who knows! But if you add the hint `get_user(id: int) -> User`, suddenly it’s crystal clear.

So how do we use these fancy annotations in our code? Well, there are a few different ways but let’s start with the most common one: adding them directly to your function or variable definitions. Here’s what that might look like:

# This script defines a function, variable, and class with type annotations to demonstrate their usage in Python.

# First, we define a function called "add_numbers" that takes in two integer parameters, "x" and "y", and returns an integer. The "-> int" annotation at the end indicates that the function will return an integer value.
def add_numbers(x: int, y: int) -> int:
    return x + y

# Next, we create a list called "my_list" and assign it to contain three integers. The "# type hint for list of integers" comment indicates that we are using a type hint to specify the data type of the elements in the list.
my_list = [1, 2, 3] # type hint for list of integers

# Finally, we define a class called "User" with a constructor that takes in an integer parameter, "id". The "__init__" function is used to initialize the object's attributes, and the "self.id = id" line assigns the "id" parameter to the "id" attribute of the object. The ": int" annotation after the "id" parameter indicates that it should be an integer value.
class User:
    def __init__(self, id: int):
        self.id = id

Now, if you’re working with an older version of Python (like 3.5 or earlier), you might need to use “type comments” instead which basically involve adding a comment next to your variable or function that describes its type. Here’s what that would look like:

# This script is used to demonstrate the use of type hints and type comments in Python.

# Function to add two numbers and return the result
def add_numbers(x: int, y: int) -> int: # type hint for int -> int
    return x + y

my_list: list[int] = [1, 2, 3] # type comment for list of int

# Class to represent a user with an id
class User:
    def __init__(self, id: int): # type comment for int
        self.id = id # Assigns the id parameter to the id attribute of the User class

And if you’re working with a library or package that doesn’t support annotations (or if you just prefer to keep things simple), you can also use “stub files” which are basically text documents that describe the types of functions and variables in your code, without actually changing anything. Here’s what one might look like:

# my_library/my_module.pyi
# Importing the necessary typing modules to add annotations
from typing import List, Dict

# Defining a function named "get_users" that takes in an integer argument "page" and returns a list of User objects
def get_users(page: int) -> List[User]:
    ...

# Defining a class named "User" with a constructor that takes in an integer argument "id" and assigns it to the "id" attribute of the object
class User:
    def __init__(self, id: int):
        self.id = id

We know it might seem like extra work at first, but trust us once you get the hang of it, your code will be cleaner, more readable, and less prone to errors. And who doesn’t love that?

Now go forth, my nerdy friends, and annotate thy code!

SICORPS