3_control_structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three basic types of control structures; sequential, selection and iteration. They can be combined in any way to solve specified problems.\n",
    "\n",
    "* **Sequential** These are commands which are run after each other as in scripting. We will not conver this here as it's self explanatory. An example would be: \n",
    "```\n",
    "print('I'm first!')\n",
    "print('I'm second...')\n",
    "```\n",
    "\n",
    "* **Selection** This deterimes if something should happen by asking a question. The most basic and common is the \"if\" statement. The \"if\" and \"if/else\" statements can be nested.\n",
    "\n",
    "* **Iteration** The iteration or repetition of code repeatedly executing a series of statements as long as the condition is true. The condition may be predefined or open-ended."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selection Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also known as a conditional structure, a selection structure is a programming feature that performs different processes based on whether a boolean condition is true or false. Selection structures use relational operators to test conditions. There are different types of selection structures that can be used to achieve different outcomes.\n",
    "\n",
    "* If you want your program to do something if a condition is true, but do nothing if that condition is false, then you should use an `if` structure.\n",
    "* If you want your program to do something if a condition is true and do something different if it is false, then you should use an `if-else` structure.\n",
    "* If you want to test multiple conditions, then you can include an `if-elif` structure within an `if` or `if-else` structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` selection structures are used when only one boolean condition is necessary. In `if` structures, a process will be only be performed if the boolean condition is true. They have the following form:\n",
    "```\n",
    "if some_condition:\n",
    "    do_something\n",
    "```\n",
    "An example would be to print _Hello_ if `x` is greater than 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12\n",
    "if x > 10:\n",
    "    print('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If-else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if-else` selection structures are used when only one boolean condition is necessary. In `if-else` structures, a specific action will be performed if the boolean condition is true and another action, if the condition is false. They have the following form:\n",
    "```\n",
    "if some_condition:\n",
    "    do_something_on_true\n",
    "else:\n",
    "    do_something_on_false\n",
    "```\n",
    "An example would be to print _Hello_ if `x` is greater than 10 or _World_ otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12\n",
    "if x > 10:\n",
    "    print('Hello')\n",
    "else:\n",
    "    print('World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if-elif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if-elif` structures are a way to combine multiple boolean conditions into a single selection structure. They have the form:\n",
    "\n",
    "```\n",
    "if some_condition:\n",
    "    do_something_on_true\n",
    "elif some_other_condition:\n",
    "    do_something_else_on_true\n",
    "else:\n",
    "    do_something_on_false\n",
    "```\n",
    "An exmaple would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print('x > y')\n",
    "elif x < y:\n",
    "    print('x < y')\n",
    "else:\n",
    "    print('x = y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If statement inside a `if` statement or `if-elif` or `if-else` are called as **nested if** statements. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 12\n",
    "if x > y:\n",
    "    print('x > y')\n",
    "elif x < y:\n",
    "    print('x < y')\n",
    "    if x == 10:\n",
    "        print('x = 10')\n",
    "    else:\n",
    "        print('Invalid')\n",
    "else:\n",
    "    print('x = y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iteration is the repetition of a process in order to generate a (possibly unbounded) sequence of outcomes. The sequence will approach some end point or end value. Each repetition of the process is a single iteration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `for` loop has the ability to iterate over the items of any sequence, such as a list or a string. It has the structure:\n",
    "\n",
    "```\n",
    "for iterating_var in sequence:\n",
    "   do_something\n",
    "```\n",
    "\n",
    "If a sequence contains an expression list, it is evaluated first. Then, the first item in the sequence is assigned to the iterating variable `iterating_var`. Next, the statement block is executed. Each item in the list is assigned to `iterating_var`, and the `do_something` block is executed until the entire sequence is exhausted.\n",
    "\n",
    "For example, printing all numbers between 0 and 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, `i` iterates over the 0,1,2,3,4. Every time it takes each value and executes the statement inside the loop. It is also possible to iterate over a nested list illustrated below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for list1 in list_of_lists:\n",
    "        print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A use case of a nested for loop in this case would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for list1 in list_of_lists:\n",
    "    for x in list1:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`while` loops are useful when programming for scenarios where it is unknown how many times the code should execute. The conditions within while loops are tested using relational operators. They have the form:\n",
    "\n",
    "```\n",
    "while some_condition:    \n",
    "    do_something\n",
    "```\n",
    "\n",
    "It should be noted that the `some_condition` should depend on somethingin the loop. Otherwise `do_something` will be repeated without end!\n",
    "\n",
    "An example would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 3:\n",
    "    print(i ** 2)\n",
    "    i = i + 1\n",
    "print('Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the name says. It is used to break out of a loop when a condition becomes true when executing the loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(100):\n",
    "    print(i)\n",
    "    if i >= 7:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This continues the rest of the loop. Sometimes when a condition is satisfied there are chances of the loop getting terminated. This can be avoided using continue statement. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    if i > 4:\n",
    "        print('The end.')\n",
    "        continue\n",
    "    elif i < 7:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python makes it simple to generate a required list with a single line of code using list comprehensions. For example If i need to generate multiples of say 27 I write the code using for loop as,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = []\n",
    "for i in range(1, 11):\n",
    "    x = 27*i\n",
    "    res.append(x)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since you are generating another list altogether and that is what is required, List comprehensions is a more efficient way to solve this problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[27*x for x in range(1, 11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it!. Only remember to enclose it in square brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understanding the code, The first bit of the code is always the algorithm and then leave a space and then write the necessary loop. But you might be wondering can nested loops be extended to list comprehensions? Yes you can."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[27*x for x in range(1, 20) if x <= 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let me add one more loop to make you understand better, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[27*z for i in range(50) if i == 27 for z in range(1, 11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We have a themometer which reports the `temperature`. Write an `if` selection structure to tell us to put a coat on if it's below `10`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now add to this code to suggest it's t-shirt weather if the `temperature` is more than `24` using an `if-else` structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now convert this to an `if-elif` to tell us we can wear what we want if the `temperature` is greater than 10 and less than 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use the built in `range` function to generate a list from 1-12 which will be the `months` of the year "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = 'Your code here'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Use a `for` loop to iterate over the `months` of the year printing **It is month `month`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The average monthly temperatures in Lund for 2019 were:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = [-1, 0, 0, 5, 11, 16, 17, 16, 13, 8, 4, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a built in function `zip` which allows you to itterate over two lists at once giving the corresponding item at a position in both iterators. it has the form:\n",
    "\n",
    "```\n",
    "for item1, item2 in zip(list1, list2):\n",
    "```\n",
    "\n",
    "* Use `zip` to iterate over months and temperatures to print **It is month `month` and temperature `temperature`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining Iteration structures and selection structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use your final code for the selection structure questions and insert it into the final code for the iteration questions. \n",
    "\n",
    "You will have to:\n",
    "* Modify the t-shirt temperature to fit to the Lund climate.\n",
    "You want each iteration of months to produce the statement:\n",
    "\n",
    "_It is month `month` and temperature `temperature`.\n",
    "Wear this item of clothes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -- YOUR CODE HERE --\n",
    "# --------------------"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}