ipynb/Iterators and range in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this post, we will mainly discuss iterator and range function. we have been using them previously this time we'll go in depth. Let's first talk about iterator and iterable object in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterator and Iterable object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An iterator is an object that represents a stream of data in order words an iterator is an object that you can traverse one element at a time. Any object that supports iteration is called iterable and so far we have seen some iterable objects like string and list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_string = \"0123456789\"\n",
    "some_list = [\"burundi\",\"kenya\",\"rwanda\",\"uganda\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for char in some_string:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "burundi\n",
      "kenya\n",
      "rwanda\n",
      "uganda\n"
     ]
    }
   ],
   "source": [
    "for country in some_list:\n",
    "    print(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have already seen this, in these examples above we are going through all the elements in the string and in the list one-by-one. What is actually happening is that there is an iterator that is created behind the scene by the for loop and uses it to return each element in the string or list (iterable) and when there is no more element left. An error will be raised and handled by the for loop and the loop will terminate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see clearly what is going on here, let's create our own iterable using the iter( ) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<str_iterator object at 0x1083c1f60>\n"
     ]
    }
   ],
   "source": [
    "interable_string = iter(some_string)\n",
    "print(interable_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result shows that we have created an iterable object and the numbers show the address where that iterable is located in memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now how can we print the elements found in the iterable? We use the next( ) function to print each element one at the time in sequential order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(next(interable_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have printed the first element in the string, to print the following element, we have to re-write it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(next(interable_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically, the iter() goes to each element one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))\n",
    "print(next(interable_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that each time we write the next function, it remembers which element was returned by the previous next function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-0070de267b2a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterable_string\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(next(interable_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After exhausting all the elements in the string will cause the following use of the next function to result in an error, StopIteration error will be raised which means that we have reached the end of the string, there is no more element in the iterable object. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we were using the for loop to iterate, StopIteration error was raised behind the scene and the for loop took care of it for us and exited the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this challenge, we will create a sequence of numerical characters using either string or a list using iter( ) function with the next( ) function to print all the elements in the list/string.\n",
    "\n",
    "We should use for loop to loop \"n\" times through the string/list. \"n\" corresponding to the number of elements found in the list or string.\n",
    "\n",
    "hit: use the len( ) function to get \"n\".\n",
    "\n",
    "Now go ahead and try this challenge on your own and only after you have tried, come back and compare your solution with mine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge Solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember for each solution, there is a multitude of implementation, so your code might look very different than mine but as long as the results are correct, then you good."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "ML_algorithms = [\"CNN\",\"GANs\",\"linear regression\",\"RNN\",\"Random forest\"]\n",
    "ML_algorithms_iter = iter(ML_algorithms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN\n",
      "GANs\n",
      "linear regression\n",
      "RNN\n",
      "Random forest\n"
     ]
    }
   ],
   "source": [
    "for _ in range(len(ML_algorithms)):\n",
    "    print(next(ML_algorithms_iter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we have a list of different machine learning algorithms strings stored in a list, we create its iterator object using iter( ) function and store it in the ML_algorithms_iter variable.\n",
    "\n",
    "Now comes the for loop that will loop as long as we have not exceeded the number of elements found in the list using the len( ) and the range( ) function. We will print each element of the list one by one using the next( ) function. No StopIteration error will be raised(encountered) because we have not gone beyond the number of elements found in the list thanks to the range function.\n",
    "\n",
    "Another thing here to mention is the use if _ as count variable of the for the loop. As a convention in Python, we use _ instead of \"i\" or \"j\" when we ain't using this variable inside the loop. the _ variable acts like a placeholder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the point here is to show you how iterator works and what is really going on behind the scene when we are using. This is by no mean \"the\" way of writing a for loop, you should write it without the iter( ) and next( ) as we did before since everything is being taken care for us. We will see how iterator are useful when we will be creating our own iterator classes and using generators in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have been using range in the for loop, let's take a deep dive into it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have already seen, a range function has a start, stop and step value as parameters in this format: range(start, stop, step). If only one value is passed as a parameter, it will be considered as the stop value. Remember the range function is an exclusive function this means that if we write range(21), the count will stop at value 20."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a list constructor to generate a range of elements like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_num = list(range(21))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
     ]
    }
   ],
   "source": [
    "print(list_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "even = list(range(0,20,2))\n",
    "odd = list(range(1,20,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the even numbers are: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n",
      "the odd numbers are: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "print(\"the even numbers are: {}\\nthe odd numbers are: {}\".format(even,odd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are creating two lists here, one that contains all the even numbers from 0 to 20 with 2 as step and another one that contains odd numbers starting from 1, stepping by 2 up to 20."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### index and slicing with range function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get an index of a particular character and a character at a particular index in a string/list, we use slicing and index function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = \"abcdefghijklmnopqrstuvwxyz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(alpha.index(\"g\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the index function on the string or list, we can get the index at which a particular character is located in the string. If the character is not found, an error will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-a2e48dc282f8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malpha\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"*\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "print(alpha.index(\"*\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a substring of more than one character is used as a parameter, only the first character index is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(alpha.index(\"ghijklmnopq\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So now, what if we have an index but we want to get the character found at that index. We will use slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g\n"
     ]
    }
   ],
   "source": [
    "print(alpha[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "print(alpha[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the range function with slicing and index function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's illustrate this by first creating a range without casting it to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_nums = range(1,1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 1000)\n"
     ]
    }
   ],
   "source": [
    "print(my_nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not what you expected? some might expect to return all elements for 1 to 1000 but remember, we have not cast the range to a list. This is just a range class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n"
     ]
    }
   ],
   "source": [
    "print(type(my_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use the index and the slicing on range."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can access to an index of a certain element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(my_nums.index(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "print(my_nums.index(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the examples above, we check at what position(index) the value 3 and 20 are found in the range."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can access to an element at a certain index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(my_nums[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "print(my_nums[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In these examples above, we are returning the elements at index 0 and 7."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a useful case of using the range function without casting it to a list.\n",
    "Casting it to a list would have been memory inefficient. Let's see another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "mupli_of_seven = range(7,1000,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number between 7 and 1000: 0\n",
      "Please enter a number between 7 and 1000: 44\n"
     ]
    }
   ],
   "source": [
    "num_inputted = 0\n",
    "while num_inputted not in range(7,1001):\n",
    "    num_inputted = int(input(\"Please enter a number between 7 and 1000: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44 is not a multiple of 7\n"
     ]
    }
   ],
   "source": [
    "if num_inputted in mupli_of_seven:\n",
    "    print(\"{} is a multiple of 7\".format(num_inputted))\n",
    "else:\n",
    "    print(\"{} is not a multiple of 7\".format(num_inputted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a range from 7 to 1000 with 7 as the step, this means that we have a range of only multiples of 7 since we are starting from 7\n",
    "\n",
    "After that, we ask the user to input a number between 7 and 1000. The while loop has been added as a test to check if the inputted number is within the range. The inputted number will be cast to int and stored in the variable num_inputted.\n",
    "\n",
    "Now comes the conditional statement, these will check if num_inputted is found in the mupli_of_seven range, if it is or not, the appropriate message will be printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use range at the same time with slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_nums = range(1,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 100, 2)\n"
     ]
    }
   ],
   "source": [
    "print(my_nums[::2])\n",
    "my_nums_step = my_nums[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]\n"
     ]
    }
   ],
   "source": [
    "print(list(my_nums[::2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compare the two ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The two range are equal\n"
     ]
    }
   ],
   "source": [
    "if my_nums_step == range(1,100,2):\n",
    "    print(\"The two range are equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's compare the two ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The two range are equal\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if range(0,5,2) == range(0,6,2):\n",
    "    print(\"The two range are equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two ranges are equal because the two range will return 0,2,4. In the second range, 6 will not be included because as we have already seen the range function is an exclusive function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's cast and print them to see what's going on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(0,5,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(0,6,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use range and slicing in reverse order too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "18\n",
      "16\n",
      "14\n",
      "12\n",
      "10\n",
      "8\n",
      "6\n",
      "4\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for i in range(20,-1,-2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To print in reverse order the range function, the start will be higher than the end and the step will be a negative number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_range = range(0,21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "18\n",
      "16\n",
      "14\n",
      "12\n",
      "10\n",
      "8\n",
      "6\n",
      "4\n",
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for i in the_range[::-2]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first example, we have reversed the order starting from 20 and ending at 0 (that is why we use -1 as stop) and used -2 as step which countdown by 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second example, we exactly doing the same thing just that this time we are using slicing at the same time with the range function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare the two notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The two range are equal\n"
     ]
    }
   ],
   "source": [
    "if range(20,-1,-2) == range(0,21)[::-2]:\n",
    "    print(\"The two range are equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can clearly see that the two ranges are equal, but pay attention to how we wrote the second expression, we started by writing the range function using only the start and the end parameters and then we add a step using slicing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the question that comes next would be when do we need to use slicing in reversed order?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well, let's illustrate this with an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "reversed_string = \"idnuruB fo latipac eht si arubmujuB\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bujumbura is the capital of Burundi\n"
     ]
    }
   ],
   "source": [
    "print(reversed_string[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using slicing we have managed to write a reversed ordered string into its correct order by using -1 as step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "the_nums = range(0,11)\n",
    "for i in the_nums[::-1]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the same with numbers too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This challenge has two main parts\n",
    "- The first part is to print all the multiple to 11 in a reversed order form 100 to 0 using range and slicing at the same time\n",
    "- The second part should ask the user to input a number and check if that number is a multiple of 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now go ahead and try this challenge on your own and only after you have tried, come back and compare your solution with mine."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 88, 77, 66, 55, 44, 33, 22, 11]\n"
     ]
    }
   ],
   "source": [
    "#First part\n",
    "multi_eleven_count = list(range(1,100)[::-11])\n",
    "print(multi_eleven_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number betwee 11 and 100: 22\n",
      "The number inputted is a multiple of 11\n"
     ]
    }
   ],
   "source": [
    "#Second part\n",
    "user_in = int(input(\"Please enter a number betwee 11 and 100: \"))\n",
    "if user_in in multi_eleven_count:\n",
    "    print(\"The number inputted is a multiple of 11\")\n",
    "else:\n",
    "    print(\"The number inputted is not a multiple of 11\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "multi_eleven_count is calculated using the range function that will get back all the number between 1 and 99 and use slicing to step by 11 on all the elements from 1 to 99 which will return all the multiple of 11. After getting the range, we will cast it to a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will compare and see if the user_in is found in the multi_eleven_count list and print the appropriate message accordingly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterable objects are very crucial parts of Python because they are the ones that make a for and while loop through a sequential data type possible. Understanding how they work behind the scene is also important because this will help us to understand how to create our own iterable class in the upcoming post. \n",
    "\n",
    "The range function generates a range of number between a given interval, we can use this range without casting it to a list to save up memory.\n",
    "\n",
    "Thank you for reading this tutorial. Hope you have learned one or two things. If you like this post, please subscribe to stay updated with new posts and if you have a thought or a question, I would love to hear it by commenting below."
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}