DS109-Python/DS109-L9-Matrix-Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Nine Matrix Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L9_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L9_toc)\n",
    "    * [Page 1 - Introduction](#DS109L9_page_1)\n",
    "    * [Page 2 - Numpy Arrays](#DS109L9_page_2)\n",
    "    * [Page 3 - Aggregate Functions on Arrays](#DS109L9_page_3)\n",
    "    * [Page 4 - Data Generation with NumPy](#DS109L9_page_4)\n",
    "    * [Page 5 - Arithmetic with Arrays](#DS109L9_page_5)\n",
    "    * [Page 6 - Indexing on Arrays](#DS109L9_page_6)\n",
    "    * [Page 7 - Creating Matrices with Arrays](#DS109L9_page_7)\n",
    "    * [Page 8 - Matrix Arithmetic and Aggregation](#DS109L9_page_8)\n",
    "    * [Page 9 - Matrix Indexing](#DS109L9_page_9)\n",
    "    * [Page 10 - Aggregating Matrix Values Across Columns and Rows](#DS109L9_page_10)\n",
    "    * [Page 11 - Manipulating Matrices](#DS109L9_page_11)\n",
    "    * [Page 12 - Key Terms](#DS109L9_page_12)\n",
    "    * [Page 13 - Lesson 9 Hands-On](#DS109L9_page_13)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Introduction<a class=\"anchor\" id=\"DS109L9_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b6d15579-8871-4c49-9600-dc386833c2fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/390082803\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x10fb933a0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: NumPy\n",
    "VimeoVideo('390082803', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "\n",
    "The transcript for the above overview video **[is located here](https://repo.exeterlms.com/documents/V2/DataScience/Video-Transcripts/DSO109L09overview.zip)**.\n",
    "\n",
    "# Introduction\n",
    "\n",
    "Another package that data scientists frequently use in Python is NumPy, which includes functions for mathematics basics and the data types of arrays and matrices.  In this lesson, you will learn how to: \n",
    "\n",
    "* Create NumPy arrays and matrices\n",
    "* Run aggregate functions on arrays and matrices\n",
    "* Index on arrays and matrices\n",
    "* Perform arithmetic upon arrays and matrices\n",
    "* Generate data with NumPy\n",
    "* Manipulate the shape of matrices\n",
    "\n",
    "This lesson will culminate in a hands-on in which you practice your array and matrix skills with arrays and matrices of your own making.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may want to watch this <a href=\"https://vimeo.com/460783739\"> recorded live workshop </a> that goes over the material in this lesson. </p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Numpy Arrays<a class=\"anchor\" id=\"DS109L9_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# Numpy Arrays\n",
    "\n",
    "The second most often used data science package in Python is *Numpy*, a combination of \"numbers\" and \"Python.\" NumPy was the original mathematical Python package, and it is the backbone of many of the machine learning packages, so it is very important to have a good understanding of NumPy. To work with NumPy, you will need to import the package into your Jupyter Notebook, using this line of code:\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "```\n",
    "\n",
    "This is telling Python that you are importing the `numpy` package and you want to nickname it `np` to shorten things up.  `np` is the standard abbreviation for NumPy, though you could technically abbreviate it anything you'd like. \n",
    "\n",
    "---\n",
    "\n",
    "## Arrays\n",
    "\n",
    "While `pandas` deals with data frames, the data format that NumPy makes use of is called an array. What is an array? Simply a list of numbers that has been turned into its own variable so that you can use it as a chunk (all the data together) rather than one at a time (each number in the list). How about you make your first NumPy array?\n",
    "\n",
    "```python\n",
    "my_first_array = np.array([7,2,1])\n",
    "```\n",
    "\n",
    "You are giving this array the name `my_first_array`, and it contains the numbers 7, 2, and 1.  The function to do this is `np.array()`. \n",
    "\n",
    "Now, if you call that array, by simply typing in it's name again, you will get this output:\n",
    "\n",
    "```text\n",
    "array([7, 2, 1])\n",
    "```\n",
    "\n",
    "It tells you the format of the data (an array), and then gives you information about what data is in that array.  \n",
    "\n",
    "You can also print arrays - try it:\n",
    "\n",
    "```python\n",
    "print(my_first_array)\n",
    "```\n",
    "\n",
    "When printed, the data architecture (array) is left off, and you only get the data in the array, like this:\n",
    "\n",
    "```text\n",
    "[7 2 1]\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7a016ca1-1b05-4963-abcd-0adbbac32b9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bf88363f-55a5-4a84-a4b7-c99d04e7e7d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "65ebe3e8071749e78d2df4d438f52b21",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. np', 0), ('B. pd', 1),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b9010d407e5b44e4a347cbf81a9ba02c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. dataframe', 0), ('B. d…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P2Q1, L9P2Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Aggregate Functions on Arrays<a class=\"anchor\" id=\"DS109L9_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# Aggregate Functions on Arrays\n",
    "\n",
    "You can run aggregate functions on arrays - things like getting measures of central tendency, dispersion, or sums.  Try it out! \n",
    "\n",
    "---\n",
    "\n",
    "## Max\n",
    "\n",
    "To find the max value in your array, simply use the function `.max()`: \n",
    "\n",
    "```python\n",
    "my_first_array.max()\n",
    "```\n",
    "\n",
    "The result is `7`!\n",
    "\n",
    "---\n",
    "\n",
    "## Min\n",
    "\n",
    "To find the minimum value in your array, you can use the function `.min()`, like this:\n",
    "\n",
    "```python\n",
    "my_first_array.min()\n",
    "```\n",
    "\n",
    "The result is `1`!\n",
    "\n",
    "---\n",
    "\n",
    "## Mean\n",
    "\n",
    "You can also find the mean, using the function `.mean()` on your array: \n",
    "\n",
    "```python\n",
    "my_first_array.mean()\n",
    "```\n",
    "\n",
    "And here is the output:\n",
    "\n",
    "```text\n",
    "3.3333333333333335\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Standard Deviation\n",
    "\n",
    "The standard deviation is another aggregate function option.  Try out `.std()`:\n",
    "\n",
    "```python\n",
    "my_first_array.std()\n",
    "```\n",
    "\n",
    "The result is this:\n",
    "\n",
    "```text\n",
    "2.6246692913372702\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Sum\n",
    "\n",
    "The last option for performing aggregate functions on arrays is `.sum()`, which totals everything for you:\n",
    "\n",
    "```python\n",
    "my_first_array.sum()\n",
    "```\n",
    "\n",
    "The result is `10`. \n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Want to know more about array aggregate functions? Check out <a href=\"https://jakevdp.github.io/PythonDataScienceHandbook/02.04-computation-on-arrays-aggregates.html\"> this reference to ALL aggregate functions, their companions that will work even with missing data, and even examples of how aggregate functions can be used. </a></p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "db3c84b0-d217-425e-8e55-1131cfd335ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7889853472a14dff858dcc7c3e091177",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which of the following is NOT an aggregate funct…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P3Q1)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Data Generation with NumPy<a class=\"anchor\" id=\"DS109L9_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Data Generation with NumPy\n",
    "\n",
    "There are many different ways to generate data with NumPy.  \n",
    "\n",
    "---\n",
    "\n",
    "## Generating Random Numbers\n",
    "\n",
    "Perhaps the most useful way to generate data is to generate random numbers for simulation. You can use the function `random.random()` to generate an array filled with random numbers, and the argument that goes in the parentheses is the number of random numbers you want to generate in your array.  It's the length of your array. Here's an example:\n",
    "\n",
    "```python\n",
    "RandomNumbers = np.random.random(1)\n",
    "```\n",
    "\n",
    "The code above generates an array named `RandomNumbers` that is only one digit long.  Take a look when you call it:\n",
    "\n",
    "```text\n",
    "array([0.20739175])\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Remember that since this generates a random number, there's a good chance that your number won't be the same one that you see up above. Don't worry if you get a different result.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Generating Specific Numbers\n",
    "\n",
    "You also have the option to fill your array with a particular number.  The function `ones()` generates an array of the number one.  The function `zeros()` generates an array filled with the number zero. Check 'em out! \n",
    "\n",
    "---\n",
    "\n",
    "### Generating Ones\n",
    "\n",
    "```python\n",
    "allOnes = np.ones(7)\n",
    "```\n",
    "\n",
    "The code above generates an array with a length of seven that are all ones, in an array named `allOnes`:\n",
    "\n",
    "```text\n",
    "array([1., 1., 1., 1., 1., 1., 1.])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Generating Zeros \n",
    "\n",
    "And the code below will generate an array named `allZeros` with a length of two, in an array with a length of two:\n",
    "\n",
    "```python\n",
    "allZeros = np.zeros(2)\n",
    "```\n",
    "\n",
    "The result:\n",
    "\n",
    "```text\n",
    "array([0., 0.])\n",
    "```\n",
    "\n",
    "Being able to do this can be quite useful, because you will often use the numbers one and zero as placeholders for dichotomous, or two category, variables.  Things like \"yes/no\", \"men/women\", \"child/adult\" etc. may all be represented as zeros and ones.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f85d176a-c67c-4d77-8a6e-f3b2767fd495",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c68296e0450b483cb24a3838a0ac5f70",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which of the following functions will generate a…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P4Q1)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Arithmetic with Arrays<a class=\"anchor\" id=\"DS109L9_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "# Arithmetic with Arrays\n",
    "\n",
    "You can also do arithmetic with arrays, with the four basic math operations. This arithmetic can be array to array, or can be a single number applied to every number in the array.  Numpy automatically iterates things for you, so you don't have to worry about looping anything in your array.  That speeds things up considerably!\n",
    "\n",
    "---\n",
    "\n",
    "## Arithmetic with Two Arrays\n",
    "\n",
    "You'll start with doing arithmetic on two arrays.  This works, as long as your arrays aren't the same length. Start by creating a second array, also three in length:\n",
    "\n",
    "```python\n",
    "my_second_array = np.array([1,2,7])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Adding\n",
    "\n",
    "Then you can add them together, easily by just using the plus sign:\n",
    "\n",
    "```python\n",
    "my_first_array + my_second_array\n",
    "```\n",
    "\n",
    "Here is the result - a third array, where every number is the sum of the first and the second array:\n",
    "\n",
    "```text\n",
    "array([8, 4, 8])\n",
    "```\n",
    "\n",
    "If you're feeling doubtful, try it longhand yourself once.  `my_first_array` contains the values 7, 2, and 1.  `my_second_array` contains the values 1, 2, and 7.  So, 7 (from the first array) plus 1 (from the second array) is 8.  Similarly, 2 from the first array and 2 from the second array make 4.  Lastly, 1 from the first array and 7 from the second array added together make 8 once more.\n",
    "\n",
    "Just like anything else, you can assign your addition to a variable, like this:\n",
    "\n",
    "```python\n",
    "ArraySummed = my_first_array + my_second_array\n",
    "```\n",
    "\n",
    "Then call it - `ArraySummed` - to get your result.\n",
    "\n",
    "---\n",
    "\n",
    "### Subtracting\n",
    "\n",
    "The same principle holds true for doing subtraction with two arrays. This will subtract the second array from the first:\n",
    "\n",
    "```python\n",
    "ArraySubtracted = my_first_array - my_second_array\n",
    "```\n",
    "\n",
    "And here is the result once you call `ArraySubtracted`:\n",
    "\n",
    "```text\n",
    "array([ 6,  0, -6])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Multiplying\n",
    "\n",
    "Multiplication is also possible with two arrays: \n",
    "\n",
    "```python\n",
    "ArrayMultiplied = my_first_array * my_second_array\n",
    "```\n",
    "\n",
    "The resultant product shows itself once you call `ArrayMultiplied`:\n",
    "\n",
    "```text\n",
    "array([7, 4, 7])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Dividing \n",
    "\n",
    "Lastly, you can also divide arrays. The code below will do so:\n",
    "\n",
    "```python\n",
    "ArrayDivided = my_first_array / my_second_array\n",
    "```\n",
    "\n",
    "And here is the result:\n",
    "\n",
    "```text\n",
    "ArrayDivided\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Arithmetic on an Array\n",
    "\n",
    "It is also possible to do arithmetic on just one array.  Say you'd like to see your array with every variable multiplied by four? It can be done without a lot of fuss.  Again, no need to loop - just use your operand on the array name!\n",
    "\n",
    "---\n",
    "\n",
    "### Multiplying\n",
    "\n",
    "How about multiplying `my_first_array` by four?\n",
    "\n",
    "```python\n",
    "TimesFour = my_first_array * 4\n",
    "```\n",
    "\n",
    "Here is the product when `TimesFour` is called:\n",
    "\n",
    "```text\n",
    "array([28,  8,  4])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Dividing\n",
    "\n",
    "You can also divide every number in the array by four:\n",
    "\n",
    "```python\n",
    "DividedFour = my_first_array / 4\n",
    "```\n",
    "\n",
    "And the result:\n",
    "\n",
    "```text\n",
    "array([1.75, 0.5 , 0.25])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Adding\n",
    "\n",
    "It's relatively to add four to every number as well:\n",
    "\n",
    "```python\n",
    "PlusFour = my_first_array + 4\n",
    "```\n",
    "\n",
    "With this result:\n",
    "\n",
    "```text\n",
    "array([11,  6,  5])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### Subtracting\n",
    "\n",
    "Or to subtract four from everything in your array:\n",
    "\n",
    "```python\n",
    "MinusFour = my_first_array - 4\n",
    "```\n",
    "\n",
    "Here's what you get when you call `MinusFour`:\n",
    "\n",
    "```text\n",
    "array([ 3, -2, -3])\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c857ba53-6b55-4163-acdd-0eb5e0d1bdc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c541561b096e49cf865c28d98b12a427",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. True or False: You can use regular arithmetic op…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "16f513999d9e4da994bf59e88850c59b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Is it possible to add the same number to every n…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P5Q1, L9P5Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Indexing on Arrays<a class=\"anchor\" id=\"DS109L9_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "Indexing on Arrays\n",
    "\n",
    "You can access certain elements in an array by using indexing.The thing to remember about indexing is that Python is zero index. This means that you start counting the number positions from zero and not from one.  In brackets you will place the position numbers you want.  If you just want a single number, then you can call the array and then place the number of the position. \n",
    "\n",
    "For instance, for `my_first_array`, shown below:\n",
    "\n",
    "```text\n",
    "array([7, 2, 1])\n",
    "```\n",
    "\n",
    "You can get the first place by calling `[0]` at the end of the name, like this:\n",
    "\n",
    "```python\n",
    "my_first_array[0]\n",
    "```\n",
    "\n",
    "Which will yield the number `7` in return.\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing Multiple Numbers in an Array\n",
    "\n",
    "If you want to access multiple numbers in an array, then you can use two position numbers, separated by a colon.  So the format will read `[position a #: position b #]`. You will receive everything inclusive of those numbers.  For instance, if you wanted to get everything in the current array, you could try something like this:\n",
    "\n",
    "```python\n",
    "my_first_array[0:3]\n",
    "```\n",
    "\n",
    "Which will yield this:\n",
    "\n",
    "```text\n",
    "array([7, 2, 1])\n",
    "```\n",
    "\n",
    "You can also leave a position number missing instead making use of just the colon.  Just a colon without a position means \"everything.\" For instance, if you wanted all the numbers after the second position, you could use this notation:\n",
    "\n",
    "```python\n",
    "my_first_array[1:]\n",
    "```\n",
    "\n",
    "With the resulting information retrieved:\n",
    "\n",
    "```text\n",
    "array([2, 1])\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d3eae965-abb4-4b76-a5db-5043d7707532",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a01aab53bd447f49b2461d33d3a79e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. True or False: Python is one-index.\\n', 'output_…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "28d84ddffc834805a9cd0fdbb965dba6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. To access the third element in an array, what nu…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c02685f2c4840509d95ce7364e5a747",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. To access every element in an array before the f…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P6Q1, L9P6Q2, L9P6Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Creating Matrices with Arrays<a class=\"anchor\" id=\"DS109L9_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "# Creating Matrices with Arrays\n",
    "\n",
    "Matrices are the backbone for a lot of the more complex statistical analyses and machine learning algorithms which often make use of matrix algebra at their heart. While you won't need to know how to do that math (hoorah!), you will need to know how to create matrices with arrays. In the simplest terms, making a matrix out of arrays just involves placing array lists together, separated by a comma, like this:\n",
    "\n",
    "```python\n",
    "my_first_matrix = np.array([[8,9], [5,4]])\n",
    "```\n",
    "\n",
    "When you call `my_first_matrix`, it should now look like this:\n",
    "\n",
    "```text\n",
    "array([[8, 9],\n",
    "       [5, 4]])\n",
    "```\n",
    "\n",
    "Having the arrays on multiple lines is a visual way to double check that you do in fact have a matrix instead of an array.\n",
    "\n",
    "---\n",
    "\n",
    "## Matrix of All Ones\n",
    "\n",
    "You can use the same data generation effects on matrices that you can on arrays. For instance, you can create a matrix of all ones. The below code will make a matrix filled with ones that has seven rows and two columns:\n",
    "\n",
    "```python\n",
    "AllOnesMatrix = np.ones((7,2))\n",
    "```\n",
    "\n",
    "And here's what that will look like when you call `AllOnesMatrix`:\n",
    "\n",
    "```text\n",
    "array([[1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.]])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Matrix of All Zeros\n",
    "\n",
    "You can do the exact same thing, but with zeros if you'd like: \n",
    "\n",
    "```python\n",
    "AllZerosMatrix = np.zeros((7,2))\n",
    "```\n",
    "\n",
    "Again, the above text creates a matrix of 7 rows and 2 columns:\n",
    "\n",
    "```text\n",
    "array([[0., 0.],\n",
    "       [0., 0.],\n",
    "       [0., 0.],\n",
    "       [0., 0.],\n",
    "       [0., 0.],\n",
    "       [0., 0.],\n",
    "       [0., 0.]])\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Random Matrix\n",
    "\n",
    "Lastly, you can also make a random matrix, using the `np.random.random` function:\n",
    "\n",
    "```python\n",
    "RandomMatrix = np.random.random((7,2))\n",
    "```\n",
    "\n",
    "And here is an example of what that random matrix might look like. Take note that because it is random, your numbers will most likely be different!\n",
    "\n",
    "```text\n",
    "array([[0.06528685, 0.9767537 ],\n",
    "       [0.61912473, 0.02705559],\n",
    "       [0.78753624, 0.04548327],\n",
    "       [0.53897846, 0.11152877],\n",
    "       [0.86995997, 0.81987622],\n",
    "       [0.63686912, 0.4906349 ],\n",
    "       [0.41159298, 0.29468443]])\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e99c6112-1d02-4c92-8cf0-9a4972659181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e87338ccb8a64d66ae027b3d5095d87f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. What does this code do?: np.ones((9,3))\\n', 'out…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P7Q1)    \n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Matrix Arithmetic and Aggregation<a class=\"anchor\" id=\"DS109L9_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "# Matrix Arithmetic and Aggregation\n",
    "\n",
    "Yes, you can do arithmetic and aggregate functions on matrices as well! Commence the partying!\n",
    "\n",
    "---\n",
    "\n",
    "## Arithmetic\n",
    "\n",
    "To perform basic arithmetic on matrices, simply call their names and separate by the arithmetic operator of choice. The below code will add the randomly generated matrix (`RandomMatrix`) and the `AllOnesMatrix` together:\n",
    "\n",
    "```python\n",
    "RandomMatrix + AllOnesMatrix\n",
    "```\n",
    "\n",
    "And here is your resultant new matrix:\n",
    "\n",
    "```text\n",
    "array([[1.06528685, 1.9767537 ],\n",
    "       [1.61912473, 1.02705559],\n",
    "       [1.78753624, 1.04548327],\n",
    "       [1.53897846, 1.11152877],\n",
    "       [1.86995997, 1.81987622],\n",
    "       [1.63686912, 1.4906349 ],\n",
    "       [1.41159298, 1.29468443]])\n",
    "```\n",
    "\n",
    "You can also subtract, divide, and multiply matrices this way.\n",
    "\n",
    "---\n",
    "\n",
    "## Aggregation\n",
    "\n",
    "You can also make use of the aggregation functions you learned for arrays - simply call them on a matrix instead.  For instance, to get the minimum value for `my_first_matrix`, use the `.min()` function:\n",
    "\n",
    "```python\n",
    "my_first_matrix.min()\n",
    "```\n",
    "\n",
    "And you receive the value of `4`.  You can make use of the others as well:\n",
    "\n",
    "```python\n",
    "my_first_matrix.max()\n",
    "my_first_matrix.sum()\n",
    "my_first_matrix.mean()\n",
    "my_first_matrix.std()\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "91b6cb9f-20c7-4560-b63b-e3467134cc97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0047629c78a247d78e15673da0461499",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. True or False: You can use aggregate functions o…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P8Q1)    \n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Matrix Indexing<a class=\"anchor\" id=\"DS109L9_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "try:\n",
    "    display(L9P8Q1)    \n",
    "except:\n",
    "    pass# Matrix Indexing\n",
    "\n",
    "You can access elements in a matrix through indexing. Simply call the matrix name, then use square brackets to indicate the row and column in question.  The first number in square brackets will be the row, and the second number in square brackets after the comma will be the column where your element is located.  For instance, for `my_first_matrix`, which has the following values:\n",
    "\n",
    "```text\n",
    "array([[8, 9],\n",
    "       [5, 4]])\n",
    "```\n",
    "\n",
    "If you want to access the `9`, then you would want to use the following code:\n",
    "\n",
    "```python\n",
    "my_first_matrix[0,1]\n",
    "```\n",
    "\n",
    "The 0 stands for the first row (remember that Python is zero-index!) and the 1 stands for the second column (where the 9 is located). If you run the code, you should receive back the number `9`.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff6d90c6-cf59-489a-ab4a-aa4dd196d5c4",
   "metadata": {},
   "source": [
    "```python\n",
    "array([[2, 5],\n",
    "       [3, 7]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ef191f7b-e32c-44c4-9994-386432a501d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f2e78f230bd949ada38dc4d1473c8041",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which code portion will access the three in this…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P9Q1)    \n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Aggregating Matrix Values Across Columns and Rows<a class=\"anchor\" id=\"DS109L9_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49fd2fea-212d-4a9f-a4f8-64dcdcd0a5f7",
   "metadata": {},
   "source": [
    "# Aggregating Matrix Values Across Columns and Rows\n",
    "\n",
    "Since a matrix now takes the form of columns and rows, you can also do aggregate functions along the columns and rows.\n",
    "\n",
    "Remember `my_first_matrix`? \n",
    "\n",
    "```text\n",
    "array([[8, 9],\n",
    "       [5, 4]])\n",
    "```\n",
    "\n",
    "How about you find the largest number in the columns?\n",
    "\n",
    "```python\n",
    "my_first_matrix.max(axis=0)\n",
    "```\n",
    "\n",
    "You will use the aggregate function you want (in this case, `.max()`), but then go one step further, and specify the argument `axis=` to ensure that you aren't doing it for the whole matrix, but rather for either columns or rows.  `axis=0` is for columns, and `axis=1` is for rows.\n",
    "\n",
    "Here is the result of the above code:\n",
    "\n",
    "```text\n",
    "array([8, 9])\n",
    "```\n",
    "\n",
    "You'll note that it spits back two numbers, not just one.  That is because there are two columns in your matrix, and it gives the largest number for each column.  In the first column, eight is the biggest number (8 > 5), and in the second column, nine is the largest number (9 > 4).  You can similarly do this for the rows, instead of the columns:\n",
    "\n",
    "```python\n",
    "my_first_matrix.max(axis=1)\n",
    "```\n",
    "\n",
    "Just by changing the `0` to a `1` after `axis=`, you now get different results, finding the largest number in a row:\n",
    "\n",
    "```text\n",
    "array([9, 5])\n",
    "```\n",
    "\n",
    "Again, you receive two numbers.  The first is for the largest number in the first row (9), and the second is for the largest number in the second row (5).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a33bbbd4-b1ff-48d3-a6ea-3e8eb78e2e38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0487cd9ef5614a44a18703bb76af03fd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. To perform an aggregate function on a row, which…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d6c68d514e1c4c8493d6000c24cf70da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. True or False: You an use the same aggregate fun…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P10Q1, L9P10Q2)    \n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91efdc26-e4f2-432e-8153-8bdd857fae16",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Manipulating Matrices<a class=\"anchor\" id=\"DS109L9_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "283da7e6-5578-4046-b78e-2a630a25332b",
   "metadata": {},
   "source": [
    "# Manipulating Matrices\n",
    "\n",
    "The last thing you'll learn to do with matrices is to manipulate them - basically, change their shape.\n",
    "\n",
    "---\n",
    "\n",
    "## Transposing \n",
    "\n",
    "First, you'll learn to transpose matrices. What does *transpose* mean? It means to flip your data.  It's easier to get a visual on it.  Here is the original ```AllOnesMatrix```:\n",
    "\n",
    "```text\n",
    "array([[1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.],\n",
    "       [1., 1.]])\n",
    "```\n",
    "\n",
    "And once it has been transposed, it will look like this:\n",
    "\n",
    "```text\n",
    "array([[1., 1., 1., 1., 1., 1., 1.],\n",
    "       [1., 1., 1., 1., 1., 1., 1.]])\n",
    "```\n",
    "\n",
    "The code for doing this is one simple little letter - `.T`. So the code to flip the `AllOnesMatrix` looks like this:\n",
    "\n",
    "```python\n",
    "AllOnesMatrix.T\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Reshaping\n",
    "\n",
    "You can also reshape your matrix. What if you want to take that matrix and put it in one column of 14 rows? That can be done with the `reshape()` function, and the arguments you'll use inside the parentheses is the number of rows, separated by a comma and followed by the number of columns.  Here's what the code to reshape `AllOnesMatrix` to a single column with 14 rows looks like:\n",
    "\n",
    "```python\n",
    "AllOnesMatrix.reshape(14,1)\n",
    "```\n",
    "\n",
    "And here's the resulting format:\n",
    "\n",
    "```text\n",
    "array([[1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.],\n",
    "       [1.]])\n",
    "```\n",
    "\n",
    "You can reshape any number of different ways, but remember that the number has to be divisible by the total number of elements.  So, trying this:\n",
    "\n",
    "```python\n",
    "AllOnesMatrix.reshape(3,5)\n",
    "```\n",
    "\n",
    "Won't work, and you'll get this error:\n",
    "\n",
    "```text\n",
    "---------------------------------------------------------------------------\n",
    "ValueError                                Traceback (most recent call last)\n",
    "<ipython-input-68-f20be8614c6b> in <module>()\n",
    "----> 1 AllOnesMatrix.reshape(3,5)\n",
    "\n",
    "ValueError: cannot reshape array of size 14 into shape (3,5)\n",
    "```\n",
    "\n",
    "That is because 3 times 5 is 15, not 14...and so Python doesn't know what to do with that extra number.  It can't be easily placed into the new matrix format. As you enter into machine learning, which is based on arrays and matrices, you may encounter this error sometimes - so it's good to be armed with knowledge of what it's all about!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4a44d51b-56ef-42b5-a525-e3a3f1fc7c21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea6fb4e7db7249479eb7bf9bc3a984f2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. To flip your data, which function should be used…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "49dcbac88b374dd7ba8375f35fb01869",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. True or False: You can reshape data any way you …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L9P11Q1, L9P11Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe714043-ccf1-4f50-b4e8-ce6b50e41490",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Key Terms <a class=\"anchor\" id=\"DS109L9_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a48c4359-574a-43cc-b39d-db659d3bbda1",
   "metadata": {},
   "source": [
    "# Key Terms \n",
    "\n",
    "Below is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>NumPy</td>\n",
    "        <td>Python package designed for mathematics, arrays, and matrices.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Array</td>\n",
    "        <td>List of numbers.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Zero Index</td>\n",
    "        <td>Start counting positions from zero.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Matrix</td>\n",
    "        <td>Multiple arrays together; made up of columns and rows.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Transpose</td>\n",
    "        <td>Go from a horizontal to vertical shape of your data.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "---\n",
    "\n",
    "## Key NumPy Code\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>np.array()</td>\n",
    "        <td>Generates an array.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.max()</td>\n",
    "        <td>Finds the maximum value.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.min()</td>\n",
    "        <td>Finds the smallest value.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.mean()</td>\n",
    "        <td>Finds the mean.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.std()</td>\n",
    "        <td>Finds the standard deviation.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.sum()</td>\n",
    "        <td>Adds everything together for the total.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>np.random.random()</td>\n",
    "        <td>Generates random numbers between zero and one.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>np.ones()</td>\n",
    "        <td>Generates ones.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.zeros()</td>\n",
    "        <td>Generates zeros.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>axis=0</td>\n",
    "        <td>Argument for an aggregate function that specifies to perform the action on columns.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>axis=1</td>\n",
    "        <td>Argument for an aggregate function that specifies to perform the action on rows.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.T()</td>\n",
    "        <td>Transposes a matrix.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.reshape()</td>\n",
    "        <td>Changes the shape of a matrix.</td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08a81e60-0ed8-4b19-bc30-4d8797ca9a9d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 13 - Lesson 9 Hands-On<a class=\"anchor\" id=\"DS109L9_page_13\"></a>\n",
    "\n",
    "[Back to Top](#DS109L9_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3edbf6fb-a4d4-4970-a3b4-53a9f806ebe5",
   "metadata": {},
   "source": [
    "\n",
    "For your Lesson 9 Hands-On, you will be practicing your new skills with arrays and matrices! This Hands-On **will** be graded, so be sure you complete all requirements.\n",
    "\n",
    "Please complete the following tasks in a Jupyter Notebook file, using the `numpy` package: \n",
    "\n",
    "* Create a five element array using your favorite numbers named `myFavorites`.\n",
    "* Perform each of the five aggregate functions on your array.\n",
    "* Create a five element array containing only ones named `OneArrayToRuleThemAll`.\n",
    "* Add `myFavorites` and `OneArrayToRuleThemAll`.\n",
    "* Multiply every element in `myFavorites` by two.\n",
    "* Call the third element in `myFavorites` using indexing.\n",
    "* Create a four element, two-by-two matrix of numbers named `TheMatrixHasYou`. \n",
    "* Access the upper left element in `TheMatrixHasYou` using indexing.\n",
    "* Find the largest number in each row for `TheMatrixHasYou`.\n",
    "* Reshape `TheMatrixHasYou` into a matrix with one row and four columns.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}