Oh, yes, and welcome back to another class of our course, want the complete introduction to that
science with Python.
So in this class, we are going to talk about Seabourne like in the best class, and we are still going
to learn how to use this amazing visualization tool.
So let's go into this class.
We are going to create another type of graph which is called the Cat Blood.
And basically inside of this block, what we are going to find, we are going to find once again, dots
or lines or basically what's cool about it is that it will give us the higher limit and the lower limit.
So basically, we will be able to see, for example, what is the most popular element of the graph,
for example.
So to help you better understand this graph, what I propose you is a basic example.
So we are still going to work with databases from GitHub in this case.
And the database that we are going to use today will be the flight's database.
So basically, for those of for those of you who don't know from which database, we are going to take,
everything that you can see, it's from here.
It's from GitHub.
And basically we are going to work with the database that is right here.
All right.
So our goal today will simply be to understand what is the most popular month of the year to fly.
So once again, this is something that is pretty simple to do and will analyze the data that we have
to be able to understand what is the most popular month of the year.
All right.
So, like always, the first step, the first step or the first thing that we need to do is importing
our database.
And this is exactly old.
So we need to create a variable to store everything.
So let's create the variable and call it database.
So this is our variable.
And inside of this variable, we want to import our data sets like always.
What we will do all right is because we are making reference to Seabourne and we will write down load
dataset.
So we want to load the data set.
So what data set we want to have?
We want to have the flight data sets in this case will simply write down flights.
So here we go.
We have our dataset ready.
Next thing, we want to print everything to be sure that everything works fine.
So we want to print data base, which is in this case, the Bible that we have just for you.
And we want to run everything.
So if we have something generated right here, it means it works.
If not, well doesn't work.
So as you can see right here, we have generated absolutely everything we need.
So as you can see, we have the years, the months and the number of passengers, which is quite amazing.
So we have everything that we need.
All right.
From now, as I said, we want to do is we want to know in what month we have a lot of passengers inside
of our flights.
So this is exactly what we'll do.
All right.
So next thing that we want to do, since we have printed everything, we want to create our well, generate
our blood.
So how exactly do we generate the plot?
It's pretty simple.
So we'll just write down as the dot chat plot.
So this is the blood that we are going to work with.
This is the type of graph.
So you'll see it's pretty simple.
So instead of the cardboard, what exactly we need to write down, we have four arguments.
So three of those four arguments are amendatory.
So we need them to be able to make the graph work.
And we have one argument that is optional, but we are going to talk about it a bit later.
So the first argument that we need is the X.
So in our cases, in our case, the X value will be the months.
So basically the month will be our X value.
Then we need a Y value for our graph.
And in our case, the value of the graph will be the passengers.
So here we go.
We have the passengers.
So very important.
Don't make any mistake when you write down those arguments, because if you make a mistake, it's just
not going to work.
All right.
Next argument is from where exactly we will take the data.
So in our case, we are going to take the data from the variable data base.
So the data is stored inside the database and this is where we are going to take it.
So simply write down the data and the data that we are going to take will be taken from data base.
All right.
So those are the three viable arguments that are mandatory for our graph or for our blood to be generated.
So let's run everything and see what it all looks like.
Oh, I forgot one argument there.
So we need to show everything.
So it's going to be team that show.
They're.
So don't forget this little line of code as I did.
All right.
So simply run everything.
So here we go.
We have our graph right here.
So this is the basics.
Once again, here we have our outgroup.
It looks pretty complicated to understand at first, but this is the one of the types of grab that we
can generate with the blood.
So basically, there are plenty of other types of retention.
So as you can see, we automatically can see that July is the most important month of the year in terms
of how many flights there is or how many passengers there is.
Well, how many passengers there is.
There is.
And in the years that have been have been generated right here.
So if you want to have something that is a bit more presentable, we can use a different type of graph
for the checkbook.
So basically, how do we do this?
It's pretty simple.
We are going to use the optional argument that is called kind so we can choose the kind of grab that
we want.
So basically we can have the strip strip, which is one of the arguments in this case.
We can use strip and we can run and see what it looks like.
So here we go, we have the strip right here, the strip is basically the thing by default, then we
can use another one, which would be, for example, the violin.
Here you go.
So this is another type of graph, which is the violin.
So you'll see it's a bit this one is a bit well, it takes more space.
So it's going to be more complicated if you guys want to generate it and make it bigger.
And there are some other types well, there are plenty of types, the ones that I personally prefer
is bux, so the kind of books.
So as you can see, it looks something like this automatically.
With this type of graph, we can automatically see the demand that we have the most people is the month
of July.
So let's just make it full screen and see the month of July is the month where there is the most people.
So even the mean of July is the highest.
Then we can automatically see that the mean of the month where where there is the less people that are
flying is the month of February, because as you can see here, we have the lowest but the lowest minimum
will be in November.
So in November, we have an extreme, which is the lowest extreme.
But the month which is on average, where there is the less people flying will be February or the month
right here.
So as you can see, it's pretty cool what you guys can do with this type of graph, which is called
the Catala.
Once again, let me just summarize everything that we have learned.
So basically, as always, the lines of code right here are made to generate a database.
Then after that, the chatbot right here, pretty simple we simply write down is because we're making
a reference to Seabourne.
We write down chatbot because this is a type of flood that we need.
We have for arguments with Schema X, which is right here, the months then the number of passengers
right here, which is the way then we have our data, which is taken from database right here.
And finally, the type of graph that we want in this case, we want the box type, which is one type
of growth, and to understand the graph.
So basically what we can understand right here is that we can understand how many passengers have been
flying in this plane depending of the number of months.
Hope you guys understand everything until now.
As you can see, it's not really complicated to understand this type of graph, and it's pretty straight
to the point.
So you guys can understand it.
Pretty simple.
So that's a first class guys.
See our next class.