B10 Badge - Repeating things with Loops v1.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B10 Badge: Repeating things with Loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning objectives:\n",
    "\n",
    "At the end of this badge you will know:\n",
    "\n",
    "- Use `For things In things` loop to repeat code for each item of a collection.\n",
    "- Perform some basic tasks with loops.\n",
    "\n",
    "### 🔜 SPOILER ALERT:\n",
    "\n",
    "\n",
    "You will also understand these lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for word in [\"pinapple\", \"apple\", \"kiwi\", \"pear\"]:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = [\"pinapple\", \"apple\", \"kiwi\", \"pear\"]\n",
    "for word in words:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def does_list_contain_word_banana(words):\n",
    "    for word in words:\n",
    "        if word == \"banana\":\n",
    "            return True \n",
    "    # And if after checking every word with the loop you still found nothing, then...\n",
    "    return False\n",
    "\n",
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"kiwi\", \"pear\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 🎯 End of learning objectives 🎯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are loops good for? Surviving in the world of changing requirements, is one thing.\n",
    "\n",
    "## Let's imagine a following scenario:\n",
    "\n",
    "Imagine you have a very fickle client who keeps changing their mind. You will be presented with a number of versions of what they are asking you to program, and you will see the process of writing code to meet the changing requirements. \n",
    "\n",
    "The process will be always:\n",
    "\n",
    "- Understand what we are asked to do.\n",
    "- Write some code which does it.\n",
    "- See if we can make the code prettier or more efficient.\n",
    "- Repeat...\n",
    "\n",
    "**Version 01: Print a word \"Monday\" 5 times**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imagine you'd want to print a word many times:\n",
    "\n",
    "print(\"Monday\")\n",
    "print(\"Monday\")\n",
    "print(\"Monday\")\n",
    "print(\"Monday\")\n",
    "print(\"Monday\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But that's not very DRY (Don't Repeat Yourself).\n",
    "\n",
    "Imagine the brief has changed and now you are asked to...\n",
    "\n",
    "**Version 02: Print another word instead, e.g. \"Tuesday\"**.\n",
    "\n",
    "You could:\n",
    "\n",
    "- a ) Go up and down your code and replace every \"Monday\" with \"Tuesday\" and just hope for the best. That sounds terrible. You would need to change so many lines of code each time your client changed their mind.\n",
    "\n",
    "OR\n",
    "\n",
    "- b ) Introduce a variable ```day```, set it once at the beginning, and print however many times. Much cleaner. You would only have to change one line of code each time they change their mind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day = \"Tuesday\"\n",
    "print(day)\n",
    "print(day)\n",
    "print(day)\n",
    "print(day)\n",
    "print(day)\n",
    "\n",
    "# Much better - what would it take to turn this into many \"Wednesday\"s?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok so this is better, but now imagine your brief has changed again:\n",
    "\n",
    "**Version 03: Print all working days of the week: \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\"**.\n",
    "\n",
    "Okay let's do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "day0 = \"Monday\"\n",
    "day1 = \"Tueday\"\n",
    "day2 = \"Wednesday\"\n",
    "day3 = \"Thursday\"\n",
    "day4 = \"Friday\"\n",
    "\n",
    "print(day0)\n",
    "print(day1)\n",
    "print(day2)\n",
    "print(day3)\n",
    "print(day4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, our job is done. The code does what we were asked to build. But is there a way to make it prettier? Or more efficient?\n",
    "\n",
    "Now that we know the magic of LISTS, we can simplify that code. \n",
    "\n",
    "It's already a bit better because, if we are asked to add weekends, we'll only have to change the list and add two more prints.\n",
    "\n",
    "💥**JARGON: REFACTORING**: Changing HOW your code does something, without changing WHAT it does. Exactly what we are doing here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\"]\n",
    "\n",
    "print( weekdays[0])\n",
    "print( weekdays[1])\n",
    "print( weekdays[2])\n",
    "print( weekdays[3])\n",
    "print( weekdays[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, but they've just changed their mind again. \n",
    "\n",
    "**Version 04: Also include Saturday and Sunday**.\n",
    "\n",
    "Because we used a list, this is not going to be such a big job. Let's do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "print( weekdays[0])\n",
    "print( weekdays[1])\n",
    "print( weekdays[2])\n",
    "print( weekdays[3])\n",
    "print( weekdays[4])\n",
    "print( weekdays[5])\n",
    "print( weekdays[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh no! They went and changed their minds again:\n",
    "\n",
    "**Version 05: Print each day in a sentence, like \"Monday will be a lovely day\"**.\n",
    "\n",
    "Hmm... we could copy-paste the beginning of that sentence into each print, but that would be very messy and time consuming if/when they change their mind again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "print( weekdays[0], \" will be a lovely day\")\n",
    "print( weekdays[1], \" will be a lovely day\")\n",
    "print( weekdays[2], \" will be a lovely day\")\n",
    "print( weekdays[3], \" will be a lovely day\")\n",
    "print( weekdays[4], \" will be a lovely day\")\n",
    "print( weekdays[5], \" will be a lovely day\")\n",
    "print( weekdays[6], \" will be a lovely day\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It works, but this is so NOT DRY! (Reminder - 'DRY' stands for \"Don't Repeat Yourself\").\n",
    "\n",
    "Instead let's use our new superpowers and refactor this code again. We will change HOW it does something, but not WHAT it does.\n",
    "\n",
    "**FUNCTIONS to the rescue!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we separate the action we want performed:\n",
    "\n",
    "def into_a_sentence(day): \n",
    "    return day + \" will be a lovely day\"\n",
    "\n",
    "# Here we separate the data we want it performed on:\n",
    "\n",
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "# Here, unfortunately, we still need to spell out all these lines:\n",
    "\n",
    "print( into_a_sentence( weekdays[0]) )\n",
    "print( into_a_sentence( weekdays[1]) )\n",
    "print( into_a_sentence( weekdays[2]) )\n",
    "print( into_a_sentence( weekdays[3]) )\n",
    "print( into_a_sentence( weekdays[4]) )\n",
    "print( into_a_sentence( weekdays[5]) )\n",
    "print( into_a_sentence( weekdays[6]) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is missing? An ability to perform a function once for each element in a list!\n",
    "\n",
    "### We call such ability A LOOP."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we are almost at the end of our journey. We separated our code into:\n",
    "    \n",
    "- Data to perform an action for: ```[\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]```\n",
    "- Action to perform: ```print( into_a_sentence( XXXXX ) )```\n",
    "\n",
    "Now we will use the new loop syntax to combine them into one..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we separate the action we want performed:\n",
    "\n",
    "def into_a_sentence(day): \n",
    "    return day + \" will be a lovely day\"\n",
    "\n",
    "# Here we separate the data we want it performed on:\n",
    "\n",
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "# I will explain this syntax in more details below, but try to guess what it does:\n",
    "\n",
    "for weekday in weekdays:\n",
    "    print(into_a_sentence(weekday))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could even simplify it further, but watch out - shorter code IS NOT always better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "\n",
    "for weekday in weekdays:\n",
    "    print(weekday + \" will be a lovely day\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or even:\n",
    "\n",
    "for weekday in [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]:\n",
    "    print(weekday + \" will be a lovely day\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the amount of lines of code we would need to edit to inplement another change in client requierements:\n",
    "\n",
    "- Adding/Removing another day - 1 line of code. (eg. remove Sundays)\n",
    "- Changing the sentence - 1 line of code. (eg. change 'lovely' to 'wonderul')\n",
    "\n",
    "(Don't believe me? You can try it yourself!)\n",
    "\n",
    "Amazing! This code could hardly get any more DRY.\n",
    "\n",
    "**FUTURE-PROOF CODE**: Hopefully you can see how we've dramatically decreased the amount of work we would need to do in response to future changes in the brief. **And in the real-world the brief changes a lot!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax of the For Loop explained - \"for an_item in items\"\n",
    "\n",
    "## Going through a collection (List, Set, Tuple or even a Dictionary) one item at a time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops will often come to our rescue!\n",
    "\n",
    "Loops are one of the core elements of programming. The basic idea is that you want to **repeat some code for each element in a collection**.\n",
    "\n",
    "Just like in our scenario above - we repeated some code, for each item in an collection!\n",
    "\n",
    "When creating a loop we need to specify these components: \n",
    "\n",
    "- What is the **ACTION** that should be repeated for each element (we used a FUNCTION before).\n",
    "- For what **ITEMS** you would like that action performed (we used a LIST before).\n",
    "\n",
    "- Extra: to get these two above elements talking to each other, we will need a way to reference/point to each **INDIVIDUAL ITEM** in the collection as we go through all of them.\n",
    "\n",
    "In **PSEUDO-CODE** - a make-believe programming language where you basically write english sentences - it would look something like this:\n",
    "\n",
    "```\n",
    "I have a COLLECTION of things\n",
    "For each ITEM in the COLLECTION of things:\n",
    "    DO SOMETHING with that ITEM\n",
    "```\n",
    "In Python 'for loop' looks like this:\n",
    "\n",
    "```\n",
    "for temp_name in collection:\n",
    "    some_actions( temp_name )\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "for weekday in weekdays:\n",
    "    print(weekday + \" will be a lovely day\")\n",
    "    \n",
    "# And that's it, just 3 lines :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now when the brief changes, you are ready!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some more examples of using LOOPS to do useful things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print a square of each number between 1 and 6:\n",
    "\n",
    "numbers = [1,2,3,4,5,6] # COLLECTION.\n",
    "for number in numbers: # for ITEM in COLLECTION.\n",
    "    print(number * number) # ACTION."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TEMPORARY VARIABLES FOR ITERATING THROUGH THE COLLECTION**: Notice that we are using a temporary variable ```item```, ```name```, ```day``` to point to the item in the list that we are currently looking at.\n",
    "\n",
    "That temporary variable will in turn take on the value of each item in the list. \n",
    "\n",
    "When the below code is run:\n",
    "\n",
    "```numbers = [1,2,3,4,5,6]\n",
    "for number in numbers:\n",
    "    print(number * number)\n",
    "```\n",
    "\n",
    "The line ```print(number * number)``` will be run 6 times.\n",
    "\n",
    "- The first time it is run, the value in variable number is 1, as if we run ```number = 1``` just before.\n",
    "- The second time it is run, the value in variable number is 2, as if we run ```number = 2``` just before.\n",
    "- The third time it is run, the value in variable number is 3, as if we run ```number = 3``` just before.\n",
    "- ... and so on.\n",
    "\n",
    "When the loop is finished the variable ```number``` becomes irrelevant. It technically still holds the last value that was in it, but it makes no much sense to use it for anything.\n",
    "\n",
    "**In some ways, you could imagine that the computer treats the folllowing three lines of code -**\n",
    "\n",
    "```\n",
    "# Pseudo code: repeat the line print(number * number) 6 times. Once for each number 1,2,3,4,5 and 6:\n",
    "\n",
    "numbers = [1,2,3,4,5,6] # COLLECTION\n",
    "for number in numbers: # for ITEM in COLLECTION\n",
    "    print(number * number) # ACTION\n",
    "```\n",
    "\n",
    "**As if they said:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "number = 1\n",
    "print(number * number)\n",
    "\n",
    "number = 2\n",
    "print(number * number)\n",
    "\n",
    "number = 3\n",
    "print(number * number)\n",
    "\n",
    "number = 4\n",
    "print(number * number)\n",
    "\n",
    "number = 5\n",
    "print(number * number)\n",
    "\n",
    "number = 6\n",
    "print(number * number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**But luckily we can use loops instead of typing all of that!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining loops with other concepts you already know:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GETTING VALUES OUT OF A LOOP - THE BASICS: \n",
    "(We will work on this in greater detail during the Lab)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know from before that printing values (like in the above examples) is something we would only really do when we are learning. Once our code is solving any real problems, our functions will most likely **RETURN** values.\n",
    "\n",
    "Next week we will work much more with loops, but for now we will see just a few ways to interact with a loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**LOOK FOR SOMETHING AND STOP ONCE YOU FOUND IT.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RETURN True / False**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def does_list_contain_word_banana(words):\n",
    "    for word in words:\n",
    "        if word == \"banana\":\n",
    "            return True # If this line is reached, the function will terminate.\n",
    "    return False # This line will only be reached after the 'for loop' iterated over all words, and did not return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"kiwi\", \"pear\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"banana\", \"kiwi\",  \"pear\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it is useful to add some prints inside of your loop for **peeking** inside to understand what is happening as you travel through the loop. \n",
    "\n",
    "PRINTS are just a temporary 'debugging' output, and DO NOT change anything in terms of what the function does and what it returns. \n",
    "\n",
    "See below version of the same function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same code as above, but with one 'debugging print' - it let's us peek inside of the loop.\n",
    "\n",
    "def does_list_contain_word_banana(words):\n",
    "    for word in words:\n",
    "        print(\"for debugging: checking word\",word) # This is optional, to illustrate what's going on inside.\n",
    "        if word == \"banana\":\n",
    "            return True # If this line is reached, the function will terminate.\n",
    "    return False # This line will only be reached after the for loop iterated over all words, and did not return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"kiwi\", \"pear\"]))\n",
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"banana\", \"kiwi\",  \"pear\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add as many prints in there as you'd like, but watch out it stays readable. At some point you will have more prints than the actual code. It's best to delete (or at least comment out) the debugging prints once youre done debugging and your function works as intended. Just to stop littering the print output.\n",
    "\n",
    "Saying that... here's an example where absolutely everything is printed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same code as above, but with some more 'debugging prints':\n",
    "\n",
    "def does_list_contain_word_banana(words):\n",
    "    print(\"words to consider:\",words)\n",
    "    for word in words:\n",
    "        print(\"checking word\",word) # This is optional, to illustrate what's going on inside.\n",
    "        if word == \"banana\":\n",
    "            print(\":) about to terminate. Word found:\",word)\n",
    "            return True # If this line is reached, the function will terminate.\n",
    "        else:\n",
    "            print(\":(\", word, \"was not banana\")\n",
    "    \n",
    "    print(\"finished the loop and went through all of the words. None of them were banana\",words)\n",
    "    return False # This line will only be reached after the for loop iterated over all words, and did not return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\",  \"kiwi\",  \"pear\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(does_list_contain_word_banana([\"pinapple\", \"apple\", \"banana\", \"kiwi\",  \"pear\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RETURN a value from the list you are looping**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_first_word_longer_than_5_characters(words):\n",
    "    for word in words:\n",
    "        if len(word) > 5:\n",
    "            return word # If this line is reached, function will terminate i.e stop running, and return where it came from,\n",
    "    return \"\" # This line will only be reached after the 'for loop' iterated over all words, and did not return.\n",
    "\n",
    "# Note that it is often not obvious what to return if you don't find what you were looking for...\n",
    "# Usually you need to check what the tests tell you to do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(find_first_word_longer_than_5_characters([\"plum\", \"pear\", \"pinapple\", \"banana\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(find_first_word_longer_than_5_characters([\"plum\", \"pear\", \"kiwi\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**RETURN a modified List - AGGREGATION**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def keep_words_longer_than_5_characters(words):\n",
    "    words_to_keep = [] # Start with an empty List.\n",
    "    for word in words:\n",
    "        if len(word) > 5: # If word is longer than 5 characters...\n",
    "            words_to_keep.append(word) # Add it to the aggregated list.\n",
    "    return words_to_keep # Once the loop is finished, return the resulting list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"plum\", \"pear\", \"pinapple\", \"kiwi\", \"fig\",\"lime\", \"lemon\", \"banana\", \"beans\"]\n",
    "print(keep_words_longer_than_5_characters(fruits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Same code, but with some debugging prints:\n",
    "\n",
    "def keep_words_longer_than_5_characters(words):\n",
    "    words_to_keep = [] # Start with an empty list.\n",
    "    for word in words:\n",
    "        print(\"considering word\", word)\n",
    "        if len(word) > 5: # If word is longer than 5 characters...\n",
    "            print( word, \"is long enough\")\n",
    "            words_to_keep.append(word) # Add it to the aggregated list.\n",
    "    print(\"finished the loop. About to return:\", words_to_keep)\n",
    "    return words_to_keep # Once the loop is finished, return the resulting list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"plum\", \"pear\", \"pinapple\", \"kiwi\", \"fig\",\"lime\", \"lemon\", \"banana\", \"beans\"]\n",
    "print(keep_words_longer_than_5_characters(fruits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WARNING: NEVER MODIFY THE LIST YOU ARE CURRENTLY LOOPING THROUGH!\n",
    "\n",
    "It's basically like cutting the branch of a tree that you are sitting on. As the loop is trying to go through all the items and items start vanishing, the loop will get VERY confused and it will cause all sorts of unexpected issues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So this is a very bad idea:\n",
    "\n",
    "def keep_words_longer_than_5_characters_the_wrong_way(words):\n",
    "    for word in words:\n",
    "        print(\"considering word\", word)\n",
    "        if len(word) <= 5: \n",
    "            print( word, \"is too short\")\n",
    "            words.remove(word) # Remove that word, hence shortening the list, and potentially skipping next item.\n",
    "    return words # Once the loop is finished, return the resulting list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"plum\", \"pear\", \"pinapple\", \"kiwi\", \"fig\",\"lime\", \"lemon\", \"banana\", \"beans\"]\n",
    "print(keep_words_longer_than_5_characters_the_wrong_way(fruits))\n",
    "\n",
    "# Read the output and try to figure out what is going wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you see a completely bizarre behaviour of the above function? How it skips some items and not others? You might want to spend some time trying to understand what is going on there, but it is quite complicated.\n",
    "\n",
    "**ONE IMPORTANT THING TO REMEMBER:** Do not change the list you are looping through. If you need to add to it, or remove from it, you should just create a new list and add/remove from there."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What have you learned in this session: Three stars and a wish. \n",
    "**In your own words** write in your Learn diary:\n",
    "\n",
    "- 3 things you would like to remember from this badge.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Minitask: Try to predict what will the code below will do. Then run it and modify it to do something else.\n",
    "\n",
    "\n",
    "Before you run these cells, read the code examples and try to describe what they do. Once you know, run them and see if you were right. Then modify the functions to do something slightly different e.g. perform another math operation, or print another set of words.\n",
    "\n",
    "**Note: Usually our functions return stuff, but technically they are allowed to not do that. If we are doing something just for practice, it's okay to just print from the functions, and watch what is happening.**\n",
    "\n",
    "Task: modify all of the below 3 code samples to do something else, your choice what."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_squares_of_numbers(numbers):\n",
    "    for number in numbers:\n",
    "        print(number * number)\n",
    "    \n",
    "all_numbers = [1,2,3,4,5]\n",
    "print_squares_of_numbers(all_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_each_word_with_ending(list_of_words, words_to_put_the_end):\n",
    "    for word in list_of_words:\n",
    "        print(word, words_to_put_the_end)\n",
    "    \n",
    "words = [\"Nicky\",\"Jill\",\"Xi\",\"Vanya\"]\n",
    "ending = \"is in the room\"\n",
    "\n",
    "print_each_word_with_ending(words, ending )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_numbers_larger_than(numbers, larger_than_this):\n",
    "    for number in numbers:\n",
    "        if number > larger_than_this:\n",
    "            print(number)\n",
    "    \n",
    "all_numbers = [1,2,3,4,5,6,7,8]\n",
    "print_numbers_larger_than(all_numbers, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: it is very rare for functions to print things, rather than returning them. How would you change above functions so that they return their result instead of printing it?\n",
    "\n",
    "It's sometimes not obvious because you can return only one thing. So you might need to 'assemble a list' and then return that. You'll learn about this in the next badge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example: first function returning rather than printing:\n",
    "def squares_of_numbers(numbers):\n",
    "    squares = []\n",
    "    for number in numbers:\n",
    "        squares.append(number * number)\n",
    "    return squares # don't forget this line! Otherwise your function will just return 'None' \n",
    "    \n",
    "all_numbers = [1,2,3,4,5]\n",
    "squared_numbers = squares_of_numbers(all_numbers)\n",
    "print(squared_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Bonus (harder) Minitask: Try to write loops to do something to a list of values.\n",
    "\n",
    "Write 2 or 3 functions that use loops. They will take a list of items and return one of them or a new list with some of them. It's up to you to find some scenarios.\n",
    "\n",
    "This is hard, hence it's a bonus task. We'll learn how to do it in a future badge.\n",
    "\n",
    "Here's some possible inspiration:\n",
    "\n",
    "- Given a list of numbers, return just the positive ones.\n",
    "- Given a set of words, return a simpler list, just with the words starting with a letter 'a' (see example below on how to capture the first letter in a word).\n",
    "- Given a list of words, and a 'searched_word', count how many times 'searched_word' appears in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Small spoiler alert. We will learn more about strings soon, meanwhile here's a cool trick:\n",
    "# You can use a STRING as if it was a LIST of characters. \n",
    "# Indeed 'string' stands for a string (line, group) of characters.\n",
    "\n",
    "fruit = \"banana!\"\n",
    "print(fruit[0])\n",
    "print(fruit[1])\n",
    "print(fruit[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if fruit[0] == \"c\":\n",
    "    print(fruit, \"starts with c\")\n",
    "else:\n",
    "    print(fruit, \"does not start with c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}