[MUSIC]

Hey y'all, I'm Kenneth, your Treehouse Python teacher.

Today I want to talk about an interesting newer feature in Python that has caused

a bit of a ruckus.

Python, like JavaScript and Ruby, and many other languages, is dynamically typed.

This means that a variable like name could change from an int to a string to a list,

to whatever else it needs to be.

This is different from languages like Java and C#, where a variable has a type

declared when it's created and it will always hold some data that fits that type.

But you probably already know this, so why am I telling you?

Well, with the acceptance of some recent PEPs,

Python has an officially supported way of doing type hinting.

It started ten years ago when PEP 3107 landed in Python 3.0.

This PEP allowed for function annotations.

You could provide information about the parameters that a function took in

its return value, and

these would show up in the __annotations__ attribute of the function.

Then came Mypy, a static type checker for Python.

This tool would look for special formatting in your Python code where you'd

declare what type a parameter should be, and

then it would tell you if you ever gave it something else.

This checker and many others like it didn't and

won't make Python statically typed.

They didn't and don't enforce anything at runtime.

Instead they're used during code reviews and

in build processes to make sure code fits a standard.

In Python 3.5, Guido introduced PEP 484, which officially laid out

a specification for how these type annotations should look and behave.

This is also when the typing module came into Python,

which we'll look at more later.

And for Python 3.6, PEP 526 gave us variable annotations.

So now you can annotate parameters to functions and methods, and

state what type of data you'd like a particular variable to hold.

These PEPs caused quite a stir.

People jumped to conclusions and declared that Python was abandoning its dynamic and

duck type roots.

Of course, that hasn't and won't happen.

All of this type hinting is just another tool to use when you're developing.

It's especially useful for larger code bases or

code where you can't look through all of the source easily.

PyCharm supports these annotations natively and

will show you warnings if you violate them.

If you don't use PyCharm, the Mypy tool will do the same.

Like I said, type hinting isn't going to change Python.

It's 100% opt in per file, and even per function or per variable.

In fact even with the type hint and a static checker,

you can send any data you want to any function or variable you want.

Well, assuming it won't cause an exception.

Like doc strings,

testing, and naming conventions, it's a tool to make your work easier.

It's something to discuss and decide on with your team.

If you decide to use it though, I'm sure will save you more than one headache.

So let me show you about type hinting.

We'll start with a really straightforward example, then talk about generics and

optionals, and how to use stub files for

compatibility with older versions of Python.