L5_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": null,
   "metadata": {},
   "outputs": [],
   "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",
    "We 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, we can probably loop over it. In addition to lists, we can iterate over the elements of a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": [
    "We can even loop through each character in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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. The easiest way to understand them is probably to just look at a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = []\n",
    "for n in range(10):\n",
    "    squares.append(n**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add an `if` condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "short_planets = [planet for planet in planets if len(planet) < 6]\n",
    "short_planets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of filtering with an `if` condition *and* applying some transformation to the loop variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[\n",
    "    planet.upper() + '!' \n",
    "    for planet in planets \n",
    "    if len(planet) < 6\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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 will the expression below evaluate to?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "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": null,
   "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": null,
   "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": null,
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**[Week 1 - Python](https://radu-enuca.gitbook.io/ml-challenge/python)**\n",
    "\n",
    "*Have questions or comments? Visit the ML Challenge Mattermost Channel.*"
   ]
  }
 ],
 "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.7.4"
  },
  "learntools_metadata": {
   "lesson_index": 4,
   "type": "tutorial"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}