00-Repasando-python/05-loops-and-list-comprehensions/loops-and-list-comprehensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.018787,
     "end_time": "2020-10-01T01:21:25.283479",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.264692",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Loops\n",
    "\n",
    "Loops are a way to repeatedly execute some code. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.325159Z",
     "iopub.status.busy": "2020-10-01T01:21:25.324492Z",
     "iopub.status.idle": "2020-10-01T01:21:25.329179Z",
     "shell.execute_reply": "2020-10-01T01:21:25.329701Z"
    },
    "papermill": {
     "duration": 0.028737,
     "end_time": "2020-10-01T01:21:25.329887",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.301150",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.017627,
     "end_time": "2020-10-01T01:21:25.367354",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.349727",
     "status": "completed"
    },
    "tags": []
   },
   "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": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.411125Z",
     "iopub.status.busy": "2020-10-01T01:21:25.410384Z",
     "iopub.status.idle": "2020-10-01T01:21:25.414192Z",
     "shell.execute_reply": "2020-10-01T01:21:25.413556Z"
    },
    "papermill": {
     "duration": 0.029018,
     "end_time": "2020-10-01T01:21:25.414318",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.385300",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "360"
      ]
     },
     "execution_count": 2,
     "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": {
    "papermill": {
     "duration": 0.017994,
     "end_time": "2020-10-01T01:21:25.450660",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.432666",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "You can even loop through each character in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.494258Z",
     "iopub.status.busy": "2020-10-01T01:21:25.493058Z",
     "iopub.status.idle": "2020-10-01T01:21:25.497471Z",
     "shell.execute_reply": "2020-10-01T01:21:25.496980Z"
    },
    "papermill": {
     "duration": 0.028893,
     "end_time": "2020-10-01T01:21:25.497599",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.468706",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.018638,
     "end_time": "2020-10-01T01:21:25.534797",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.516159",
     "status": "completed"
    },
    "tags": []
   },
   "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": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.578214Z",
     "iopub.status.busy": "2020-10-01T01:21:25.577214Z",
     "iopub.status.idle": "2020-10-01T01:21:25.581986Z",
     "shell.execute_reply": "2020-10-01T01:21:25.581367Z"
    },
    "papermill": {
     "duration": 0.028871,
     "end_time": "2020-10-01T01:21:25.582106",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.553235",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doing important work. i = 0\n",
      "Doing important work. i = 1\n",
      "Doing important work. i = 2\n",
      "Doing important work. i = 3\n",
      "Doing important work. i = 4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Doing important work. i =\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.018779,
     "end_time": "2020-10-01T01:21:25.620702",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.601923",
     "status": "completed"
    },
    "tags": []
   },
   "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": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.664132Z",
     "iopub.status.busy": "2020-10-01T01:21:25.663437Z",
     "iopub.status.idle": "2020-10-01T01:21:25.668370Z",
     "shell.execute_reply": "2020-10-01T01:21:25.667716Z"
    },
    "papermill": {
     "duration": 0.028976,
     "end_time": "2020-10-01T01:21:25.668488",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.639512",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.019409,
     "end_time": "2020-10-01T01:21:25.707762",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.688353",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.019275,
     "end_time": "2020-10-01T01:21:25.746670",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.727395",
     "status": "completed"
    },
    "tags": []
   },
   "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": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.791908Z",
     "iopub.status.busy": "2020-10-01T01:21:25.791248Z",
     "iopub.status.idle": "2020-10-01T01:21:25.794955Z",
     "shell.execute_reply": "2020-10-01T01:21:25.794260Z"
    },
    "papermill": {
     "duration": 0.028374,
     "end_time": "2020-10-01T01:21:25.795079",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.766705",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [n**2 for n in range(10)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.019935,
     "end_time": "2020-10-01T01:21:25.835207",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.815272",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Here's how we would do the same thing without a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.877811Z",
     "iopub.status.busy": "2020-10-01T01:21:25.877191Z",
     "iopub.status.idle": "2020-10-01T01:21:25.882880Z",
     "shell.execute_reply": "2020-10-01T01:21:25.883378Z"
    },
    "papermill": {
     "duration": 0.028585,
     "end_time": "2020-10-01T01:21:25.883511",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.854926",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for n in range(10):\n",
    "    squares.append(n**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.019881,
     "end_time": "2020-10-01T01:21:25.923834",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.903953",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "We can also add an `if` condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:25.967469Z",
     "iopub.status.busy": "2020-10-01T01:21:25.966876Z",
     "iopub.status.idle": "2020-10-01T01:21:25.972999Z",
     "shell.execute_reply": "2020-10-01T01:21:25.973464Z"
    },
    "papermill": {
     "duration": 0.029373,
     "end_time": "2020-10-01T01:21:25.973619",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.944246",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Venus', 'Earth', 'Mars']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "short_planets = [planet for planet in planets if len(planet) < 6]\n",
    "short_planets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.020734,
     "end_time": "2020-10-01T01:21:26.015069",
     "exception": false,
     "start_time": "2020-10-01T01:21:25.994335",
     "status": "completed"
    },
    "tags": []
   },
   "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": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.062605Z",
     "iopub.status.busy": "2020-10-01T01:21:26.061907Z",
     "iopub.status.idle": "2020-10-01T01:21:26.066307Z",
     "shell.execute_reply": "2020-10-01T01:21:26.065809Z"
    },
    "papermill": {
     "duration": 0.030705,
     "end_time": "2020-10-01T01:21:26.066417",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.035712",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['VENUS!', 'EARTH!', 'MARS!']"
      ]
     },
     "execution_count": 9,
     "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": {
    "papermill": {
     "duration": 0.021582,
     "end_time": "2020-10-01T01:21:26.109433",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.087851",
     "status": "completed"
    },
    "tags": []
   },
   "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": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.157469Z",
     "iopub.status.busy": "2020-10-01T01:21:26.156799Z",
     "iopub.status.idle": "2020-10-01T01:21:26.160793Z",
     "shell.execute_reply": "2020-10-01T01:21:26.160163Z"
    },
    "papermill": {
     "duration": 0.030187,
     "end_time": "2020-10-01T01:21:26.160901",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.130714",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['VENUS!', 'EARTH!', 'MARS!']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\n",
    "    planet.upper() + '!' \n",
    "    for planet in planets \n",
    "    if len(planet) < 6\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021252,
     "end_time": "2020-10-01T01:21:26.204160",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.182908",
     "status": "completed"
    },
    "tags": []
   },
   "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? Press the 'output' button to check. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_kg_hide-output": true,
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.253197Z",
     "iopub.status.busy": "2020-10-01T01:21:26.252366Z",
     "iopub.status.idle": "2020-10-01T01:21:26.256381Z",
     "shell.execute_reply": "2020-10-01T01:21:26.255763Z"
    },
    "papermill": {
     "duration": 0.0308,
     "end_time": "2020-10-01T01:21:26.256490",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.225690",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32, 32, 32, 32, 32, 32, 32, 32]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[32 for planet in planets]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021976,
     "end_time": "2020-10-01T01:21:26.300917",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.278941",
     "status": "completed"
    },
    "tags": []
   },
   "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": 12,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.348945Z",
     "iopub.status.busy": "2020-10-01T01:21:26.348276Z",
     "iopub.status.idle": "2020-10-01T01:21:26.353228Z",
     "shell.execute_reply": "2020-10-01T01:21:26.353758Z"
    },
    "jupyter": {
     "outputs_hidden": true
    },
    "papermill": {
     "duration": 0.030557,
     "end_time": "2020-10-01T01:21:26.353905",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.323348",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.021989,
     "end_time": "2020-10-01T01:21:26.397855",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.375866",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Here's a solution using a list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.445083Z",
     "iopub.status.busy": "2020-10-01T01:21:26.444367Z",
     "iopub.status.idle": "2020-10-01T01:21:26.448477Z",
     "shell.execute_reply": "2020-10-01T01:21:26.448988Z"
    },
    "jupyter": {
     "outputs_hidden": true
    },
    "papermill": {
     "duration": 0.029113,
     "end_time": "2020-10-01T01:21:26.449145",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.420032",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def count_negatives(nums):\n",
    "    return len([num for num in nums if num < 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021826,
     "end_time": "2020-10-01T01:21:26.493271",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.471445",
     "status": "completed"
    },
    "tags": []
   },
   "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": 14,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-10-01T01:21:26.542739Z",
     "iopub.status.busy": "2020-10-01T01:21:26.541982Z",
     "iopub.status.idle": "2020-10-01T01:21:26.544422Z",
     "shell.execute_reply": "2020-10-01T01:21:26.544987Z"
    },
    "jupyter": {
     "outputs_hidden": true
    },
    "papermill": {
     "duration": 0.029788,
     "end_time": "2020-10-01T01:21:26.545130",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.515342",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.022395,
     "end_time": "2020-10-01T01:21:26.589824",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.567429",
     "status": "completed"
    },
    "tags": []
   },
   "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": {
    "papermill": {
     "duration": 0.022225,
     "end_time": "2020-10-01T01:21:26.635845",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.613620",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Your Turn\n",
    "\n",
    "You know the deal at this point. We have some **[fun coding challenges](https://www.kaggle.com/kernels/fork/1275177)** for you. This next set of coding problems is shorter, so try it now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.02178,
     "end_time": "2020-10-01T01:21:26.679715",
     "exception": false,
     "start_time": "2020-10-01T01:21:26.657935",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Have questions or comments? Visit the [Learn Discussion forum](https://www.kaggle.com/learn-forum/161283) to chat with other Learners.*"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  },
  "learntools_metadata": {
   "lesson_index": 4,
   "type": "tutorial"
  },
  "papermill": {
   "duration": 6.179388,
   "end_time": "2020-10-01T01:21:26.809120",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2020-10-01T01:21:20.629732",
   "version": "2.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}