Lesson 4.2: For Loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for Loops\n",
    "\n",
    "A “for-loop” allows you to iterate (go over) over a collection of items, and execute a block of code once for each item in that collection. \n",
    "\n",
    "    for item in collection:\n",
    "        do some stuff with item\n",
    "\n",
    "This collection has to be an <b>ITERABLE OBJECT</b>, so what is an iterable object (an object that we can iterate over)? There are two words that we need to understand: iterable + object.\n",
    "\n",
    "<code>Object</code>: we will discuss this later in Object-Oriented Programming. In short, an object is an instance of a class. To make it simpler: if string is a class, then a string object will be any string such as 'Nam', 'Redi School NRW', 'I love Python', etc. Another example: if integer is a class, then any integer such as -6, 5, 20 will be an integer object. \n",
    "\n",
    "<code>iterable</code>: iterate + -able -> can iterate -> the object is made of multiple items. The object allows us to go through each item one by one. Example: the string 'Digitalization' is an iterable subject, it consists of 14 letters and we can iterate over each letter as in the following example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "i\n",
      "g\n",
      "i\n",
      "t\n",
      "a\n",
      "l\n",
      "i\n",
      "z\n",
      "a\n",
      "t\n",
      "i\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for character in 'Digitalization':\n",
    "    print(character)"
   ]
  },
  {
   "attachments": {
    "for-loop-python.jpg": {
     "image/jpeg": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![for-loop-python.jpg](attachment:for-loop-python.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *range* function can be used in for loops to generate integer numbers from 0 up to (and not including) a given number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for number in range(4):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also pass two numbers:\n",
    "1.   the first one will be the beginning of the sequence (included)\n",
    "2.   the second one will be the end of the sequence (not included)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "squared of 3 is 9\n",
      "squared of 4 is 16\n",
      "squared of 5 is 25\n",
      "squared of 6 is 36\n",
      "squared of 7 is 49\n",
      "squared of 8 is 64\n",
      "squared of 9 is 81\n"
     ]
    }
   ],
   "source": [
    "for number in range(3,10): #the range object contains 3,4,5,6,7,8 and 9\n",
    "    print(\"squared of\", number, 'is', number**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: we can combine a for loop with if statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not heavy\n",
      "heavy\n",
      "not heavy\n",
      "not heavy\n",
      "not heavy\n",
      "heavy\n",
      "heavy\n",
      "heavy\n",
      "not heavy\n",
      "heavy\n"
     ]
    }
   ],
   "source": [
    "list_of_weights = [51,62,39,45,59,63,79,80,59,100]\n",
    "for weight in list_of_weights:\n",
    "    if weight <= 60:\n",
    "        print('not heavy')\n",
    "    else:\n",
    "        print('heavy')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: I give you a list of numbers and want you to print our only the odd numbers,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now  how do you solve this problem? <br> Detailed info about list as a compound data type will be taught later. For now, think of a list as ..... a list of items, which opens and ends with square brackets [] and has each item seperated by a comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tool = modulo. The modulo operation allows us to get the remainder in a division and uses the % symbol. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "57 % 5 #57 divided by 5 is 11 remainder 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "31 % 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_numbers = [11,23,54,23,24,67,80,34,56]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "odd number:  11\n",
      "odd number:  23\n",
      "odd number:  23\n",
      "odd number:  67\n"
     ]
    }
   ],
   "source": [
    "for number in list_of_numbers:\n",
    "    if number % 2 == 1:\n",
    "        print('odd number: ', number) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also we can implement a <code>+=</code> to perform the addition towards the sum so that the code will be shorter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "list_sum = 0 \n",
    "for number in list_of_numbers:\n",
    "    list_sum += number\n",
    "print(list_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5: A for loop can exist within another for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I want you to print the following pattern using for loop(s). How do you approach this problem? <br>\n",
    "    1 <br>\n",
    "    1 2 <br>\n",
    "    1 2 3 <br>\n",
    "    1 2 3 4 <br>\n",
    "    1 2 3 4 5 <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "last_number = 6\n",
    "for row in range(1, last_number):\n",
    "    for column in range(1, row + 1):\n",
    "        print(column, end=' ') #by default, print goes to the next line\n",
    "    print('') #doesn't matter here, but you need to print sth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "Accept a number from user and calculate the PRODUCT of all number from 1 to a given number (factorial, denoted in Maths by !) <br>\n",
    "Example: 4! = 1 * 2 * 3 * 4 = 24. Try to use for loops instead of the factorial() function in the math library =))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the following pattern using for loop(s): <br>\n",
    "    5 4 3 2 1 <br>\n",
    "    4 3 2 1 <br>\n",
    "    3 2 1 <br>\n",
    "    2 1 <br>\n",
    "    1  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hint: \n",
    "when we write range(3,8), we actually mean range(3,8,1): going from 3 to 7 with each step-size of 1 (so 3,4,5,6,7) <br>\n",
    "If I write range(3,8,2), it means going from 3 to 7 with each step-size of 2 (so 3,5,7) <br>\n",
    "If you want to go backward like 7,6,5,4,3 ---> the stepsize is -1 --> range(7,2,-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a Python program to count the number of even and odd numbers from a series of numbers <br>\n",
    "Example: input = (1, 2, 3, 4, 5, 6, 7, 8, 9) <br>\n",
    "Expected Output : <br>\n",
    "Number of even numbers : 5 <br>\n",
    "Number of odd numbers : 4 <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}