Data Scientist With Python/Introduction to NumPy/Module 2 - Selecting and Updating Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d64c3aa0",
   "metadata": {},
   "source": [
    "# Selecting and Updating Data\n",
    "\n",
    "## Slicing and indexing trees\n",
    "Imagine you are a researcher working with data from New York City's tree census. Each row of the tree_census 2D array lists information for a different tree: the tree ID, block ID, trunk diameter, and stump diameter in that order. Living trees do not have stump diameters, which explains why there are so many zeros in that column. Column order is important because NumPy does not have column names! The first and last three rows of tree_census are shown below.\n",
    "```\n",
    "array([[     3, 501451,     24,      0],\n",
    "       [     4, 501451,     20,      0],\n",
    "       [     7, 501911,      3,      0],\n",
    "       ...,\n",
    "       [  1198, 227387,     11,      0],\n",
    "       [  1199, 227387,     11,      0],\n",
    "       [  1210, 227386,      6,      0]])\n",
    "```\n",
    "\n",
    "In this exercise, you'll be working specifically with the second column, representing block IDs: your research requires you to select specific city blocks for further analysis using NumPy slicing and indexing. numpy is loaded as np, and the `tree_census` 2D array is available.\n",
    "\n",
    "* Select all rows of data from the second column, representing block IDs; save the resulting array as `block_ids`.\n",
    "* Print the first five block IDs from block_ids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4d1579ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "tree_census = np.load('datasets/tree_census.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6dafa943",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[501451 501451 501911 501911 501911]\n"
     ]
    }
   ],
   "source": [
    "# Select all rows of block ID data from the second column\n",
    "block_ids = tree_census[:, 1]\n",
    "\n",
    "# Print the first five block_ids\n",
    "print(block_ids[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10668d58",
   "metadata": {},
   "source": [
    "* Select the tenth block ID from `block_ids`, saving the result as `tenth_block_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b0046963",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "501911\n"
     ]
    }
   ],
   "source": [
    "# Select the tenth block ID from block_ids\n",
    "tenth_block_id = block_ids[9]\n",
    "print(tenth_block_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96e05bb7",
   "metadata": {},
   "source": [
    "* Select five consecutive block IDs from `block_ids`, starting with the tenth ID, and save as `block_id_slice`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b832630b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[501911 501911 501911 501909 501909]\n"
     ]
    }
   ],
   "source": [
    "# Select five block IDs from block_ids starting with the tenth ID\n",
    "block_id_slice = block_ids[9:14]\n",
    "print(block_id_slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "309f1e24",
   "metadata": {},
   "source": [
    "No mental block for you! Well done. Notice how the slicing and indexing syntax for a 1D array is exactly as it would be if you were working with a Python list!\n",
    "\n",
    "## Stepping into 2D\n",
    "Now assume that your research requires you to take an admittedly unrepresentative sample of trunk diameters, which are located in the third column of `tree_census`. Getting just a selection of trunk diameters can be done with NumPy's slicing and stepping functionality.\n",
    "\n",
    "* Create an array called `hundred_diameters` which contains the first 100 trunk diameters in `tree_census`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "82b95320",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24 20  3  3  4  4  4  4  4  3  3  4  2  2  3  4  4  4  0 14  3  4  7  8\n",
      "  7  8  7  5  6  5  5 17  0 19 21 18  4  5  3  4  3  4 13 13 13  5  4  4\n",
      "  4 11  5  4  5  8 51  7  4 15  3  8  6  6  3  4  3  2  3  3  6  5  5  5\n",
      "  5  9  4  4  7  7  6  5  4  4  5  5  5  7  3  5  3  3  6  6  8  7  4  5\n",
      "  4  4  4  4]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of the first 100 trunk diameters from tree_census\n",
    "hundred_diameters = tree_census[:100, 2]\n",
    "print(hundred_diameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df743bc5",
   "metadata": {},
   "source": [
    "* Create an array,`every_other_diameter`, which contains only every other trunk diameter for trees with row indices from 50 to 100, inclusive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e98ee3eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  5 51  4  3  6  3  3  3  6  5  5  4  7  6  4  5  5  3  3  6  8  4  4\n",
      "  4  6]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of trunk diameters with even row indices from 50 to 100 inclusive\n",
    "every_other_diameter = tree_census[50:101:2, 2]\n",
    "print(every_other_diameter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26fef07e",
   "metadata": {},
   "source": [
    "Look at that slicing! Great work. Notice how you only sliced the rows. In terms of columns, you just indicated that you were working with the column at index two: trunk diameter.\n",
    "\n",
    "## Sorting trees\n",
    "Sometimes it's easiest to understand data when it is sorted according to the value you are most interested in. Your new research task is to create an array containing the trunk diameters in the New York City tree census, sorted in order from smallest to largest.\n",
    "\n",
    "* Create an array called `sorted_trunk_diameters` which selects only the trunk diameter column from `tree_census` and sorts it so that the smallest trunk diameters are at the top of the array and the largest at the bottom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7b9e8784",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  2  2  2  2  2  2\n",
      "  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
      "  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2\n",
      "  2  2  2  2  2  2  2  2  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3\n",
      "  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3\n",
      "  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3\n",
      "  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  4  4  4  4\n",
      "  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
      "  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
      "  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
      "  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4  4\n",
      "  4  4  4  4  4  4  4  4  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5\n",
      "  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5\n",
      "  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5\n",
      "  5  5  5  5  5  5  5  5  5  5  6  6  6  6  6  6  6  6  6  6  6  6  6  6\n",
      "  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6\n",
      "  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  7  7  7  7  7  7  7\n",
      "  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7\n",
      "  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  8  8  8  8\n",
      "  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8  8\n",
      "  8  8  8  8  8  8  8  8  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9\n",
      "  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9  9\n",
      "  9 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10\n",
      " 10 10 10 10 10 10 10 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11\n",
      " 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11\n",
      " 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12\n",
      " 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12\n",
      " 12 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 13 13\n",
      " 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 14 14\n",
      " 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14\n",
      " 14 14 14 14 14 14 14 14 14 14 15 15 15 15 15 15 15 15 15 15 15 15 15 15\n",
      " 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 16 16 16\n",
      " 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17\n",
      " 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 18 18 18\n",
      " 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18\n",
      " 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19\n",
      " 19 19 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20\n",
      " 20 20 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 22 22 22\n",
      " 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 23 23 23 23 23 23 23 23\n",
      " 23 24 24 24 24 24 24 24 24 25 25 25 25 25 25 25 25 25 25 25 26 26 26 26\n",
      " 26 26 27 27 27 28 28 28 30 30 33 34 38 39 44 51]\n"
     ]
    }
   ],
   "source": [
    "# Extract trunk diameters information and sort from smallest to largest\n",
    "sorted_trunk_diameters = np.sort(tree_census[:, 2])\n",
    "print(sorted_trunk_diameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2adb3f",
   "metadata": {},
   "source": [
    "Way to get to the root of that tree problem! Notice that the np.sort() function doesn't include an option to sort ascending or descending.\n",
    "\n",
    "## Filtering with masks\n",
    "In the last lesson, you sorted trees from smallest to largest. Now, you'll use fancy indexing to return the row of data representing the largest tree in tree_census. You'll also examine other trees located on the same block as the largest tree: are they also large?\n",
    "\n",
    "* Using Boolean indexing, create an array, `largest_tree_data`, which contains the row of data on the largest tree in `tree_census` corresponding to the tree with a diameter of 51."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e1d9ba57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    61 501882     51      0]]\n"
     ]
    }
   ],
   "source": [
    "# Create an array which contains row data on the largest tree in tree_census\n",
    "largest_tree_data = tree_census[tree_census[:, 2] == 51]\n",
    "print(largest_tree_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09033665",
   "metadata": {},
   "source": [
    "* Slice `largest_tree_data` to retrieve only the block id of the block the largest tree is located on; save this block id as `largest_tree_block_id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fba2bd3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[501882]\n"
     ]
    }
   ],
   "source": [
    "# Slice largest_tree_data to get only the block id\n",
    "largest_tree_block_id = largest_tree_data[:, 1]\n",
    "print(largest_tree_block_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24ebf257",
   "metadata": {},
   "source": [
    "* Using fancy indexing, create an array called `trees_on_largest_tree_block` which contains data on all trees with the same block ID as the largest tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7ed9ba9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[    60 501882      8      0]\n",
      " [    61 501882     51      0]\n",
      " [    62 501882      7      0]\n",
      " [    63 501882      4      0]\n",
      " [    64 501882     15      0]\n",
      " [    65 501882      3      0]\n",
      " [    66 501882      8      0]\n",
      " [    67 501882      6      0]\n",
      " [    68 501882      6      0]\n",
      " [    69 501882      3      0]]\n"
     ]
    }
   ],
   "source": [
    "# Create an array which contains row data on all trees with largest_tree_block_id\n",
    "trees_on_largest_tree_block = tree_census[tree_census[:, 1] == largest_tree_block_id]\n",
    "print(trees_on_largest_tree_block)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e7a73db",
   "metadata": {},
   "source": [
    "So fancy! Great job. Based on your work, it looks like the largest tree on the tree_census is the only really big tree on its block.\n",
    "\n",
    "## Fancy indexing vs. np.where()\n",
    "You and your tree research team are double-checking collection data by visiting a few trees in person to confirm their measurements. You've been assigned to check the data for trees on block 313879, and you'd like to make a small array of just the tree data that relates to your work.\n",
    "\n",
    "* Using fancy indexing, create an array called `block_313879` which only contains data for trees with a block ID of 313879."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "51e56b39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1115 313879      3      0]\n",
      " [  1116 313879     17      0]]\n"
     ]
    }
   ],
   "source": [
    "# Create the block_313879 array containing trees on block 313879\n",
    "block_313879 = tree_census[tree_census[:, 1] == 313879]\n",
    "print(block_313879)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e5274b",
   "metadata": {},
   "source": [
    "* Using `np.where()`, create an array of `row_indices` for trees with a block ID of 313879.\n",
    "* Using `row_indices`, create `block_313879`, which contains data for trees on block 313879."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f2feea0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1115 313879      3      0]\n",
      " [  1116 313879     17      0]]\n"
     ]
    }
   ],
   "source": [
    "# Create an array of row_indices for trees on block 313879\n",
    "row_indices = np.where(tree_census[:, 1] == 313879)\n",
    "\n",
    "# Create an array which only contains data for trees on block 313879\n",
    "block_313879 = tree_census[row_indices]\n",
    "print(block_313879)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b87fa13a",
   "metadata": {},
   "source": [
    "Where'd you get those np.where() skills!? Great filtering. You probably noticed that fancy indexing is more elegant than np.where() in this example. That's because we haven't really tapped into the power of np.where() yet. It's most useful for finding indices and then using that location information to update an array. We'll see an example of this in the next exercise, and also in the next lesson, where one of the functions takes indices as arguments!\n",
    "\n",
    "## Creating arrays from conditions\n",
    "Currently, the stump diameter and trunk diameter values in `tree_census` are in two different columns. Living trees have a stump diameter of zero while stumps have a trunk diameter of zero. If you'd like to include both living trees and stumps in certain research calculations, it might be useful to have their diameters together in just one column.\n",
    "\n",
    "* Create and print a 1D array called `trunk_stump_diameters`, which replaces a tree's trunk diameter with its stump diameter if the trunk diameter is zero.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "213c090a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24 20  3  3  4  4  4  4  4  3  3  4  2  2  3  4  4  4  3 14  3  4  7  8\n",
      "  7  8  7  5  6  5  5 17 31 19 21 18  4  5  3  4  3  4 13 13 13  5  4  4\n",
      "  4 11  5  4  5  8 51  7  4 15  3  8  6  6  3  4  3  2  3  3  6  5  5  5\n",
      "  5  9  4  4  7  7  6  5  4  4  5  5  5  7  3  5  3  3  6  6  8  7  4  5\n",
      "  4  4  4  4  6  5  3  4 12 12 12  5  6  6  6  6  6  5  5  6  7  7 25  5\n",
      "  5  4  6  6  7 11  6 17 13 14 14 20 15 13  7  7 10 17 14  4  6  7  8  7\n",
      "  7  6  7  5  2  2  2  2 26 25  2 15  6 20  5  9 15 13 15  3  2 13  6 12\n",
      " 15 18 22 18 18 15 17  7  3  7  8  4 12 11 12  3  9 12 11 10  8  6  6  7\n",
      "  7  3 15 12 12  4  5  5  5  4  4  5  4  9  2  4  4  6  5  5  2  5  5  4\n",
      "  4  5  5  6 11  4  5  7  3 14 11 10  7 15 10  5  6 10 10  6  5  4  4  3\n",
      "  5  4 14 12 11  8 14 12  9 12 11  7  8 10 10 12 11 12  5  5  6  9  9  8\n",
      "  5  5  5  6  6 12 12 11 12  8  9  5  5  5  8  2  2  2 14 18 14 14 22 15\n",
      " 19 14 18  7  7  7  8  8  5 10 14  2  2  2  2 11 12 12  3  3  3  3  3  6\n",
      "  6  8  2  2 11 11 11  9 11 12 13  9 11  6  4  5  5  2  2  8 10  7  9 11\n",
      " 11  1  2 26  4 13  2  4  3  4  4  4  4  3  4  2  2 12 13  5  4  2  3  3\n",
      " 25 11 11 14 22  2  3 10  2  2 13 19 26 21 19 14 14  5 19 15 11 15  6 19\n",
      " 17 12 13 15 12  2 16  2  2  2 25  2 21  2 15 16 14 13 11  8 11 13 12  7\n",
      " 24 19  3  3  4  6 11 17 19 19 17 15 13 15 27 16 15 20 17 16  4 10  9 14\n",
      " 11 12  8  9  9 13 14  7 11 14  3  7 16 17 13 14 16 12  4  5  3 16 11  9\n",
      "  9 10  8 10 11 11  8 11 11 11  9 11 10  9  5 12 11 13  9 15 16 12  7 10\n",
      "  6  9  5  9  6  6  3  3  5  4  4  4  4  6  4  7  6  7  6  5  7  8 20  9\n",
      " 11 11 10  9 11 12 10 18  7  4  4  4  4  3 19 12  3  4  5  4  4 17 15  8\n",
      "  4  5  6 25  6 11  3  3 15  4 14 12 15  2  3  2 11 11 14 12 15 12  8  9\n",
      "  9  8  7 12 15  4 11 10  6  7  9 38  6  3 15 11  5  4  2 13 21 26  4 18\n",
      " 10 17 20 19 21 19 18 18 17 24 27 22 21  9 17 17 19 28 21 11 23 28  7 33\n",
      " 30  5 26 27 22  2  2  2  3  4  3  3 12 17 15  2  3  3  6  6  6  6 18 13\n",
      " 25 25 22 25 21 19  3  3  3  4  4 19  4  4 24 27 20  3 19  5 12 26 13  7\n",
      " 13  4 20  5 14 20 11  3  4 19  4 17 22 24 15  7  5  4  5  5  4  4  4  8\n",
      "  4  4  7  6 10  8 11  2  9  8  4  3  3  2  2 22 22 24 23 20 21  5  6  7\n",
      "  4  2 15 19 20  4  4  7  2 17 10  3 11  2 10 11  4  4  3 13  3  3  3  3\n",
      "  4  3  3  3 14  3  9  9  9 10 20 14 19 16 22 22 17 18  9  9  7  9  3 14\n",
      " 13 15 16 18 21  3  8  3  9  8 11  9 10  5  5 11 16  3  4  3  4  5  4 10\n",
      " 10 12  9  9 13 11 10  3  3  3  4  3  4  4 10 25  5  5  1 34  1  1  1 15\n",
      " 11 11 13  7  7 12 13  3 17 14 18 15 17 14 13 20  9 11  4  9 13  9 19 20\n",
      "  8  8 20 19 13 44 17 25 14 12 14 15  6  6  7  5  5  5  5  3  9  9 17 13\n",
      "  3 13 20 20 18 18 21 20 19 22 18 21 25 21 21 18 20 18 23 23 23 18 24 22\n",
      "  2  7  2 11 19 21 14 20 13  2 18  2  2 31 25 31 25 11 22  2 18 17 18 21\n",
      " 22 16 16 18 15 23  5  6 13 19  7 16 16 20 15 18  1 15 10 24 18  2  3  2\n",
      " 17 12 14 17 23 18 12 13 23  3 17  8  8  8  4  9 22  2 14 23 20 23  3  7\n",
      "  3  6  4 12  4  4  2  6  4  3 17 19  4 19 15 14 17 20  2 16  3 12 10 11\n",
      "  4 11  4 30  8  4 39  3  7 11 18 22 19 21  7 21  2 16 11 20 21 22  8 16\n",
      "  2 23 14 14 13 20 21 15 19 28 17 16 12 11 11  6]\n"
     ]
    }
   ],
   "source": [
    "# Create and print a 1D array of tree and stump diameters\n",
    "trunk_stump_diameters = np.where(tree_census[:, 2] == 0, tree_census[:, 3], tree_census[:, 2])\n",
    "print(trunk_stump_diameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caa02bc9",
   "metadata": {},
   "source": [
    "Looks fantastic! But this is just a 1D array without any tree or block ID information. How do we add this information back to the tree_census array? That's the subject of our next lesson!\n",
    "\n",
    "## Adding rows\n",
    "The research team has discovered two trees that were left off the tree_census. Your task is to add rows containing the data for these new trees to the end of the tree_census array. The new trees' data is saved in a 2D array called new_trees:\n",
    "```\n",
    "new_trees = np.array([[1211, 227386, 20, 0], [1212, 227386, 8, 0]])\n",
    "```\n",
    "\n",
    "* Print the shapes of `tree_census` and `new_trees` to confirm they are compatible to concatenate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "115e9053",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000, 4) (2, 4)\n"
     ]
    }
   ],
   "source": [
    "new_trees = np.array([[1211, 227386, 20, 0], [1212, 227386, 8, 0]])\n",
    "# Print the shapes of tree_census and new_trees\n",
    "print(tree_census.shape, new_trees.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96162bf8",
   "metadata": {},
   "source": [
    "* Add rows to the end of `tree_census` containing data for the new trees from the new_trees 2D array; save the new array as `updated_tree_census`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b7174e46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[     3 501451     24      0]\n",
      " [     4 501451     20      0]\n",
      " [     7 501911      3      0]\n",
      " ...\n",
      " [  1210 227386      6      0]\n",
      " [  1211 227386     20      0]\n",
      " [  1212 227386      8      0]]\n"
     ]
    }
   ],
   "source": [
    "# Add rows to tree_census which contain data for the new trees\n",
    "updated_tree_census = np.concatenate((tree_census, new_trees))\n",
    "print(updated_tree_census)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e137909",
   "metadata": {},
   "source": [
    "Excellent concatenation work! Notice that this concatenation task was easier because the array shapes and dimensions were already compatible. Let's take a look at an example where the arrays to be concatenated are not compatible.\n",
    "\n",
    "## Adding columns\n",
    "You finished the last set of exercises by creating an array called trunk_stump_diameters, which combined data from the trunk diameter and stump diameter columns into a 1D array. Now, you'll add that 1D array as a column to the `tree_census array`.\n",
    "\n",
    "* Print the shapes of both `tree_census` and `trunk_stump_diameters`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "aede232e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000, 4) (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Print the shapes of tree_census and trunk_stump_diameters\n",
    "print(tree_census.shape, trunk_stump_diameters.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86bb0b18",
   "metadata": {},
   "source": [
    "* Reshape `trunk_stump_diameters` so that it can be appended as the last column in `tree_census`; call the reshaped array `reshaped_diameters`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c3628bb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reshape trunk_stump_diameters\n",
    "reshaped_diameters = trunk_stump_diameters.reshape((1000, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31673c65",
   "metadata": {},
   "source": [
    "* Concatenate `reshaped_diameters` to the end of `tree_census` so that it becomes the last column; call the new array `concatenated_tree_censu`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fccb2a9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[     3 501451     24      0     24]\n",
      " [     4 501451     20      0     20]\n",
      " [     7 501911      3      0      3]\n",
      " ...\n",
      " [  1198 227387     11      0     11]\n",
      " [  1199 227387     11      0     11]\n",
      " [  1210 227386      6      0      6]]\n"
     ]
    }
   ],
   "source": [
    "# Concatenate reshaped_diameters to tree_census as the last column\n",
    "concatenated_tree_census = np.concatenate((tree_census, reshaped_diameters), axis=1)\n",
    "print(concatenated_tree_census)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36ea1d4c",
   "metadata": {},
   "source": [
    "That's right! Adding a 1D array to an existing 2D array requires you to reshape the 1D array into a 2D array first. We'll dive into shape compatibility issues like this even further in the next chapter on array mathematics!\n",
    "\n",
    "## Deleting with np.delete()\n",
    "What if your tree research focuses only on living trees on publicly-owned city blocks? It might be helpful to delete some unneeded data like the stump diameter column and some trees located on private blocks.\n",
    "\n",
    "You've learned that NumPy's `np.delete()` function takes three arguments: the original array, the index or indices to be deleted, and the axis to delete along. If you don't know the index or indices of the array you'd like to delete, recall that when it is only passed one argument,`np.where()` returns an array of indices where a condition is met!\n",
    "\n",
    "* Delete the stump diameter column from `tree_census`, and save the new 2D array as `tree_census_no_stumps`.\n",
    "* Using `np.where()`, find the indices of any trees on block 313879, a private block. Save the indices in an array called `private_block_indices`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b0c5a87a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete the stump diameter column from tree_census\n",
    "tree_census_no_stumps = np.delete(tree_census, 3, axis=1)\n",
    "\n",
    "# Save the indices of the trees on block 313879\n",
    "private_block_indices = np.where(tree_census[:, 1] == 313879)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06aea7d",
   "metadata": {},
   "source": [
    "* Using the indices you just found using `np.where()`, delete the rows for trees on block 313879 from `tree_census_no_stumps`, saving the new 2D array as `tree_census_clean`.\n",
    "* Print the shape of `tree_census_clean`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2ffbb8a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(998, 3)\n"
     ]
    }
   ],
   "source": [
    "# Delete the rows for trees on block 313879 from tree_census_no_stumps\n",
    "tree_census_clean = np.delete(tree_census_no_stumps, private_block_indices, axis=0)\n",
    "\n",
    "# Print the shape of tree_census_clean\n",
    "print(tree_census_clean.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46ce974e",
   "metadata": {},
   "source": [
    "We can't stump you! Notice that the new shape reflects two fewer rows and one fewer column than tree_census started with because of your deletions: just as expected."
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}