python-for-data/Lec05 - Loops and List Comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "Loops are a way to repeatedly execute some code. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune "
     ]
    }
   ],
   "source": [
    "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
    "for planet in planets:\n",
    "    print(planet, end=' ') # print all on same line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **``for``** loop specifies:\n",
    "- The variable name to use (in this case, `planet`)\n",
    "- The set of values to loop over (in this case, `planets`)\n",
    "\n",
    "You use the word **``in``** to link them together.\n",
    "\n",
    "The object to the right of the \"``in``\" can be any object that supports iteration. Basically, if it can be thought of as a group of things, you can probably loop over it. In addition to lists, we can iterate over the elements of a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "360"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiplicands = (2, 2, 2, 3, 3, 5)\n",
    "product = 1\n",
    "for mult in multiplicands:\n",
    "    product = product * mult\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even loop through each character in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO"
     ]
    }
   ],
   "source": [
    "s = 'steganograpHy is the practicE of conceaLing a file, message, image, or video within another fiLe, message, image, Or video.'\n",
    "msg = ''\n",
    "# print all the uppercase letters in s, one at a time\n",
    "for char in s:\n",
    "    if char.isupper():\n",
    "        print(char, end='')        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range()\n",
    "\n",
    "**`range()`** is a function that returns a sequence of numbers. It turns out to be very useful for writing loops.\n",
    "\n",
    "For example, if we want to repeat some action 5 times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(\"Doing important work. i =\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ``while`` loops\n",
    "The other type of loop in Python is a ``while`` loop, which iterates until some condition is met:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i, end=' ')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The argument of the ``while`` loop is evaluated as a boolean statement, and the loop is executed until the statement evaluates to False."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions\n",
    "\n",
    "List comprehensions are one of Python's most beloved and unique features. *But it may be difficult to start with*, so be patient.\n",
    "- It provides a concise way to create lists.\n",
    "- It consists of squarre brackets containing an expression followed by a `for` clause, then zero or more `for` or `if` clauses. The expressions can be anything, meaning you can put in all kinds of objects in lists.\n",
    "- The result will be a new list resulting from evaluating the expression in the context of the `for` and `if` clauses which follow it. \n",
    "\n",
    "### Syntax\n",
    "\n",
    "The list comprehension starts with a `[` and `]`, to help you remember that the result is going to be a list.\n",
    "\n",
    "The basic syntax is:\n",
    "```python\n",
    "[ expression for item in list if conditional ]\n",
    "```\n",
    "This is equivalent to:\n",
    "```python\n",
    "for item in list:\n",
    "    if conditional:\n",
    "        expression\n",
    "```\n",
    "### Interpretation\n",
    "```python\n",
    "new_list = [expression(i) for i in old_list if filter(i)]\n",
    "```\n",
    "- **new_list**: The new list (result).\n",
    "\n",
    "- **expression(i)**: Expression is based on the variable used for each element in the old list.\n",
    "\n",
    "- **for i in old_list**: The word for followed by the variable name to use, followed by the word in the\n",
    "old list.\n",
    "\n",
    "- **if filter(i)**: Apply a filter with an If-statement.\n",
    "\n",
    "\n",
    "The easiest way to understand them is probably to just look at a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [n**2 for n in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how we would do the same thing without a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for n in range(10):\n",
    "    squares.append(n**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, adding an `if` condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Venus', 'Earth', 'Mars']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_planets = [planet for planet in planets if len(planet) < 6]\n",
    "short_planets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you're familiar with SQL, you might think of this as being like a \"WHERE\" clause)\n",
    "\n",
    "Here's an example of filtering with an `if` condition *and* applying some transformation to the loop variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['VENUS!', 'EARTH!', 'MARS!']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# str.upper() returns an all-caps version of a string\n",
    "loud_short_planets = [planet.upper() + '!' for planet in planets if len(planet) < 6]\n",
    "loud_short_planets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "People usually write these on a single line, but you might find the structure clearer when it's split up over 3 lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['VENUS!', 'EARTH!', 'MARS!']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\n",
    "    planet.upper() + '!' \n",
    "    for planet in planets \n",
    "    if len(planet) < 6\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Continuing the SQL analogy, you could think of these three lines as SELECT, FROM, and WHERE)\n",
    "\n",
    "The expression on the left doesn't technically have to involve the loop variable (though it'd be pretty unusual for it not to). What do you think the expression below will evaluate to?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32, 32, 32, 32, 32, 32, 32, 32]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[32 for planet in planets]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions combined with functions like `min`, `max`, and `sum` can lead to impressive one-line solutions for problems that would otherwise require several lines of code. \n",
    "\n",
    "For example, compare the following two cells of code that do the same thing.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_negatives(nums):\n",
    "    \"\"\"Return the number of negative numbers in the given list.\n",
    "    \n",
    "    >>> count_negatives([5, -1, -2, 0, 3])\n",
    "    2\n",
    "    \"\"\"\n",
    "    n_negative = 0\n",
    "    for num in nums:\n",
    "        if num < 0:\n",
    "            n_negative = n_negative + 1\n",
    "    return n_negative"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a solution using a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_negatives(nums):\n",
    "    return len([num for num in nums if num < 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Much better, right?*\n",
    "\n",
    "Well if all we care about is minimizing the length of our code, this third solution is better still!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_negatives(nums):\n",
    "    # Reminder: in the \"booleans and conditionals\" exercises, we learned about a quirk of \n",
    "    # Python where it calculates something like True + True + False + True to be equal to 3.\n",
    "    return sum([num < 0 for num in nums])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which of these solutions is the \"best\" is entirely subjective. Solving a problem with less code is always nice, but it's worth keeping in mind the following lines from [The Zen of Python](https://en.wikipedia.org/wiki/Zen_of_Python):\n",
    "\n",
    "> Readability counts.  \n",
    "> Explicit is better than implicit.\n",
    "\n",
    "So, use these tools to make compact readable programs. But when you have to choose, favor code that is easy for others to understand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your Turn 👋"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.5"
  },
  "learntools_metadata": {
   "lesson_index": 4,
   "type": "tutorial"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}