Data Scientist With Python/Introduction to Python/Module 2 - Python Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26883021",
   "metadata": {},
   "source": [
    "# Chapter 2 - Python Lists¶\n",
    "\n",
    "## Learn to store, access and manipulate data in lists: the first step towards efficiently working with huge amounts of data.\n",
    "Create a list\n",
    "As opposed to int, bool etc., a list is a compound data type; you can group values together:\n",
    "\n",
    "a = \"is\" b = \"nice\" my_list = [\"my\", \"list\", a, b] After measuring the height of your family, you decide to collect some information on the house you're living in. The areas of the different parts of your house are stored in separate variables for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0494b522",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.25, 18.0, 20.0, 10.75, 9.5]\n"
     ]
    }
   ],
   "source": [
    "# area variables (in square meters)\n",
    "hall = 11.25\n",
    "kit = 18.0\n",
    "liv = 20.0\n",
    "bed = 10.75\n",
    "bath = 9.50\n",
    "\n",
    "# Create list areas\n",
    "areas=[hall , kit,liv,bed,bath]\n",
    "\n",
    "# Print areas\n",
    "print(areas)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df35557",
   "metadata": {},
   "source": [
    "## Create list with different types\n",
    "A list can contain any Python type. Although it's not really common, a list can also contain a mix of Python types including strings, floats, booleans, etc.\n",
    "\n",
    "The printout of the previous exercise wasn't really satisfying. It's just a list of numbers representing the areas, but you can't tell which area corresponds to which part of your house.\n",
    "\n",
    "For some of the areas, the name of the corresponding room is already placed in front. Pay attention here! \"bathroom\" is a string, while bath is a variable that represents the float 9.50 you specified earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c7166fb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hallway', 11.25, 'kitchen', 18.0, 'living room', 20.0, 'bedroom', 10.75, 'bathroom', 9.5]\n"
     ]
    }
   ],
   "source": [
    "# area variables (in square meters)\n",
    "hall = 11.25\n",
    "kit = 18.0\n",
    "liv = 20.0\n",
    "bed = 10.75\n",
    "bath = 9.50\n",
    "\n",
    "# Adapt list areas\n",
    "areas = [\"hallway\",hall,\"kitchen\", kit, \"living room\", liv,\"bedroom\", bed, \"bathroom\", bath]\n",
    "\n",
    "# Print areas\n",
    "print(areas)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b31eb6c",
   "metadata": {},
   "source": [
    "## List of lists\n",
    "As a data scientist, you'll often be dealing with a lot of data, and it will make sense to group some of this data.\n",
    "\n",
    "Instead of creating a flat list containing strings and floats, representing the names and areas of the rooms in your house, you can create a list of lists.\n",
    "\n",
    "Don't get confused here: \"hallway\" is a string, while hall is a variable that represents the float 11.25 you specified earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0dd7ddc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['hallway', 11.25], ['kitchen', 18.0], ['living room', 20.0], ['bedroom', 10.75], ['bathroom', 9.5]]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# area variables (in square meters)\n",
    "hall = 11.25\n",
    "kit = 18.0\n",
    "liv = 20.0\n",
    "bed = 10.75\n",
    "bath = 9.50\n",
    "\n",
    "# house information as list of lists\n",
    "house = [[\"hallway\", hall],\n",
    "         [\"kitchen\", kit],\n",
    "         [\"living room\", liv],\n",
    "         [\"bedroom\",bed],\n",
    "         [\"bathroom\",bath]]\n",
    "\n",
    "# Print out house\n",
    "print(house)\n",
    "\n",
    "# Print out the type of house\n",
    "print(type(house))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b68787af",
   "metadata": {},
   "source": [
    "## Subset and conquer\n",
    "Subsetting Python lists is a piece of cake. Take the code sample below, which creates a list x and then selects \"b\" from it. Remember that this is the second element, so it has index 1. You can also use negative indexing.\n",
    "```python\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "x[1]\n",
    "x[-3] # same result!\n",
    "```\n",
    "\n",
    "Remember the areas list from before, containing both strings and floats?. Can you add the correct code to do some Python subsetting?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1df77f4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.25\n",
      "9.5\n",
      "20.0\n"
     ]
    }
   ],
   "source": [
    "# Create the areas list\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "# Print out second element from areas\n",
    "print(areas[1])\n",
    "\n",
    "# Print out last element from areas\n",
    "print(areas[-1])\n",
    "\n",
    "# Print out the area of the living room\n",
    "print(areas[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de777722",
   "metadata": {},
   "source": [
    "## Subset and calculate\n",
    "After you've extracted values from a list, you can use them to perform additional calculations. Take this example, where the second and fourth element of a list x are extracted. The strings that result are pasted together using the + operator:\n",
    "\n",
    "```python\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "print(x[1] + x[3])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a88fcec5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.75\n"
     ]
    }
   ],
   "source": [
    "# Create the areas list\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "# Sum of kitchen and bedroom area: eat_sleep_area\n",
    "eat_sleep_area=areas[3]+areas[7]\n",
    "\n",
    "# Print the variable eat_sleep_area\n",
    "print(eat_sleep_area)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b4952ab",
   "metadata": {},
   "source": [
    "## Slicing and dicing\n",
    "Selecting single values from a list is just one part of the story. It's also possible to slice your list, which means selecting multiple elements from your list. Use the following syntax:\n",
    "\n",
    "my_list[start:end]\n",
    "The start index will be included, while the end index is not.\n",
    "\n",
    "The code sample below shows an example. A list with \"b\" and \"c\", corresponding to indexes 1 and 2, are selected from a list x:\n",
    "```\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "x[1:3]\n",
    "```\n",
    "The elements with index 1 and 2 are included, while the element with index 3 is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d5831699",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hallway', 11.25, 'kitchen', 18.0, 'living room', 20.0] ['bedroom', 10.75, 'bathroom', 9.5]\n"
     ]
    }
   ],
   "source": [
    "# Create the areas list\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "# Use slicing to create downstairs\n",
    "downstairs=areas[:6]\n",
    "\n",
    "# Use slicing to create upstairs\n",
    "upstairs=areas[6:10]\n",
    "\n",
    "# Print out downstairs and upstairs\n",
    "print(downstairs,upstairs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf369209",
   "metadata": {},
   "source": [
    "## Slicing and dicing (2)\n",
    "We first discussed the syntax where you specify both where to begin and end the slice of your list:\n",
    "\n",
    "my_list[begin:end]\n",
    "\n",
    "However, it's also possible not to specify these indexes. If you don't specify the begin index, Python figures out that you want to start your slice at the beginning of your list. If you don't specify the end index, the slice will go all the way to the last element of your list. To experiment with this, try the following commands\n",
    "```\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "x[:2]\n",
    "x[2:]\n",
    "x[:]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c13b5fe5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the areas list\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "# Alternative slicing to create downstairs\n",
    "\n",
    "downstairs=areas[:6]\n",
    "# Alternative slicing to create upstairs\n",
    "upstairs=areas[6:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e703af87",
   "metadata": {},
   "source": [
    "## Subsetting lists of lists\n",
    "You saw before that a Python list can contain practically anything; even other lists! To subset lists of lists, you can use the same technique as before: square brackets. Try out the commands in the following code sample  \n",
    "\n",
    "```python\n",
    "x = [[\"a\", \"b\", \"c\"],\n",
    "     [\"d\", \"e\", \"f\"],\n",
    "     [\"g\", \"h\", \"i\"]]\n",
    "x[2][0]\n",
    "x[2][:2]\n",
    "```\n",
    "x[2] results in a list, that you can subset again by adding additional square brackets.\n",
    "\n",
    "What will house[-1][1] return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0c62d62c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['hallway', 11.25],\n",
       " ['kitchen', 18.0],\n",
       " ['living room', 20.0],\n",
       " ['bedroom', 10.75],\n",
       " ['bathroom', 9.5]]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "house"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5840b120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "house[-1][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8b53793",
   "metadata": {},
   "source": [
    "## Replace list elements\n",
    "Replacing list elements is pretty easy. Simply subset the list and assign new values to the subset. You can select single elements or you can change entire list slices at once.\n",
    "\n",
    "Use the IPython Shell to experiment with the commands below. Can you tell what's happening and why?\n",
    "\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]  \n",
    "x[1] = \"r\"  \n",
    "x[2:] = [\"s\", \"t\"]  \n",
    "For this and the following exercises, you'll continue working on the areas list that contains the names and areas of different rooms in a house."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "19f9dbcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the areas list\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "# Correct the bathroom area\n",
    "areas[-1]=10.50\n",
    "\n",
    "# Change \"living room\" to \"chill zone\"\n",
    "areas[4]=\"chill zone\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2624f024",
   "metadata": {},
   "source": [
    "## Extend a list\n",
    "If you can change elements in a list, you sure want to be able to add elements to it, right? You can use the + operator:\n",
    "```\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "y = x + [\"e\", \"f\"]\n",
    "```\n",
    "You just won the lottery, awesome! You decide to build a poolhouse and a garage. Can you add the information to the areas list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ffc65da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the areas list and make some changes\n",
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"chill zone\", 20.0,\n",
    "         \"bedroom\", 10.75, \"bathroom\", 10.50]\n",
    "\n",
    "# Add poolhouse data to areas, new list is areas_1\n",
    "\n",
    "areas_1=areas+[\"poolhouse\",24.5]\n",
    "# Add garage data to areas_1, new list is areas_2\n",
    "areas_2=areas_1+[\"garage\",15.45]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dc40bdd",
   "metadata": {},
   "source": [
    "Cool! The list is shaping up nicely!\n",
    "\n",
    "\n",
    "## Delete list elements\n",
    "Finally, you can also remove elements from your list. You can do this with the del statement:\n",
    "```\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]  \n",
    "del(x[1])  \n",
    "```\n",
    "Pay attention here: as soon as you remove an element from a list, the indexes of the elements that come after the deleted element all change!\n",
    "\n",
    "The updated and extended version of areas that you've built in the previous exercises is coded below.  \n",
    "**areas = [\"hallway\", 11.25, \"kitchen\", 18.0,\n",
    "        \"chill zone\", 20.0, \"bedroom\", 10.75,\n",
    "         \"bathroom\", 10.50, \"poolhouse\", 24.5,\n",
    "         \"garage\", 15.45]**\n",
    "There was a mistake! The amount you won with the lottery is not that big after all and it looks like the poolhouse isn't going to happen. You decide to remove the corresponding string and float from the areas list.\n",
    "\n",
    "Also the ; sign is used to place commands on the same line. The following two code chunks are equivalent:\n",
    "\n",
    "```python\n",
    "# Same line\n",
    "command1; command2\n",
    "\n",
    "# Separate lines\n",
    "command1\n",
    "command2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dedfd863",
   "metadata": {},
   "outputs": [],
   "source": [
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0,\n",
    "        \"chill zone\", 20.0, \"bedroom\", 10.75,\n",
    "         \"bathroom\", 10.50, \"poolhouse\", 24.5,\n",
    "         \"garage\", 15.45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1f6f4c98",
   "metadata": {},
   "outputs": [],
   "source": [
    "del(areas[10:12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "236cf424",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hallway',\n",
       " 11.25,\n",
       " 'kitchen',\n",
       " 18.0,\n",
       " 'chill zone',\n",
       " 20.0,\n",
       " 'bedroom',\n",
       " 10.75,\n",
       " 'bathroom',\n",
       " 10.5,\n",
       " 'garage',\n",
       " 15.45]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "areas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f411f7",
   "metadata": {},
   "source": [
    "## Inner workings of lists\n",
    "The Python code in the script already creates a list with the name areas and a copy named areas_copy. Next, the first element in the areas_copy list is changed and the areas list is printed out. If you hit Run Code you'll see that, although you've changed areas_copy, the change also takes effect in the areas list. That's because areas and areas_copy point to the same list.\n",
    "\n",
    "If you want to prevent changes in areas_copy from also taking effect in areas, you'll have to do a more explicit copy of the areas list. You can do this with list() or by using [:]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e10c069e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5.0, 18.0, 20.0, 10.75, 9.5]\n",
      "[5.0, 18.0, 20.0, 10.75, 9.5]\n"
     ]
    }
   ],
   "source": [
    "# Create list areas\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Create areas_copy\n",
    "areas_copy = areas\n",
    "\n",
    "# Change areas_copy\n",
    "areas_copy[0] = 5.0\n",
    "\n",
    "# Print areas\n",
    "print(areas)\n",
    "print(areas_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1415c22c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.25, 18.0, 20.0, 10.75, 9.5]\n",
      "[5.0, 18.0, 20.0, 10.75, 9.5]\n"
     ]
    }
   ],
   "source": [
    "# Create list areas\n",
    "areas = [11.25, 18.0, 20.0, 10.75, 9.50]\n",
    "\n",
    "# Create areas_copy\n",
    "areas_copy = list(areas)\n",
    "\n",
    "# Change areas_copy\n",
    "areas_copy[0] = 5.0\n",
    "\n",
    "# Print areas\n",
    "print(areas)\n",
    "print(areas_copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac0b771c",
   "metadata": {},
   "source": [
    "Nice! The difference between explicit and reference-based copies is subtle, but can be really important. Try to keep in mind how a list is stored in the computer's memory."
   ]
  }
 ],
 "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
}