 If we think about everything that we've covered in this course, we've talked about file IO, we've talked about control structures, we've talked about different data types. In a nutshell, we have talked about how to program. We know how that there's not really much else to it, aside from actually applying our ability. And that's actually sort of where we're going with the remainder of this course is in this idea of taking sort of what we've learned and applying it. And there's a big fancy $5 word nowadays that gets thrown around here, something known as data science, data science. But realistically, all they're attempting to do is, oh goodness, statistics with code. Realistically, that's all we're looking to do. We have our ability to do code, which is a very quick way to do heavy mathematical calculations. Well, guess what? Statistics is a way to do. I wouldn't call them heavy, but mathematical calculations. And so realistically, we're just saying, can I then use my code to do all of these applied mathematics? And in fact, yes, we can. And this is actually where some of Python's sort of popularity and notoriety, notoriety, notoriety comes from. And the idea is that there are these different libraries that said, you've got a lot of different mathematical calculations going on there. Awesome. Fantastic. Here you go. Here's how to do them in a nutshell. So they handle it quite well. Now, when we're working off of say, for example, NumPy, just it's more of a, you know, commonality here, but for programmer's sake, we hate typing anything. So something like NumPy, too many letters. It's just too many letters. So the sort of de facto default way to reference NumPy is as in P. I'm just more, this is a way to kind of just throw this out there. This is no different than when we do things like import random as R or import math as M, we're just trying to shorthand it MP sort of is the the standard that people use. So why is NumPy so powerful? Why is it you know, oh, yeah, it does the thing. But the way to think about this is, if I sort of built out a list, right, this is a list. The big thing is that from Python's perspective, they only treat collection as a collection of numbers, a list, I can add to the list, I can remove from the list. But I can't really do mathematical calculations, even though it's how we could look at this also as a vector. And maybe we want to, you know, treat it like a vector rather than a collection. And in fact, that is where NumPy comes into play. And it says we're going to take sort of your list, just to redraw it out here real fast, we're going to take your list and we're going to convert it into an object known as a NumPy array. Now remember, when we think about the idea of objects, they're just are these complex data types that have both functions attached to them and special, you know, properties as well. We've seen this with working off of CSV Dick reader, literally strings, that's all they're kind of worked or they're dealing with. And so if we think about it, when we design out an array, we start off by presenting it with in p dot array. Again, now we're just saying, I want to work off of this particular library, which has a function attached to it that is expecting a list. And this will convert it into that array. Now, yes, we can see that there are a number of different ways. But let's actually see this in action. So I happen to have built out a little bit of code here. Again, I have that import NumPy as in p. And I have a small list of just nine numbers stored in x. Now this is my typical go to way of doing it instead of having it sort of built out and trying to write it all in one line. I don't like it because it's just too much the the arrays could get really large. So I like to build that list out first and then in p dot array x. Now in this case, I'm, you know, x is just my variable. And this is going to convert it from a list into a NumPy array. And not anything terribly different goes on there. As you can see, it still looks like a list. There's no comma. But again, you know, it's treating it like it's a matrix instead of a list of numbers. From a philosophical standpoint, they are different from a technical standpoint, they are the same. But you can see that NumPy also allows for some different functionality. Again, if it's treating it like a vector or a matrix, they have a shape associated to them. Ours is just a one dimensional vector of nine values, but it has a shape associated to it. And it has a size. So far, these aren't anything terribly different or crazy, you know, they're no different than when we were working off of a list. You know, this is Lynn in a nutshell. So I haven't done anything outlandish. But where we start to get really crazy, and just to show these off for a second, I can make another array, where we start to get really interesting is when we start trying to do array operations, the idea here is that we're now dealing with element by element operations. So in this case, let's say for example, I want to take my x and this compare one d that I've worked off of. Now, you know, again, we have our x array that is one through nine, and then compare one d, which is five to 15. Well, if I did something like plus between them and just a plus operation, well, go in element by element, and add those respective elements together. And I know that there's a little spacing thing here going on that happens for, I think it's due to the two dimensions, two digits and single digits. But my point is, you know, oh, well, you can see this nine and this 13, if we were to add them together, that would be 22. The same thing can come into play, we can also do comparison operations. So in this case, we can see that every element is in the x is not larger than every element in its respective location in the compare one d. And then the same kind of thing, you can see that we can also do scalar values. So now instead of doing a comparison on another array, I just want to say, where, where is there a value that is greater than four? And so yes, one is not just to have that in place. One is not two is not three is not four is not greater than four, but five is six is seven is eight is nine is and just to see that maybe in a different light compare greater than 10. Same kind of concept going on there, you can see that five, six, seven, eight, nine, 10 are not. But 11, 12, 13 are where this starts to get really crazy is when we sort of increase from a vector into a matrix. And in this case, you can see, oh, well, I've created a two dimensional array that is just ones and zeros. That's mostly just because I randomly picked one or zero. But you can see, oh, well, that shape is now telling me it is a three by three matrix. And that size is now telling me, oh, well, there are nine elements in the matrix. So you can see that this sort of kind of allows us to get the size of the elements without having to do anything terribly crazy, like we would with a list. So we're starting to see some connections going on there. And I've built another comparison to the dimensional array just to show that off. In that case, let's see if we wanted to look at each element and say, are they equal? Well, this is where we get into sort of the matrix operations versus element wise operations. If we do comparisons, again, if we've done just like any operator we've done in the past, it says go to each respective element and apply this operator. So just because we're in a two dimensional matrix or a 2d matrix, it's not going to change that. So this one, is it equal to this or is this value equal to this value? No, so false, you can see that that goes on. But these last these inner sort of four zero one zero one or zero one one zero, those are equal in both. So we get a true. Maybe that's not what we're dealing or looking for. Instead, we are actually looking to say, are these variables, or are these two matrices equal? And so NumPy has a way to do that. And that's where again, because we can't use the equal sign like we've done in the past, does something different. Unfortunately, NumPy says, Oh, well, let me compare. Let me look at two arrays, two matrices, y and compare to or compare 2d and say, Oh, well, let me compare them. And in this case, yes, they are false, because again, we we saw that. But if I did something like compare y to itself. Oh, you can see that it's going to get a true value going on there. The reason why this is sort of prevalent is that same kind of approach happens when we're dealing with something like multiplication. Right, you know, matrix multiplication is a little different than go to each element and multiply it by its respective place. That's not the same thing. Well, that's where if I did just do why times compare 2d again from a a Calculate from an element wise operation, go to each element and multiply it by its respective value. And in our case, that just gives us sort of this 0 1 1 0 as our end product. But that is again, not matrix multiplication or producing a dot product. Or maybe that's not what we're looking for. And very similar to array equal, there is a way to get the dot product of two matrices. And there we go. Oh, look at that. Now we're actually getting the dot product of our matrix to matrix handling