[MUSIC]

Well, it happened to me.

I committed to code an hour every day for the 100 day code challenge.

And sure enough, I didn't make it.

I missed two days in a row thanks to a Netflix binge.

We've all been there.

And sure enough though, technically I broke my commitment.

I was pretty bummed about it.

I was really enjoying the challenge.

Now, the good news is,

you can start your challenge over without losing your previous wins.

What you do is you just start a new round.

[SOUND] Now, if you'd started the challenge, you might have seen people

using that syntax in their tweet, r1d6, which stands for round one, day six.

But that brings up an interesting point.

How would we represent that in our study log array?

Currently each of our columns is used to represent a day.

Remember, it's a 100 element long array filled with zeros.

So how could we also track rounds?

You know what?

You're right, we just need a new dimension, don't we?

Good thinking.

Come help me out with this so I can get back to studying.

Before we get to upgrading our study log,

I'm going to review my reflections of multidimensional arrays.

I feel like I forgot a bunch of the stuff while I was binging that Netflix series.

Good thing I wrote it all down for my own recall.

So the data structure is actually called an ndarray,

representing any number of dimensions.

That's where the nd comes from.

Right, and arrays can have multiple dimensions.

And you declare them when you create them, cool.

Dimensions help define what each element in the array represents.

So a two-dimensional array is just an array of arrays,

like multidimensional lists.

Rank defines how many dimensions an array contains.

And shape defines the length of each of the array's dimensions.

Remember that was like three, four that we saw.

And each dimension is also referred to as an axis.

And they are zero indexed.

Multiples are called axes even though it looks like Paul Bunyan's axes.

And a two-dimension array is also known as matrix.

Awesome.

I am refreshed and ready to go.

Now there's a couple of ways to add a new dimension.

Let's explore one of them.

Let's get back down to where our study log is.

Here we go. Here's our study_minutes array.

Go ahead and, I think,

get rid of this where we print it out one more time and run that one more time.

There we go.

So let's make a brand new array which consists of our array and

a new row of zeroes.

So we could do that pretty easily.

We'll just, we'll reassign, we'll relabel.

We'll remove the study_minutes label from the other one and put it on this new one.

We'll say np.array.

And remember arrays accept iterables.

And our study_minutes is iterable.

So we'll say study_minutes here.

So that's an array of an array.

So we'll do an np.zeros(100).

And we'll do np.uint16.

Because that's what the original value was there.

And let's go ahead and run it.

It seems like it worked.

Let's go ahead, let's check the shape of that.

So, we'll say study_minutes.shape.

Awesome.

(2, 100).

So, our first axis, 2, will represent the round.

And our second axis will recommend the day.

So this 100 here, right?

So this is axis zero and axis one.

We have two dimensions, and our array is now of rank two.

So I did in fact complete an hour on that first day of round two.

So that's R2D1.

Do you remember how to access that element?

Why don't you go ahead and do that?

Why don't you set round 2 day 1 to 60?

So pause me and give it a go.

When you're ready, unpause me.

Ready?

Now remember it's 0 base.

I hope you didn't fall for that.

I hate trick questions.

So let's study_minutes.

And we want to get the second round, so one.

And then we want the first day, so that's zero.

And it was 60 that we're gonna set that to.

And then let's go ahead and let's peep it.

Let's see what we've got going on here.

Awesome, so this is the first round, right?

The first round goes all the way there and here's the second round.

There's the 60 that we got in there, great.

We did it, I'm going to come back up.

I'm going to get rid of this displaying of it.

And we will run that one more time to get our space back.

So, you did it, great.

But this syntax, all these brackets, that's kind of clunky, isn't it?

Well, NumPy introduces a fun shortcut of a comma.

So if we wanted to get the value from here we could just say study_minutes.

And we could say [1,0], which is the second row and the first column.

Let's see if that works and it does.

It feels better, right, and it's kinda cute.

Now what's happening here, it's a little subtle.

It might look like magic, especially if you haven't seen this before.

But if you separate values with a comma,

like we did here just in plain old Python, check it out, a tuple is assumed.

So really this is just a tuple in here.

But we don't want to add all of those, these prints.

We don't need them.

So, it looks nicer, like this.

It's easier to read.

So, in this case, each of these values represents an index to each of the axes.

But, there's another way that these indices can work.

And I want to bring this up now because it can be a bit confusing if it catches you

off guard.

There's a bunch of stuff that happens within these hard brackets and

we haven't even got to slicing yet.

It's going to sound like I'm making this up.

But I want to talk to you about a special type of indexing called fancy indexing.

In order to show this off,

I'd like to start with an array that is a single dimension.

And since our example arrays are now both two-dimensional,

I thought I'd show off a handy tool for creating some random data to explore.

Let's do this.

Let's make a new study log.

But instead of just zeros, let's make it contain fake but reasonable data.

Now this random trick is a great way to create data to play with.

So here we go.

So you can actually create a random number generator and

seed it in a way that will always produce the same results.

That way we can have the same random data, you and me.

The seed value.

So let's do this.

So it's np.random and we're gonna create a thing called RandomState.

And we'll pass it a seed value.

And the seed value I'll use, let's use 42.

You know, the answer to life, the universe, and everything.

And now, let's make a new fake log.

We'll make a round that was just totally fake.

And we'll use random integers.

So we'll say fake_log = rand.randint,

cuz we want an integer.

And we'll make the first parameter, it's the low value,

like how low should it ever go.

And we want it between 30 and then a high of 180.

That's three hours.

That's tons of studying.

And then we'll set the size to be 100.

Say size=100.

And we'll set the data type or dtype to the same thing that we've been using,

uint16, the unsigned integer.

Let's go ahead and do that, and then let's peep it.

We'll do fake_log.

Here we go.

[LAUGH] This is nice.

Aren't you glad we didn't have to type out all of these values?

Aren't you glad we didn't have to study all those minutes?

Our random values here have some that went under the hour.

So remember, you need at least 60 minutes to call the day a success.

So let's say that I wanted to grab a few of these, just to point them out,

so I can encourage myself to reach the full hour,

ones that are super close to the hour, but didn't quite reach the goal.

I could use some motivation.

I may want to build a list of these values.

So one thing that I could do is just build a list using standard indexing.

So let's see, we wanna have fake_log.

And we have to have this value, this 44, so this is 0, 1, 2, 3.

So we have 3.

And then we want the next value, 4, 5, 6, 7, 8.

50 that was so close.

So we'll do fake_log.

And then that's 8, right?

You should have a list of 44 and 50.

There we go.

Those are so close to making that hour.

But this indexing, it's pretty basic, right?

There is nothing fancy about it.

It's just pulling some values out.

Well, lift your finger like you would if you were drinking tea

as you type out this next one, cuz things are about to get fancy.

What you can do is type fake_log.

And in here we're gong to use hard brackets, say 3, 8,

and take a look at what we got back.

There is our 44 and our 50.

It's the same type of the values that we just selected.

Pretty fancy, right?

So again, using a list as a parameter here is saying return

me a new array with the values from index three and eight.

And check this out, it get's fancier.

The shape of the resulting array can be defined by the shape of the index array.

So this is just a two-element array, right?

Let's build an index array in the shape that we want.

So we'll make a 2x2 matrix.

So let's do that.

So we'll say the index, it can be named anything.

We'll declare an array of lists of lists.

So here we go, np.array.

We'll say 3, 8 like we had before.

So we had those two values.

And let's just go ahead and grab the first two values for the second row.

So we will have zero and one.

And then we can use this array for our fancy index.

So we say fake_log[index].

And you'll see back we got our 44 and our 50.

And we'll get 132 and 122, which I'm pretty sure are the first two, 0 and 1.

So we got 44, 50 and 132, 122.

And we pulled it out in a special order.

And you'll notice that the shape of the array is the same as

the index array that we wanted.

Ooh la la, c'est chic.

Now that we already have our study group log in the right rank, we already have two

dimensions, let's just go ahead and append this fake_log to the study group array.

We'll just redefine the study log because remember these array sizes

are always immutable.

So we can't just add new elements to them.

We need to create a new one.

So there's a method right off the NumPy module called append.

So we're going to say study_minutes because we're going to override that

again, equals np.append.

And what it does is it takes an array, our study_minutes array.

And it takes what you want to append.

So I guess we want to append our fake_log.

And then you tell it what axes to append, and we want that on axis zero.

I've left an intentional bug here for you to see.

Let's go ahead, let's run this.

Yikes.

Look at this mess.

All the input arrays must have the same number of dimensions.

Now this is a common Stack Overflow question.

So I figured I'd save you some time in the likelihood that you might run

into a problem like this.

So the solution here is just to make sure that the dimensions line up.

So we actually need two dimensions, right?

Our fake_log currently is just one dimension.

So one hack is you could just make this a list of lists.

There we go.

And if we take a look at our array now We'll see that it has the shape

Of three arrays, awesome.

So looking at this, I see that this one here, this is round 2,

day 2, or R2D2, everyone's favorite malfunctioning droid.

We absolutely have to set that.

That is one of the most favorite days of these rounds.

So let's set that one.

So that would be study_minutes[1,1] = 360, right?

Round two, day two equals 360.

Now note here we aren't using a fancy index.

We are using a comma or tuple shortcut.

It does get confusing so you really need to pay attention to what's

going on between these outer brackets, right?

You need to see if it's a tuple or it's a list.

In fact, you can even do multidimensional fancy indexing

by specifying fancy indexes for each dimension.

Now, it’s a bit out of the scope for this course.

So make sure to check the teacher’s notes for more on that.

And now, looking at our study log, this is about right.

Let's go ahead, let's run this one more time.

I'm going to go ahead, I am going to go in command mode.

I'm going to press dd to delete that.

And let's show our study minutes one more time.

This looks just about right to me.

This first round here, I let things slip.

Right, I got to here.

I did that dang Netflix binge of Stranger Things.

And then I worked a bit too hard on the second round, right?

I did 360 minutes on this day and I burned myself out.

But I kept on trucking and the third time's a charm.

Feels pretty realistic to me.

This is probably what a lot of people's rounds look like.

You have to just keep trying and eventually you'll get it.

No matter how many times I learn that lesson, I need to keep reminding myself.

Stick with it and you'll get it.

Now, I don't know about you, but some of these minutes on days where I almost made

it, like where they were almost an hour but not quite like we saw, they would

really help me keep going during the times where I was struggling to stick with it.

Wouldn't it be cool if we could just somehow pick out the values

just under 60 minutes to motivate ourselves, but

not have to pick them out by hand, visually, like we did?

Well you can, and let's do that right after this quick break.

Ooh, and also, I'm gonna write out some notes on our array creation and

appending indexing skills.

So let's come up here to where we started doing this.

Let's go right here.

We're gonna go ahead.

And I'm gonna get into command mode, go one above.

Change this over here to markdown.

And I wanna talk about array creation.

Then let's also talk about indexing over here.

So in the creation let's talk about random state.

And well talk about how to append rows.

And then indexing wise let's talk about the shortcut tuple one, right?

We'll talk about the tuple shortcut and I also wanna talk about fancy indexing.

Wow, that was a lot that we covered, good job.

I'm gonna swing back after a quick break and flesh this out for better notes.

And then I'll share them with you.

Why don't you do the same, and I'll see you in a bit.