4_python_for_loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "19464cb9",
   "metadata": {},
   "source": [
    "# Python For Loops\n",
    "\n",
    "Practice exercises for for using loops with Python.\n",
    "\n",
    "## Prerequisites\n",
    "\n",
    "In order to complete these exercises, you should know how to:\n",
    "- Create variables\n",
    "- Use print statements (to print strings and variables)\n",
    "- Use basic mathematic operators (`+`, `-`, `*`, `/`, `%` etc.)\n",
    "- Use relational operators ( `>`, `<`, `==`, `>=`, `<=`, `!=`)\n",
    "- Use logical operators (`and`, `or`, `not`)\n",
    "- Create functions\n",
    "- Use if, else and elif statements\n",
    "- Use for loops\n",
    "- Use while loops\n",
    "- Use range()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec93de1",
   "metadata": {},
   "source": [
    "## For loops with strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd4a4e66",
   "metadata": {},
   "source": [
    "### Exercise 0\n",
    "\n",
    "Write Python code which takes a word as user input. It prints then prints out every occurence of the letter \"a\" in the word. Use a for loop.\n",
    "\n",
    "For the word \"amazing\" it should print:\n",
    "\n",
    "```\n",
    "a\n",
    "a\n",
    "```\n",
    " \n",
    "#### Going further 1\n",
    "\n",
    "Modify your code so that every time it finds a character that is not \"a\" it prints \"<character> is not a\"\n",
    "\n",
    "For the word \"amazing\" it should print:\n",
    "\n",
    "```\n",
    "a\n",
    "m is not a\n",
    "a\n",
    "z is not a\n",
    "i is not a\n",
    "n is not a\n",
    "g is not a\n",
    "```\n",
    "\n",
    "#### Going further 2\n",
    "\n",
    "Modify your code again so that for the word \"amazing\" it prints:\n",
    "\n",
    "```\n",
    "Letter 1 is a\n",
    "Letter 2 is not a\n",
    "Letter 3 is a\n",
    "Letter 4 is not a\n",
    "Letter 5 is not a\n",
    "Letter 6 is not a\n",
    "Letter 7 is not a\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99d155fb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "08486267",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "Write Python code which takes a word as user input, and prints the length of the word. Use a for loop to find the length.\n",
    "\n",
    "Hint: You need to initiate a variable outside the loop, which will be modified inside the loop to count the letters.\n",
    "\n",
    "#### Going further 1\n",
    "Put the code into a function `get_length()` which takes a word as an argument (no user input), and returns the length of the word. It does not print anything.\n",
    "\n",
    "#### Going further 2\n",
    "Modify the function so that it takes two arguments: a word and a character. As well as returning the length of the word, it also returns a count of how many times the character is in the word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "974f3d69",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5cc9cee9",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Write a Python code which takes a word as user input. It replaces every occurence of the letter e with an \"!\" character, and prints the modified word. For 'elephant' it should print '!l!phant'\n",
    "\n",
    "Hint: Try using += on a string variable. What does it do?\n",
    "\n",
    "#### Going further 1\n",
    "Put the code into a function `replace_e()` which takes a word as an argument (no user input). It replaces every occurence of the letter e with an \"!\" character, and returns the modified word. For 'elephant' it should return '!l!phant'. It does not print anything.\n",
    "\n",
    "#### Going further\n",
    "Can your function recognse capital letters as valid occurences of the letter e? If not, make sure it does. Hint: use an inbuilt string function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0091c8c6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e2a71faf",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Write a Python function which takes a word as user input and prints its reverse. For \"elephant\" it should return \"tnahphele\". \n",
    "\n",
    "Hint: Similar to the previous exercises, you need to:\n",
    "- initiate an empty variable outside the loop, which will be modified in the loop and hold the reversed word\n",
    "- use `+` on a string variable to build the reversed word\n",
    "\n",
    "\n",
    "### Going further\n",
    "\n",
    "Put your code into a function `reverse()` which takes a word and returns its reverse (no user input or printing). For \"elephant\" it should return \"tnahphele\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36e6237d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b2b0cf35",
   "metadata": {},
   "source": [
    "## For loops with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09b6566e",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Complete the Python code below, so that the sum of all the numbers in the pre-defined list variable is calculated and printed. Use a for loop to calculate the sum.\n",
    "\n",
    "For the list `[5, 1, 6, 2, 3, 19]` it should print `36`. Check that when you change the numbers in the list variable, it still works.\n",
    "\n",
    "#### Going further 1\n",
    "\n",
    "Modify your code so that it is a function `sum_list()` which takes a list of numbers as an argument and returns the sum of all the numbers in the list. Use a for loop to calculate the sum.\n",
    "\n",
    "For the list `[5, 1, 6, 2, 3, 19]` it should return `36`\n",
    "\n",
    "#### Going further 2\n",
    "\n",
    "Modify the function so that as well as the sum, it also calculates and returns the average number, and the highest number. For the list above, the average number is 6 and the highest is 19, so it should return `(36, 6, 19)`. Do not use any inbuilt Python functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "268056d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [5, 1, 6, 2, 3, 19]\n",
    "\n",
    "## YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82c9e767",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27ea9033",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "Complete the Python code below, so that every **even** number from the pre-defined list variable is printed. It should also print two more things: a count of how many even numbers are in the list, and a count of how many odd numbers are in the list.\n",
    "\n",
    "For the list `[5, 1, 6, 2, 3, 19]` it should print:\n",
    "\n",
    "```\n",
    "6\n",
    "2\n",
    "\"There are 2 even numbers\"\n",
    "\"There are 4 odd numbers\"\n",
    "```\n",
    "\n",
    "Use a for loop.\n",
    "\n",
    "### Going further\n",
    "\n",
    "Modify your code so that it is a Python function `even_odd()` which takes a list of numbers as an argument and prints out every **even** number from the list. It also returns two numbers: a count of how many even numbers are in the list, and a count of how many odd numbers are in the list.\n",
    "\n",
    "For the list `[5, 1, 6, 2, 3, 19]` it should return `(2, 4)` and print:\n",
    "\n",
    "```\n",
    "6\n",
    "2\n",
    "```\n",
    "\n",
    "Use a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3865127e",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [5, 1, 6, 2, 3, 19]\n",
    "\n",
    "## YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec535c8c",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "\n",
    "Complete the Python code below so that it prints the number of words in the list, and the number of times the letter \"e\" appears in all the words. Do not use any inbuilt functions. Hint: you may need two loops.\n",
    "\n",
    "For `['elephant', 'monkey', 'emu', 'crocodile', 'tiger']` it should print :\n",
    "\n",
    "`There are 5 words in the list`\n",
    "`The letter e appears 6 times`\n",
    "\n",
    "### Going further\n",
    "\n",
    "Modify your code so that it is a function `analyse_words()` which takes a list of strings as an argument and returns two things: the number of words in the list, and the number of times the letter \"e\" appears in all the words. It does not print anything.\n",
    "\n",
    "For `['elephant', 'monkey', 'emu', 'crocodile', 'tiger']` it should return `(5,6)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1793c2af",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['elephant', 'monkey', 'emu', 'crocodile', 'tiger']\n",
    "\n",
    "## YOUR CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39fc9a8d",
   "metadata": {},
   "source": [
    "## For loops with range()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56076ccc",
   "metadata": {},
   "source": [
    "### Exercise 7\n",
    "\n",
    "Below is python code using a while loop. Rewrite it using a for loop. Ensure it has the same output as the original code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cf2c5134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The square of 0 is 0\n",
      "The square of 1 is 1\n",
      "The square of 2 is 4\n",
      "The square of 3 is 9\n",
      "The square of 4 is 16\n",
      "The square of 5 is 25\n",
      "The square of 6 is 36\n",
      "The square of 7 is 49\n",
      "The square of 8 is 64\n",
      "The square of 9 is 81\n"
     ]
    }
   ],
   "source": [
    "i = 0  \n",
    "  \n",
    "while (i<10):  \n",
    "    print(\"The square of\", i, \"is\", i*i)\n",
    "    i+=1  \n",
    "    \n",
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ba7556",
   "metadata": {},
   "source": [
    "### Exercise 8\n",
    "\n",
    "Write Python code that takes two integer values as user input, which represent a range. Print an error message if the second value is not greater than the first. Otherwise, use a loop to calculate and print the sum of the integers in that range.\n",
    "\n",
    "When the values are `2` and `7`, the calculation will be `2 + 3 + 4 + 5 + 6 = 20`, it should print `The sum of this range is 20`.\n",
    "\n",
    "Hint: when passing two arguments to range(), the first represents the start of the range, and the second indicates that the range stops before this number. \n",
    "\n",
    "### Going further\n",
    "\n",
    "Modify your code to create a function `range_sum()` that takes two integer values as arguments, which represent a range. There is no user input. Print an error message if the second value is not greater than the first. Otherwise, use a loop to calculate and return the sum of the integers in that range.\n",
    "\n",
    "When called with the values `2` and `7`, the calculation will be `2 + 3 + 4 + 5 + 6 = 20`, so the function should return `20`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5393aa66",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "31101c21",
   "metadata": {},
   "source": [
    "### Exercise 9\n",
    "\n",
    "\n",
    "Write Python code that receives a number from user input, and then prints a countdown based on that number. For an input of `5` it should print:\n",
    "\n",
    "```\n",
    "Counting down...\n",
    "5\n",
    "4\n",
    "3\n",
    "2\n",
    "1\n",
    "Go!\n",
    "```\n",
    "\n",
    "Hint: when passing three arguments to range(), the third argument represents the step size:\n",
    "`range(0,10,2)` gives a range of `0, 2, 4, 6, 8`\n",
    "`range(10,0,-2)` gives a range of `10, 8, 6, 4, 2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64ed82f8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0c4d8e57",
   "metadata": {},
   "source": [
    "### Exercise 10\n",
    "\n",
    "Write Python code that receives a whole number from user input, and prints its factorial. The factorial is defined as follows:\n",
    "\n",
    "```\n",
    "n * (n - 1) * (n-2) * (n-3) * ... * (1).\n",
    "\n",
    "```\n",
    "\n",
    "The factorial of 7, for example, is:\n",
    "\n",
    "```\n",
    "7 * 6 * 5 * 4 * 3 * 2 * 1 = 5040\n",
    "```\n",
    "\n",
    "For an input of 7, it should print `The factorial of 7 is 5040`\n",
    "\n",
    "Note that there is a special case: the factorial of 0 is 1.\n",
    "\n",
    "Call your function **calculate_factorial()**\n",
    "\n",
    "### Going further\n",
    "\n",
    "Rewrite your code as a function that receives the whole number as an argument, and prints its factorial. Name your function **calculate_factorial()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acb72972",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27979cd5",
   "metadata": {},
   "source": [
    "## Nested for loops with range()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0bc19e8",
   "metadata": {},
   "source": [
    "### Exercise 11\n",
    "\n",
    "Write Python code that takes a whole number from user input, and then based on that number uses nested loops to print the following pattern. When receiving an input of `5`, it should print:\n",
    "\n",
    "```\n",
    "1\n",
    "12\n",
    "123\n",
    "1234\n",
    "12345\n",
    "```\n",
    "\n",
    "*Note: to tell a print statement not to print a new line at the end of itself, use an end argument as follows: `print(\"hello\", end=\"\")`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97ee9df6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d581b44f",
   "metadata": {},
   "source": [
    "### Exercise 12\n",
    "\n",
    "Write Python code that takes a whole number from user input, and then based on that number uses nested loops to print the following asterisk triangle pattern. When receiving an argument of `5`, it should print:\n",
    "\n",
    "```\n",
    "    *\n",
    "   **\n",
    "  ***\n",
    " ****\n",
    "*****\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaef32c4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "85b56cb2",
   "metadata": {},
   "source": [
    "### Exercise 13\n",
    "\n",
    "Write python code that prints the following table showing the results of multiplying each row and colum header. Pay attention to the alignment of the numbers.\n",
    "\n",
    "```\n",
    "1   2   3   4   5   6   7   8   9   \n",
    "2   4   6   8   10  12  14  16  18  \n",
    "3   6   9   12  15  18  21  24  27  \n",
    "4   8   12  16  20  24  28  32  36  \n",
    "5   10  15  20  25  30  35  40  45  \n",
    "6   12  18  24  30  36  42  48  54  \n",
    "7   14  21  28  35  42  49  56  63  \n",
    "8   16  24  32  40  48  56  64  72  \n",
    "9   18  27  36  45  54  63  72  81  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "284cf690",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8cdbfd5d",
   "metadata": {},
   "source": [
    "## For loops with range() and break/continue"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a52ae9bf",
   "metadata": {},
   "source": [
    "### Exercise 14\n",
    "\n",
    "Write a python function that receives a whole number as an argument, and then based on that number prints out only the even numbers in the range from 0 to that number. Use a `continue` statement to achieve this. Also, use a `break` statement to avoid printing any numbers higher than 10, and print out an appropriate message.\n",
    "\n",
    "For an argument of `13`, the output should be as follows:\n",
    "\n",
    "```\n",
    "2\n",
    "4\n",
    "6\n",
    "8\n",
    "10\n",
    "Exiting\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c73d6262",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}