python-list-comprehensions-in-5-minutes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Quick Introduction to List Comprehensions with Python\n",
    "\n",
    "This notebook runs through some quick examples of how to do list comprehensions in Python.\n",
    "\n",
    "List comprehensions are one of the most powerful tools in a Pythonista's toolbelt. There are many more things they are capable of outside of this notebook but we'll save those for a later date.\n",
    "\n",
    "**Note:** There is an accompanying blog post and video on YouTube explaining the steps in this notebook more in-depth.\n",
    "    \n",
    "- Blog post:\n",
    "- YouTube video:\n",
    "\n",
    "If you find any errors or have advice for a future tutorial, please let me know at [daniel@mrdbourke.com](mailto:daniel@mrdbourke.com)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why would you use a list comprehension?\n",
    "\n",
    "To get the same thing done in less lines of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The shopping cart example\n",
    "Let's say you're shopping at a math store and you have in your cart a bunch of differnt numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# shopping cart full of numbers (a Python list of numbers)\n",
    "cart = [5, 7, 9, 10, 12, 15, 19, 20, 22]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You realise you've done enough shopping and decide to go to the cashier and start passing them the items one by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9, 10, 12, 15, 19, 20, 22]\n"
     ]
    }
   ],
   "source": [
    "cashier = [] # the cashier starts with zero items\n",
    "for item in cart: # go over each item one by one\n",
    "    cashier.append(item) # hand the cashier each item\n",
    "print(cashier) # check which items the cashier has"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9, 10, 12, 15, 19, 20, 22]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now how could you make this shorter? Could you do it in one line of code instead of three?\n",
    "\n",
    "This is where list comprehensions come into play.\n",
    "\n",
    "Let's check using a differnt cashier to make sure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "cashier_2 = [item for item in cart]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wait? Surely this can't be the same as the lines above?\n",
    "\n",
    "Let's check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9, 10, 12, 15, 19, 20, 22]\n",
      "[5, 7, 9, 10, 12, 15, 19, 20, 22]\n"
     ]
    }
   ],
   "source": [
    "print(cashier)\n",
    "print(cashier_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They're the exact same!\n",
    "\n",
    "What's happening here?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/list-comprehensions-1.png\" alt=\"Drawing\" style=\"width: 700px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each of the colours corresponds to what's happening in each section of code.\n",
    "\n",
    "1. `cashier` is created in blue. On the left it's created on its own line. On the right, it's created at the same time everything else is being created.\n",
    "\n",
    "2. `cart` is being iterated over in green. `item` is created as the for loop runs. This is the same as grabbing one `item` at a time out of your shopping cart and passing it to the cashier.\n",
    "\n",
    "3. `cashier` is updated in the red with each `item`. The only difference is on the left, an `append` statement is required. The list comprehension on the right negates the need for an `append` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some more shopping cart examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third cashier only likes working with even numbers. How could we deal with that?\n",
    "\n",
    "Let's try a non-list comprehension version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9, 10, 12, 15, 19, 20, 22]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 12, 20, 22]\n"
     ]
    }
   ],
   "source": [
    "# Only give cashier_3 even numbers\n",
    "cashier_3 = []\n",
    "for item in cart:\n",
    "    if item % 2 == 0:\n",
    "        cashier_3.append(item)\n",
    "print(cashier_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How could you do this with a list comprehension?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 12, 20, 22]\n"
     ]
    }
   ],
   "source": [
    "cashier_3 = [item for item in cart if item % 2 == 0]\n",
    "print(cashier_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's happening here?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/list-comprehensions-2.png\" alt=\"Drawing\" style=\"width: 700px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's similar to the above example except now we have a conditional statement in yellow.\n",
    "\n",
    "1. `cashier_3` is created in blue. In the top code it's created on its own line. Below, it's created at the same time everything else is being created.\n",
    "\n",
    "2. `cart` is being iterated over in green. `item` is created as the for loop runs. This is the same as grabbing one `item` at a time out of your shopping cart and passing it to the cashier.\n",
    "\n",
    "3. As each `item` is being passed to `cashier_3`, it's being checked to see if it matches up with the conditional in yellow. \n",
    "    * Example: `10 % 2 = 0`, the `%` symbol is called modulo. It returns the remainder of one number divided by another. \n",
    "        * Example 2: `19 % 2 = 1` because `19 = 9 * 2 + 1`.\n",
    "\n",
    "4. `cashier_3` is updated in the red with each `item` as long as it fulfills the conditional in yellow. The list comprehension on negates the need for an `append` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fourth cashier only accepts numbers over 100 and are odd. How would you change each of the numbers in `cart` before giving them to `cashier_4`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9, 10, 12, 15, 19, 20, 22]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[105, 107, 109, 115, 119]\n"
     ]
    }
   ],
   "source": [
    "# Only give cashier 4 odd numbers over 100\n",
    "cashier_4 = []\n",
    "for item in cart:\n",
    "    item += 100 # add 100 to each item to bring them over 100\n",
    "    if item % 2 == 1: # check to see if they're odd or not\n",
    "        cashier_4.append(item)\n",
    "print(cashier_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now do the same with a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[105, 107, 109, 115, 119]\n"
     ]
    }
   ],
   "source": [
    "# TODO: Turn the cashier_4 code above into a list comprehension\n",
    "cashier_4 = [item+100 for item in cart if item % 2 == 1]\n",
    "print(cashier_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What if you don't have a list of numbers to begin with?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n"
     ]
    }
   ],
   "source": [
    "# Non-list comprehension\n",
    "a = []\n",
    "for i in range(100):\n",
    "    a.append(i)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n"
     ]
    }
   ],
   "source": [
    "# List comprehension version\n",
    "b = [i for i in range(100)]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is `a` the same as `b`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You bet!\n"
     ]
    }
   ],
   "source": [
    "if a == b:\n",
    "    print('You bet!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What about comparing two lists?\n",
    "\n",
    "Let's compare two differnt shopping carts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "cart_1 = [1, 8, 29, 34, 58, 74, 88, 99]\n",
    "cart_2 = [3, 8, 31, 36, 58, 77, 88, 93]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`cashier_5` only takes two of the same item at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 58, 88]\n"
     ]
    }
   ],
   "source": [
    "# Non-list comprehension version\n",
    "cashier_5 = []\n",
    "for item in cart_1:\n",
    "    if item in cart_2:\n",
    "        cashier_5.append(item)\n",
    "print(cashier_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 58, 88]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List comprehension version\n",
    "cashier_5 = [item for item in cart_1 if item in cart_2]\n",
    "cashier_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge time!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How could you add these two lists together for `cashier_6`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 60, 70, 116, 151, 176, 192]\n"
     ]
    }
   ],
   "source": [
    "# Without list comprehension\n",
    "cashier_6 = []\n",
    "for item_1, item_2 in zip(cart_1, cart_2):\n",
    "    cashier_6.append(item_1 + item_2)\n",
    "print(cashier_6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We haven't been over the `zip` function yet but here's a hint at what it's doing.\n",
    "\n",
    "Remember what `cart_1` and `cart_2` look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 29, 34, 58, 74, 88, 99]\n",
      "[3, 8, 31, 36, 58, 77, 88, 93]\n"
     ]
    }
   ],
   "source": [
    "print(cart_1)\n",
    "print(cart_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's `zip` them together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (8, 8), (29, 31), (34, 36), (58, 58), (74, 77), (88, 88), (99, 93)]\n"
     ]
    }
   ],
   "source": [
    "cart_3 = list(zip(cart_1, cart_2))\n",
    "print(cart_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you've seen this, how could you turn the `cashier_6` non-list comprehension code into a list comprehension?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Give cashier_6 the numbers in cart_1 and cart_2 added together.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get stuck, this Stackoverflow thread should help you out: https://stackoverflow.com/questions/14050824/add-sum-of-values-of-two-lists-into-new-list\n",
    "\n",
    "**Extra challenge:** Part of being a good Python programmer is researching what different functions do. Can you find a resource which explains the `zip` function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More\n",
    "\n",
    "This was brief introduciton to list comprehensions in Python. If you'd like more, I'd recommend checking out this article by DataCamp: https://www.datacamp.com/community/tutorials/python-list-comprehension\n",
    "    \n",
    "Happy comprehending!\n",
    "\n",
    "**PS** don't forget, if you find any errors or have advice for how something could be done better, please let me know at daniel@mrdbourke.com."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}