Lab03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Basic Programming II\n",
    "\n",
    "In scientific computing, data structures and loops are fundamental tools that enable efficient data management and processing. Here's a brief introduction to their importance:\n",
    "\n",
    "## Loops\n",
    "Loops are a way of implementing **Repetition Control Instruction**. Before we understand what that means, remember that it is ok to make more than one assignment to the same\n",
    "variable. A new assignment makes an existing variable refer to a new value (and stop\n",
    "referring to the old value).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "bruce = 5\n",
    "print(bruce)\n",
    "bruce = 7\n",
    "print(bruce)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of this program is `5 7`, because the first time `bruce` is printed, its value is `5`, and the second time, its value is `7`.\n",
    "\n",
    "One of the most common forms of multiple assignment is an **update**, where the new value of the variable depends on the old."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "\n",
    "print(x)\n",
    "\n",
    "# Get the current value of x, add one, and then update x with the new value\n",
    "x = x+1\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to update a variable that doesn’t exist, you get an error, because **Python evaluates the right side before** it assigns a value to x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[3], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43my\u001b[49m\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "y = y+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before you can update a variable, you have to **initialize** it, usually with a simple assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "y = 3\n",
    "y = y+1\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Updating a variable by adding 1 is called an **increment**; subtracting 1 is called a **decrement**.\n",
    "\n",
    "You can use these concepts to create simple programs that repeat a single set of instructions a certain number of times. However, each time, the results of the execution migh not be the same. This type of procedure is called an **iteration**. \n",
    "\n",
    "Much like an **if-else** block, the instructions that you mean to repeat **must be indented** below the iteration instruction. Let us look at a simple example: The `while` loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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",
      "Finished!\n"
     ]
    }
   ],
   "source": [
    "#Initialize a counting variable\n",
    "n = 10\n",
    "\n",
    "while n > 0:\n",
    "    # Note the indented block below\n",
    "    print(n)\n",
    "    n = n-1\n",
    "\n",
    "print('Finished!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can almost read the `while` statement as if it were English. It means, \n",
    "\n",
    "While `n` is greater than `0`, execute the indented block again and again. That means, do the following \n",
    "\n",
    "1. Display the value of n and then \n",
    "2. **Decrement** the value of n by 1.\n",
    "    \n",
    "When n drops to `0` **or** below `0` (whichever is first), leave the indented block and move on to the next line, in this case, display the word \"Finished!”\n",
    "\n",
    "More formally, a `while` loop is structured like so:\n",
    "\n",
    "```python\n",
    "...\n",
    "...\n",
    "\n",
    "Maybe do an initialization, if necessary\n",
    "\n",
    "while condition:\n",
    "    Do this\n",
    "    Then, do this\n",
    "    ...\n",
    "    ...\n",
    "\n",
    "once !condition, resume from here\n",
    "\n",
    "...\n",
    "\n",
    "```\n",
    "\n",
    "This means:\n",
    "\n",
    "1. Evaluate the condition after the `while`. This must be a logical condition that returns either `True` or `False` as outcome.\n",
    "2. If the condition is `False`, ignore the indented block and continue execution at the next statement.\n",
    "3. If the condition is `True`, execute the body and then go back to step 1.\n",
    "\n",
    "**Note that**, much like `if`, `else` or function `def` statements, the `while` condition **must** end with a colon (:)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The body of the loop should update the value of one or more variables so that eventually the condition becomes `False` and the loop terminates. \n",
    "\n",
    "Otherwise the loop will repeat forever, which is called an **infinite loop**. A simple way to create an infinite loop is to do \n",
    "\n",
    "```python\n",
    "\n",
    "while True:\n",
    "    do_something\n",
    "\n",
    "resume\n",
    "```\n",
    "\n",
    "\n",
    "Since the outcome of the condition is always trivially `True`, it will never reach step 2 and always `do_something` again and again. This can be useful to implement in **event-driven programming**, but we will typically not do that in this course. Let us look at a slightly nontrivial example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "46\n",
      "23.0\n",
      "70.0\n",
      "35.0\n",
      "106.0\n",
      "53.0\n",
      "160.0\n",
      "80.0\n",
      "40.0\n",
      "20.0\n",
      "10.0\n",
      "5.0\n",
      "16.0\n",
      "8.0\n",
      "4.0\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "n = 15\n",
    "\n",
    "while n != 1:\n",
    "    print(n)\n",
    "    if n % 2 == 0: #If n is even\n",
    "        n = n/2\n",
    "    else: #N is odd\n",
    "        n = 3 * n + 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The condition for this loop is `n != 1`, so the loop will continue until `n` is `1`, which makes the condition `False`.\n",
    "\n",
    "Each time through the loop, the program outputs the value of `n` and then checks whether it is even or odd. If it is even, `n` is divided by `2`. If it is odd, the value of `n` is replaced with `3 * n + 1`. For example, if the argument passed to sequence is `3`, the resulting sequence is `3, 10, 5, 16, 8, 4, 2, 1`.\n",
    "\n",
    "Since `n` sometimes increases and sometimes decreases, there is no obvious proof that `n` will ever reach `1`, or that the program terminates. For some particular values of `n`, we can prove termination. For example, if the starting value is a power of two, then the value of `n` will be even each time through the loop until it reaches `1`. \n",
    "\n",
    "Interestingly, this is a famous maths problem called the **Collatz Conjecture**.  The German mathematician, Lothar Collatz, proposed without proof that this sequence always reaches `1` and terminates for any starting integer `n`.\n",
    "\n",
    "As of today, there is no proof of this conjecture. Nonetheless, this simple while loop allows you to numerically test this conjecture for any starting choice of `n`. Choose some starting values, like `15, 20, 27` and see many iterations it takes to reach `1`. Is there a pattern to these iterations? \n",
    "\n",
    "### Exercise 01:\n",
    "What does the following program do ? Put in different values of `start` and find out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 4, Result = 24\n"
     ]
    }
   ],
   "source": [
    "start = 4\n",
    "n = start\n",
    "f = 1\n",
    "while n > 0:\n",
    "    f = f * n\n",
    "    n = n - 1\n",
    "print(f\"n = {start}, Result = {f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 02:\n",
    "\n",
    "A simple way to numerically estimate the square root of a number $a$, given by $\\sqrt{a}$ is the ***Newton-Rhapson*** method. This is an **iterative map**, where you start from an initial guess for the root, say, $x_0$, and put it in a map formula and get a better guess $x_1$, then apply the same formula to get a better guess $x_2$ etc. The map produces a sequence of values $x_0, x_1, x_2, x_3 \\dots x_N$, which should converge to a **fixed point** (beyond which $x_n \\approx x_{n+1} \\approx x_{n+2} \\dots$) whose value is $\\sqrt{a}$. The map formula is \n",
    "\\begin{equation*}\n",
    "x_{n+1} = \\frac{x_n + \\frac{a}{x_n}}{2}\n",
    "\\end{equation*}\n",
    "\n",
    "Write a program to implement this method for a given $a$. \n",
    "\n",
    "**Important Note:** The loop must terminate at the fixed point, where subsequent value of the iteration is **approximately** equal to the running value. Set a relative tolerance of $\\varepsilon = 0.0001$ to make this approximation.\n",
    "\n",
    "<!--\n",
    "```python\n",
    "a = 2\n",
    "\n",
    "x = 1.45\n",
    "x_old = x\n",
    "x_new = 0.5 * (x_old + a/2)\n",
    "x = x_new\n",
    "\n",
    "eps = 0.0001\n",
    "\n",
    "while abs((x_new - x_old)/x_old) > eps:\n",
    "    x_old = x\n",
    "    x_new = (x_old + a/x_old)/2\n",
    "    x = x_new\n",
    "\n",
    "print(f\"sqrt({a}) = {x}\")\n",
    "```-->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists \n",
    "\n",
    "Before we continue with loops, we should discuss the most basic data structure in python, a **list**.\n",
    "\n",
    "A list in Python is an ordered, mutable collection of many items enclosed in square brackets []. A list can be assigned to a variable. A list of $4$ numbers could be\n",
    "\n",
    "```python\n",
    "a = [1,3,8, 76]\n",
    "```\n",
    "\n",
    "Each **element** of this list (the numbers) can be accessed in a manner similar to string characters seen in previous labs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "8\n",
      "76\n"
     ]
    }
   ],
   "source": [
    "a = [1,3,8,76]\n",
    "\n",
    "print(a[0])\n",
    "print(a[1])\n",
    "print(a[2])\n",
    "print(a[3])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can also be sliced ***exactly*** like strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13, 15, 17]\n",
      "[15, 25, 45]\n",
      "[97, 45, 38, 25, 17, 15, 13, 12]\n"
     ]
    }
   ],
   "source": [
    "a = [12, 13, 15, 17, 25, 38, 45, 97]\n",
    "\n",
    "print(a[1:4])\n",
    "print(a[2:8:2])\n",
    "\n",
    "#Lists can also be reversed like strings\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Notabene***: If you take a slice of a list (or string, or tuple) and change it, then the original list is **unaffected**. \n",
    "\n",
    "This is because, when sliced, the slice output is copied to a new place in computer memory, even if it is unreferenced. The original list is this kept pristine. \n",
    "\n",
    "This is different from other iterables like, say, the `NumPy` array, which we will see in later labs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 8.5, 'Whatever this is']\n",
      "[1, 3, 8.5, 'Whatever this is']\n",
      "[8.5, 5]\n"
     ]
    }
   ],
   "source": [
    "a = [1,3,8.5,\"Whatever this is\"]\n",
    "a[1:3][0] = 4 #This assigns the value 4 to the first element of the slice\n",
    "print(a) # However, this will not change the original list\n",
    "\n",
    "y = a[2:4]\n",
    "y[1] = 5 # So I just changed the second element of the slice referenced to the variable 'y'\n",
    "print(a) # This will NOT change the original list either\n",
    "\n",
    "print(y) #However, this will change the slice referenced to the variable 'y'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some key properties of lists\n",
    "\n",
    "1. Ordered: The items in a list have a defined order, and this order will not change unless explicitly modified. That is why we can reference a list element by its ***index***. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 13, 15, 17, 25, 38, 45, 97]\n",
      "38 45\n"
     ]
    }
   ],
   "source": [
    "a = [12, 13, 15, 17, 25, 38, 45, 97]\n",
    "\n",
    "print(a)\n",
    "print(a[5], a[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Mutable: You can change, add, or remove items after the list has been created. This is **not** true for strings, by the way. Strings are **immutable**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 13, 15, 17, 25, 38, 45, 97]\n",
      "[12, 13, 15, 17, 25, 4593, 45, 97]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a[5] = 4593\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Heterogeneous: Lists can contain items of different data types, such as integers, strings, and even other lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "apple\n",
      "[1, 'orange', 3.14, True]\n",
      "[1, 'orange', 3.14, True, 'new item']\n",
      "[1, 'orange', True, 'new item']\n",
      "[1, 'orange', True, 'new item', 1, 'orange', True, 'new item', 1, 'orange', True, 'new item', 1, 'orange', True, 'new item']\n",
      "[1, 'orange', True, 'new item', 4, 'lemon', 2.13, False]\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of mixed data types\n",
    "my_list = [1, \"apple\", 3.14, True]\n",
    "\n",
    "# Accessing elements by index\n",
    "print(my_list[0])  # Output: 1\n",
    "print(my_list[1])  # Output: apple\n",
    "\n",
    "# Modifying an element\n",
    "my_list[1] = \"orange\"\n",
    "print(my_list)  # Output: [1, 'orange', 3.14, True]\n",
    "\n",
    "# Adding a new element\n",
    "my_list.append(\"new item\")\n",
    "print(my_list)  # Output: [1, 'orange', 3.14, True, 'new item']\n",
    "\n",
    "# Removing an element\n",
    "my_list.remove(3.14)\n",
    "print(my_list)  # Output: [1, 'orange', True, 'new item']\n",
    "\n",
    "# Lists can be repeated like strings\n",
    "print(4 * my_list)\n",
    "\n",
    "# Lists can be concatenated like strings\n",
    "\n",
    "my_other_list = [4, \"lemon\", 2.13, False]\n",
    "print(my_list + my_other_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note to C/C++ programmers:\n",
    "You can see that python lists are not quite the same as arrays in C/C++. Arrays are **homogeneous** collections, *i.e.* all the elements are of the same type: `int`, `long`, `float`, `double`, or `char`. In contrast, a python list can contain elements of different types. There is a way to create C-like arrays in python using an external library called `NumPy`. We'll discuss this in a latter lab.\n",
    "\n",
    "\n",
    "### Lists in functions\n",
    "\n",
    "If you pass in any mutable object, say a list, to a function, then you will be able to impact the external world. This is very different from mutable objects like numbers, strings etc. seen in the previous lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outside [7, 14] [-1, -3]\n",
      "inside [7, 15] ['hello', 'bye']\n",
      "outside [7, 15] [-1, -3]\n"
     ]
    }
   ],
   "source": [
    "def f(xs, ys):\n",
    "    xs[1] += 1\n",
    "    ys = [\"hello\", \"bye\"]\n",
    "    print(\"inside\", xs, ys)\n",
    "\n",
    "us = [7, 14]\n",
    "vs = [-1, -3]\n",
    "\n",
    "print(\"outside\", us, vs)\n",
    "f(us, vs)\n",
    "print(\"outside\", us, vs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the first list was changed after being manipulated (i.e., the same value was being referred to both inside and outside the function), but the second list was not changed, due to the fact that it was re-assigned inside the function (so a new value was created inside the function, therefore the one that was being referred to outside was not modified). \n",
    "\n",
    "**Notabene:** Try to avoid modifying list arguments to functions in-place like in the above code cell. If you need to change a list inside a function, sinply create a new list and put the changes there, then return the new list.\n",
    "\n",
    "**Note for C/C++ Programmers:** This is similar to how arrays can be passed by reference using pointers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List methods\n",
    "\n",
    "We have already seen that you can add extra elements to a list using `append()`. This type of function is called a **list method**, a function that is bound to every list created in python. There are a few other list methods that are of interest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* count(): Returns the number of elements with the specified value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 2, 3]\n",
    "print(my_list.count(2))  # Output: 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* extend(): Adds all the elements of a list to the end of the current list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3]\n",
    "my_list.extend([4, 5])\n",
    "print(my_list)  # Output: [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* insert() and remove(): Inserts (removes) the first item with the specified value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3]\n",
      "[1, 'a', 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3]\n",
    "my_list.remove(2)\n",
    "print(my_list)  \n",
    "\n",
    "my_list.insert(1, 'a')\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* sort(): Sorts the list in ascending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['a', 'balderdash', 'charlie and the chocolate factory', 'd', 'h', 'r']\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[49], line 12\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m# Sorting only works for lists that contain numbers or strings, not both\u001b[39;00m\n\u001b[1;32m     11\u001b[0m my_list\u001b[38;5;241m.\u001b[39minsert(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 12\u001b[0m \u001b[43mmy_list\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "my_list = [3, 1, 2]\n",
    "my_list.sort()\n",
    "print(my_list)  \n",
    "\n",
    "#Sorting also works with strings\n",
    "another_list = ['h', 'r', 'd', 'a', 'balderdash', 'charlie and the chocolate factory']\n",
    "another_list.sort()\n",
    "print(another_list)\n",
    "\n",
    "# Sorting only works for lists that contain numbers or strings, not both\n",
    "my_list.insert(1, 'a')\n",
    "my_list.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The for-loop\n",
    "\n",
    "List elements can be **traversed** one by one using `while` loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "apple\n",
      "3.14\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, \"apple\", 3.14, True]\n",
    "\n",
    "index_count = 0\n",
    "\n",
    "while index_count < len(my_list):\n",
    "    print(my_list[index_count])\n",
    "    index_count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, there is a less cumbersome way to do this using a new kind of loop: A **for-loop**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "apple\n",
      "3.14\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, \"apple\", 3.14, True]\n",
    "\n",
    "for element in my_list:\n",
    "    print(element)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This loop also reads in plain English. It means \"Do the indented code block\" **for every element in my_list**.\n",
    "\n",
    "Note that, unlike while loops, for-loops do not require you to keep track of the index values. \n",
    "\n",
    "A for-loop **iterates** through every element of a list automatically. At each iteration, the body of the loop is executed while the variable `element` (called an **iterator**) is set to a particular element of the list. Once the iteration is done, the variable `element` is set to the next element of the list. The loop bpody is repeatedly executed until the last element of the list. Then, the loop automatically terminates and the lines below the body of the loop are executed.\n",
    "\n",
    "**Note that** the `for`-loop statement also ends with a colon like the `while`-loop statement.\n",
    "\n",
    "Suppose you want to create an index count in a for-loop just like a while loop. This can be done using the builtin `range()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of first 10 natural numbers: 5050\n"
     ]
    }
   ],
   "source": [
    "# Example: Calculating the sum of the first 10 natural numbers\n",
    "total = 0\n",
    "for i in range(1, 101):\n",
    "    total += i\n",
    "print(\"Sum of first 10 natural numbers:\", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, `range(start, stop, step)` produces a sequence of integers from `start` (inclusive) to `stop` (exclusive) with a stride of `step`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "26\n",
      "39\n",
      "52\n",
      "65\n",
      "78\n",
      "91\n",
      "104\n",
      "117\n",
      "130\n"
     ]
    }
   ],
   "source": [
    "for i in range(13, 131, 13):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to prepare a list element by element, there is a simple way of doing this by combining a list with a for-loop, called **list comprehension**. List comprehensions in Python provide a concise way to create lists. They are often more readable and faster than traditional for loops. Here’s a breakdown of how they work:\n",
    "\n",
    "```python\n",
    "[expression for item in iterable if condition]\n",
    "```\n",
    "\n",
    "Here, \n",
    "\n",
    "1. expression: The operation you want to perform on each item.\n",
    "2. item: The current item from the iterable.\n",
    "3. iterable: The collection of items you are iterating over (e.g., a list).\n",
    "4. condition (optional): A filter that only includes items that meet the condition.\n",
    "\n",
    "Simple Example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "squares = [x ** 2 for x in numbers]\n",
    "print(squares)  # Print a list of squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example of list comprehension with a conditional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "evens = [x for x in range(11) if x % 2 == 0]\n",
    "print(evens)  # Print a list of even numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### break statement\n",
    "\n",
    "The loops that we have discussed above all have pre-determined termination points. You can, if you want, exit a loop prematurely (before the condition for the loop becomes `False`) using the `break` statement. The break statement in Python is used to exit a loop prematurely when a **newly provided** condition is met. It can be used in both while and for loops. Here’s how it works in each context:\n",
    "\n",
    "A while loop continues to execute as long as its condition is `True`. The `break` statement can be used to exit the loop when an additional condition is met, **even if the loop’s condition is still** `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Exited the loop\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    if i == 5:\n",
    "        break\n",
    "    i += 1\n",
    "print(\"Exited the loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the loop prints numbers from 0 to 5. When i equals 5, the break statement is executed, and the loop terminates.\n",
    "\n",
    "The `break` statement can also be used in a for-loop. A for loop iterates over a sequence like a list. The `break` statement can be used to exit the loop when a specific condition is met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Exited the loop\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 5:\n",
    "        break\n",
    "print(\"Exited the loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 03:\n",
    "A simple way to determine if a number $n$ is a prime number or not is to prepare a sequence of increasing numbers from $2$ to $\\left[\\sqrt{n}\\right]$ (here, $[\\;]$ is the floor function). If $n$ is not divisible by any of these numbers, then $n$ is a prime number. \n",
    "\n",
    "Use a for-loop to prepare a sequence of $N$ prime-numbers and run it for some choices of $N$. You can start from an empty list, created using a command like\n",
    "\n",
    "```python\n",
    "l = []\n",
    "```\n",
    "and populate it with primes using `l.append()`.\n",
    "\n",
    "\n",
    "<!--\n",
    "```python\n",
    "N = 100\n",
    "list_of_primes = []\n",
    "\n",
    "for n in range(2, N):\n",
    "    is_prime = True\n",
    "    for i in range(2, int(n**0.5) + 1):\n",
    "        if n % i == 0:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        list_of_primes.append(n)\n",
    "\n",
    "print(list_of_primes)\n",
    "```-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "A tuple is a collection of items that is ***ordered and immutable***. \n",
    "\n",
    "Tuples are similar to lists, but unlike lists, once a tuple is created, its elements cannot be changed. Tuples are defined by enclosing the elements in parentheses ().\n",
    "\n",
    "\n",
    "You can create a tuple by placing a sequence of values separated by commas inside parentheses.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 'Hello', 3.4)\n",
      "(1, 2, 3)\n",
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "# Creating a tuple\n",
    "my_tuple = (1, 2, 3)\n",
    "print(my_tuple)  # Output: (1, 2, 3)\n",
    "\n",
    "# Tuple with mixed data types\n",
    "mixed_tuple = (1, \"Hello\", 3.4)\n",
    "print(mixed_tuple)  # Output: (1, 'Hello', 3.4)\n",
    "\n",
    "# Creating a tuple without parentheses\n",
    "another_tuple = 1, 2, 3\n",
    "print(another_tuple)  # Output: (1, 2, 3)\n",
    "\n",
    "# Creating a tuple with one element\n",
    "single_element_tuple = (1,)\n",
    "print(single_element_tuple)  # Output: (1,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can also be created from lists using the builtin `tuple()` function. **Note** that, the reverse is also possible, *i.e.* a list can be created from a tuple using the `list()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "[4, 5, 'My name is', 'John', 3.14159]\n"
     ]
    }
   ],
   "source": [
    "a_list = [1, 2, 3]\n",
    "a_tuple = tuple(a_list)\n",
    "print(a_tuple)  # Output: (1, 2, 3)\n",
    "\n",
    "another_tuple = (4, 5, \"My name is\", \"John\", 3.14159)\n",
    "\n",
    "another_list = list(another_tuple)\n",
    "print(another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access elements in a tuple using indexing, just like lists. Indexing starts from 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "my_tuple = ('a', 'b', 'c', 'd', 'e')\n",
    "\n",
    "# Accessing the first element\n",
    "print(my_tuple[0])  # Output: 'a'\n",
    "\n",
    "# Accessing the last element\n",
    "print(my_tuple[-1])  # Output: 'e'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can unpack a tuple into individual variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "\n",
    "a, b, c = my_tuple\n",
    "print(a)  # Output: 1\n",
    "print(b)  # Output: 2\n",
    "print(c)  # Output: 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extra, the swap idiom in python\n",
    "\n",
    "Remember the swap idiom from the last lab, where we easily swapped two python objects `a` and `b` with the code\n",
    "\n",
    "```python\n",
    "a, b = b, a\n",
    "```\n",
    "\n",
    "Actually, the commas indicate the creation of **tuples**, so the code can also read as\n",
    "```python\n",
    "(a, b) = (b, a)\n",
    "```\n",
    "\n",
    "Now, we can understand the idiomatic meaning of the swap a little better. The right-hand side of the assignment `(b, a)` creates a tuple with the values of `b` and `a`. The left-hand side `(a, b)` unpacks this tuple, assigning the first value to a and the second value to b. \n",
    "\n",
    "You can also use this packing/unpacking to do multiple assignments in a single instruction. For instance:\n",
    "```python\n",
    "a, b, c = 3, 6, 0\n",
    "```\n",
    "sets the tuple `(a,b,c)` to `(3, 6, 0)`. Thus, it sets `a = 3, b = 6, c = 0` all together.\n",
    "\n",
    "If the number of variables is less than the number of values in the tuple, you can use an asterisk (*) to collect the remaining values into a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "['cherry', 'strawberry', 'raspberry']\n"
     ]
    }
   ],
   "source": [
    "# Using * to unpack remaining values\n",
    "fruits = (\"apple\", \"banana\", \"cherry\", \"strawberry\", \"raspberry\")\n",
    "green, yellow, *red = fruits\n",
    "print(green)  # Output: apple\n",
    "print(yellow)  # Output: banana\n",
    "print(red)  # Output: ['cherry', 'strawberry', 'raspberry']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 04:\n",
    "\n",
    "Given a tuple of numbers, write a Python program to find the second-largest number in the tuple. The numbers may not be unique: That is to say, they may repeat, like `[1, 5, 28, 28, 9, 8]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}