DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports Events Over 2 million developers have joined DZone. Join Today! Thanks for visiting DZone today,
Edit Profile Manage Email Subscriptions Moderation Admin Console How to Post to DZone Article Submission Guidelines
View Profile
Sign Out
Refcards
Trend Reports
Events
Zones
Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
  1. DZone
  2. Coding
  3. Languages
  4. Python 3: Variable Annotations

Python 3: Variable Annotations

Python is one of the most important programming languages for big data. Read on to learn more about Python and master this powerful language.

Mike Driscoll user avatar by
Mike Driscoll
·
Nov. 02, 18 · Tutorial
Like (6)
Save
Tweet
Share
16.89K Views

Join the DZone community and get the full member experience.

Join For Free

Python added syntax for \ something called Variable Annotation in version 3.6. Variable Annotation is basically an enhancement of type hinting, which was introduced in Python 3.5. The full explanation behind Variable Annotation is explained in PEP 526. In this article, we give have a quick refresher on type hinting and then introduce the new Variable Annotation syntax.

What's Type Hinting?

Type hinting in Python is basically declaring that the parameters in your functions and methods have a certain type. Python does not enforce the type "hints," but you can use tools like mypy to enforce the type hints in much the same way that C++ enforces type declarations at runtime. Let's look at a normal function with no type hints added:

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

if __name__ == '__main__':
    add(2, 4)

Here we create an add() function that takes two parameters. It adds the two parameters and returns the result. What we don't know is what we need to pass to the function. We could pass it integers, floats, lists, or strings and it would most likely work. But would it work the way we expected it to? Let's add some type hinting to our code:

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

if __name__ == '__main__':
    print(add(2, 4))

Here we change the definition of the function to utilize type hinting. You will notice that now the parameters are marked with what type they should be:

  • a:int 

  • b:int 

We also hint at the return value, which is what the "-> int" is. That means we expect an integer as our return value. If you try calling the add() function with a couple of strings or a float and an integer, though, you won't see an error. As I said, Python just allows you to hint at what the type of the parameters should be, but it does not enforce it.

Let's update the code to the following:

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

if __name__ == '__main__':
    print(add(5.0, 4))

If you run this, you will see it executes just fine. Now let's install mypy using pip:

pip install mypy

Now that we have mypy, we can use it to determine if we are using our function correctly. Open up a terminal and navigate to the folder that you save the above script to. Then execute the following command:

mypy hints.py

When I ran this command, I received the following output:

hints.py:5: error: Argument 1 to "add" has incompatible type "float"; expected "int"

As you can see, mypy found a problem with our code. We are passing in a float for the first argument instead of an int. You can use mypy on a continuous integration server that can check your code for these kinds of issues before committing pushing your submission to your branch or running it locally before committing your code at all.

Variable Annotation

Let's say you want to not just annotate function parameters but also regular variables. In Python 3.5, you couldn't do this using the same kind of syntax as you would for function parameters as it would raise a SyntaxError. Instead, you would need to use comments, but now that 3.6 is out, we can use the new syntax! Let's look at an example:

from typing import List

def odd_numbers(numbers: List) -> List:
    odd: List[int] = []
    for number in numbers:
        if number % 2:
            odd.append(number)

    return odd

if __name__ == '__main__':
    numbers = list(range(10))
    print(odd_numbers(numbers))

Here, we specify that the variable, odd, should be a list of integers. If you run mypy against this script, you will receive no output as we are doing everything correctly. Let's try changing the code to add something other than an integer though!

from typing import List

def odd_numbers(numbers: List) -> List:
    odd: List[int] = []
    for number in numbers:
        if number % 2:
            odd.append(number)

    odd.append('foo')

    return odd

if __name__ == '__main__':
    numbers = list(range(10))
    print(odd_numbers(numbers))

Here we add a new line that appends a string to the list of integers. Now if we run mypy against this version of the code we should see the following:

hints2.py:9: error: Argument 1 to "append" of "list" has incompatible type "str"; expected "int"

Just to reiterate, in Python 3.5 you could do variable annotation, but you had to put that annotation in a comment:

# Python 3.6
odd: List[int] = []

# Python 3.5
odd = [] # type: List[int]

Note that if you change the code to use the Python 3.5 variation of variable annotation syntax, mypy will still flag the error correctly. You have to specify the "type:" after the pound sign though. If you remove that, then it's no longer variable annotation. Basically, all PEP 526 added was making the syntax more uniform across the language.

Wrapping Up

At this point you should have enough information to start doing variable annotation in your own code whether you're using Python 3.5 or 3.6 I think it's a neat concept and will be especially useful to those programmers that work with others that are more familiar with a static, typed language.

Annotation Python (language)

Published at DZone with permission of Mike Driscoll, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • Learning by Doing: An HTTP API With Rust
  • Multi-Cloud Database Deep Dive
  • How To Get Page Source in Selenium Using Python
  • The New DevOps Performance Clusters

Comments

Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends: