Like I said in the introduction to this workshop,

Python 3.5 gave us the typing module.

This module defines a bunch of,

well, types that we can use when creating hints for our code.

Let's look at something a bit more complex.

I've been working on some classes that all relate to recipes.

There's an ingredient class that's already typed it just uses strings but

the ones in this model are a bit more complicated.

For instance the recipe ingredient class can when instantiated receive

either an ingredient or a string to turn into an ingredient.

Maybe not the best design but that's what I have to work with.

In the typing module there are several types defined for

these more complex situations but

there are three of them that you'll find yourself using more often than the others.

It just so happens that I need to use all three of them in here.

So let me go ahead and import these,

the first one that I want to talk about is list.

So I'm gonna say from typing import list.

The list type lets you say that you want a list of items of a particular type.

For example, I would want a list of strings,

if I was annotating the str.join method.

In my recipe class,

down here, I want to store ingredients as a list of recipe ingredients.

I wanted to start out blank too, so, hey, you get a twofer.

So ingredients right now is a list and I'm gonna say this is gonna

be a list of RecipeIngredients and I want it to be a blank list.

So that's what this equals blank is and

for instance self.title right here is going to be a string.

And I also want to have steps be a list of recipe steps.

And this is where we're using Python 3.6's variable type hinting too, by the way,

this line right here.

Just like when we hint function parameters, we use a colon and

then the type.

And if we don't want to define a default value for the variable,

we can just name it and hint it, right?

So, if I had say another one, self.order,

this is just going to be an int, all right?

So, that just makes that one an int.

But if I want to have a default value or

I want to assign a value, I can do with an equal sign afterwards.

And I don't need that order, so I'm gonna go ahead and take that out.

The method where we just have the variable name and the type ends up looking a lot

like other languages where you have to declare a variable before you can use it.

But this is 100% semantic sugar and

doesn't actually create the variable in Python.

Quick note about lists.

Much like the actual list type you don't usually want to

use it when you're declaring types with parameters in a function or a method.

You want to check out the mapping sequence and abstract set types from the typing

module for those cases there's a link to these in the teacher's notes.

I also wanna make this one add a string.

All right, so what about recipe ingredient needing either a string or an ingredient.

Right right up here that was our thing.

Well this is where the union type comes in.

Union lets you specify two or more valid types.

So let's bring in union.

And then here for ingredient I'm gonna say

this is a union of ingredient or string.

So now the type checkers know that either of these values are valid for the method.

If you do a union with only one type Python ignores the union and

just uses the type that you included.

Python also flattens unions If you nest them.

All right on to the third handy dandy type that I mentioned this one is optional.

Not that it is optional.

It's called optional and it specifies that a type is well exactly that it's optional.

This means that the value can be one of the types that are specified or none.

This is really good for places where you have arguments that can be left out

in fact recipe ingredient needs exactly that.

Because measurement here can be none.

So we'll say that measurement is optional and

if it's available if it's included I want it to be a string.

Otherwise it's none condition would be the same.

The measurable value is optional, defaults to none.

Now the type checker knows that it's okay for the argument to be admitted.

If you look through the downloads that are associated with this workshop,

you'll see this file fully filled out with types.

Something you might notice is that it feels a bit redundant.

You could just specify the types when you're defining the method parameters and

be safe enough.

But I like to specify the types when I first define a variable too.

Just make sure that my thinking follows the same pattern all the way through again

this is something to decide with your team.