Lab02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Basic Programming I\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python idioms\n",
    "\n",
    "Now that we have seen variables at work, it's time to delve into a slightly more advanced feature of python, its **idiomatic nature**. \n",
    "\n",
    "The key characteristic of python is ***readability***. It is of great importance that we leverage on readability, since code is read much more often than it is written. The design of python programs is heavily influenced by the following principles, often called the **\"Zen of Python\"**\n",
    "\n",
    "1. Beautiful is better than ugly.\n",
    "2. Explicit is better than implicit.\n",
    "3. Simple is better than complex.\n",
    "4. Readability counts.\n",
    "\n",
    "\n",
    "There are some other principles (19 in total), but these four are the key ones. \n",
    "\n",
    "**Extra:** If you want to see all Zen principles, run the python command `import this`.\n",
    "\n",
    "Very broadly, these mean that there should be semantically **simple** and **easy-to-understand** ways to do \"standard tasks\" that are required by computer programmers, even if the actual task is logically very complex. \n",
    "\n",
    "These 'simple' ways of doing 'complex' tasks are called **idioms**. \n",
    "\n",
    "Thus, an idiom in python is similar to an idiom in English (বাগ্ধারা in Bengali), where a short, pithy phrase is stated to mean something completely different than the literal description: For example, the Bengali বাগ্ধারা \"ঘোড়ার ডিম\" (idiom \"horse's egg\") which stands for something that does not exist, or is unlikely, impossible, or absurd. This type of idiom is called an idiom of improbability, or 'adynaton', and it is similar to the idiom \"when pigs fly\" in English, or \"Am Sankt-Nimmerleins-Tag\" (on Saint-Never's-day) in German.\n",
    "\n",
    "Python has many idioms that make complex programming easy. Let us look at an example. Suppose you have two variables\n",
    "```python\n",
    "name = 46\n",
    "\n",
    "age = \"Analabha Roy\"\n",
    "```\n",
    "\n",
    "Here, I wanted the variable `name` to contain a string with my name, and the variable `age` to contain an integer with my age. \n",
    "\n",
    "But wait! I made a mistake! The values are switched! So is there a way to switch them back programatically?\n",
    "\n",
    "Doing the obvious operation yields a mistake\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is  46 . My age is  Analabha Roy .\n",
      "My name is  Analabha Roy . My age is  Analabha Roy .\n"
     ]
    }
   ],
   "source": [
    "name = 46\n",
    "age = \"Analabha Roy\"\n",
    "\n",
    "print(\"My name is \", name, \". My age is \", age, \".\")\n",
    "\n",
    "#Let's try to 'switch' them, but this will not work\n",
    "name = age\n",
    "age = name\n",
    "print(\"My name is \", name, \". My age is \", age, \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That didn't work. Because although the first swap re-referenced the string \"Analabha Roy\" to the correct variable, it **de-referenced** the original value (46) in the process, which got **deleted and lost** due to the garbage collector later on. The second swap simply re-referenced the current value of `name` (the string \"Analabha Roy\") to `age`. \n",
    "\n",
    "So, the standard programming practice (common in languages like C/C++ or Java or whatever) for 'swapping' two variables is to create a **third** temporary variable and backup the first value there before swapping. That way, the original value isn't lost, and can be \"restored\" from the backup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is  46 . My age is  Analabha Roy .\n",
      "My name is  Analabha Roy . My age is  46 .\n"
     ]
    }
   ],
   "source": [
    "name = 46\n",
    "age = \"Analabha Roy\"\n",
    "\n",
    "print(\"My name is \", name, \". My age is \", age, \".\")\n",
    "\n",
    "#########################################################\n",
    "#Let's try to 'switch' them the right way\n",
    "#########################################################\n",
    "#First, backup the value of 'name' into 'temp'\n",
    "temp = name\n",
    "\n",
    "#Next, write the value of 'age' into 'name'. \n",
    "name = age\n",
    "\n",
    "#The old value is deleted.\n",
    "\n",
    "#Now, restore the value of 'age' from the backup at 'temp'\n",
    "age = temp\n",
    "#########################################################\n",
    "\n",
    "#This will now work\n",
    "print(\"My name is \", name, \". My age is \", age, \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### That worked! \n",
    "\n",
    "The problem is that this was not trivial, and somewhat counter-intuitive. \n",
    "\n",
    "Is there some way to make it look easier and clearer to understand? Most programming languages can't do this, but Python can, with an **idiom**!\n",
    "\n",
    "Look at the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is  46 . My age is  Analabha Roy\n",
      "My name is  Analabha Roy . My age is  46\n"
     ]
    }
   ],
   "source": [
    "name = 46\n",
    "age = \"Analabha Roy\"\n",
    "\n",
    "print(\"My name is \", name, \". My age is \", age)\n",
    "\n",
    "#Let's try to 'switch' them idiomatically\n",
    "name, age = age, name\n",
    "print(\"My name is \", name, \". My age is \", age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### That worked perfectly, and was very simple! \n",
    "I just switched them 'together and simultaneously' with commas! Actually, these comma-separated values constitute a **tuple** in python: we'll discuss tuples later on in this course. This is an example of a pythonic idiom! This won't work so easily in C/C++ or Java! \n",
    "\n",
    "We will see other idiomatic expressions in python throughout this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings in Python\n",
    "\n",
    "In python, strings are a fundamental data type, just like `int` and `float`.\n",
    "\n",
    "A Python string is a collection of Unicode characters.\n",
    "\n",
    "A python string can be prepared by enclosed in single, double or triple quotes.\n",
    "\n",
    "```python\n",
    "\n",
    "'BlindSpot'\n",
    "\"BlindSpot\"\n",
    "''' BlindSpot '''\n",
    "\"\"\"Blindspot\"\"\"\n",
    "```\n",
    "all these are individual strings\n",
    "\n",
    "\n",
    "Note that, if there are characters like ' \" or \\ within a string, they can be\n",
    "retained in two ways:\n",
    "\n",
    "1. Escape them by preceding them with a \\\n",
    "2. Prepend the string with a 'r' indicating that it is a raw string\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He said, 'Let's go to school.'\n",
      "He said, 'Let's go to school.'\n"
     ]
    }
   ],
   "source": [
    "msg1 = 'He said, \\'Let\\'s go to school.\\''\n",
    "print(msg1)\n",
    "\n",
    "msg2 = r\"He said, 'Let's go to school.'\"\n",
    "print(msg2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "msg1 == msg2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that, if the operation `==` is executed with the variables `msg1` and `msg2`, it compares the values of these variables ***i.e.*** the data referenced by them after any evaluations of expressions. If the data are identical bit-for-bit, the result is the boolean `True`. \n",
    "\n",
    "If, however,  they are not identical (even by a little bit), then the result is `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He said, 'Let's go to school.'\n",
      "He said, 'Let us  go to school.'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "msg2 = r\"He said, 'Let us  go to school.'\"\n",
    "print(msg1)\n",
    "print(msg2)\n",
    "msg1 == msg2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note to C/C++ programmers:** Python does not have a separate `char` datatype for single characters, unlike C/C++. Single characters can be created in python as a string consisting of a single character, for instance\n",
    "```python\n",
    "a = 'r'\n",
    "b = 'a'\n",
    "c = 'g'\n",
    "d = '123'\n",
    "```\n",
    "Here, `a,b,c,d` are all *strings*, but `a,b,c` only store a single character in the string, whereas `d` is a multi-character string. Unlike C/C++, a string in python is **not** an array of characters, although it can be indexed like one, as we shall now discuss.\n",
    "\n",
    "\n",
    "String elements can be accessed using an index value, starting with 0. Negative index value is allowed. The last character is considered to be at index -1. Backwards index counting is possible, starting from -1 and going as -2, -3, -4 etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H o H\n",
      "o l\n",
      "l\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "msg = 'Hello'\n",
    "a = msg[0]\n",
    "b = msg[4]\n",
    "c = msg[-0]\n",
    "d = msg[-1]\n",
    "e = msg[-2]\n",
    "f = msg[-5]\n",
    "\n",
    "print(a, d, f)\n",
    "print(b, e)\n",
    "print(msg[2])\n",
    "\n",
    "\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part of a string can be sliced out of a string. Consider a string names `s`, with integers `start` and `end`. Then,\n",
    "\n",
    "* s[start : end: stride] - extract from `start` to `(end - 1)` in steps of `stride`.\n",
    "* s[start :] - extract from `start` to the last character. Default stride is `1`.\n",
    "* s[: end] - extract from beginning to `(end - 1)`. Default stride is `1`.\n",
    "* s[-start :] - extract from `-start` (included) to the last character. Default stride is `1`.\n",
    "* s[: -end] - extract from beginning to `-end - 1`. Default stride is `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kolkata and Burdwan are two cities\n",
      "Kolkata   is a city\n",
      "Burdwan  is also a city\n",
      "Burdwan  is also a city, only here its counted differently\n",
      "The city of Kolkata   has  8  letters in its name\n",
      "Klaa\n",
      "Klaa\n"
     ]
    }
   ],
   "source": [
    "s = \"Kolkata and Burdwan are two cities\"\n",
    "print(s)\n",
    "\n",
    "kol = s[:8]\n",
    "print(kol, ' is a city')\n",
    "\n",
    "bwn = s[12:19]\n",
    "print(bwn, ' is also a city')\n",
    "print(s[-22:-15], ' is also a city, only here its counted differently')\n",
    "\n",
    "#This shows the usage of the len() function\n",
    "print(\"The city of\", kol, \" has \", len(kol) ,\" letters in its name\")\n",
    "\n",
    "#Print every alternate letter of 'kolkata' by striding through the list by 2\n",
    "print(kol[::2])\n",
    "print(s[0:7:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python, some math and logic operations have been **overloaded** to work with strings, for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MacLearn!!\n",
      "MacLearn!!MacLearn!!\n",
      "MacLearn!!MacLearn!!MacLearn!!\n"
     ]
    }
   ],
   "source": [
    "msg6 = 'MacLearn!!'\n",
    "print(msg6)\n",
    "\n",
    "# string replication during printing\n",
    "print(msg6 * 2)\n",
    "print(msg6 * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UtopiaToday!!!\n"
     ]
    }
   ],
   "source": [
    "msg7 = 'Utopia'\n",
    "msg8 = 'Today!!!'\n",
    "msg7 = msg7 + msg8 # concatenation using +\n",
    "print(msg7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we observe two more **pythonic idioms**. In most programming languages like C/C++ or Java, you cannot trivially \"add\" (concatenate) strings or repeat them with `*`, since the `+` and `*` symbols are reserved only for adding (multiplying) numbers. \n",
    "\n",
    "You'll have to create a new empty string of the right size, read each one of the original strings character-by-character in the desired order and write each character into the new string. Alternatively, you can use special functions from external libraries that automatically concatenate strings. In C/C++, this is the`strcat()` function defined in the `string.h` header and located in the `libstdc++` library. Either way, it's complicated!\n",
    "\n",
    "Not necessary in python. In python, operator symbols can serve multiple roles (this is called 'operator overloading'). \n",
    "\n",
    "A simple idiom makes concatenating and repeating strings simple and intuitive: It's just like doing math!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BamboozledHype!\n",
      "BambooMonger!\n"
     ]
    }
   ],
   "source": [
    "s = 'Bamboozled'\n",
    "s = s + 'Hype!'\n",
    "print(s)\n",
    "\n",
    "s = s[:6] + 'Monger' + s[-1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Madam. I'm Adam\n",
      "madA m'I .madaM\n"
     ]
    }
   ],
   "source": [
    "a = \"Madam. I'm Adam\"\n",
    "print(a)\n",
    "\n",
    "# Reversing a string\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reversing the string was just done by using another **pythonic idiom**, the string slice `[::-1]` means \"extract from beginning to end in steps of -1\", *i.e.* in reverse order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 01:\n",
    "\n",
    "1. Try to make sense of the output of the program below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "able was I ere I saw elba\n",
      "able was I ere I saw elba\n",
      "True\n",
      "#########################\n",
      "able was I ere I saw elba.\n",
      ".able was I ere I saw elba\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#This is something that Napoleon Bonaparte is supposed to have said\n",
    "a = \"able was I ere I saw elba\"\n",
    "print(a)\n",
    "\n",
    "a_reversed = a[::-1]\n",
    "print(a_reversed)\n",
    "print(a == a_reversed)\n",
    "\n",
    "print(\"#########################\")\n",
    "\n",
    "a = \"able was I ere I saw elba.\"\n",
    "print(a)\n",
    "\n",
    "a_reversed = a[::-1]\n",
    "print(a_reversed)\n",
    "print(a == a_reversed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 02:\n",
    "\n",
    "For a given string 'Bamboozled', write a program to obtain the following output:\n",
    "```python\n",
    "Ba\n",
    "ed\n",
    "mboozled\n",
    "Bamboo\n",
    "delzoobmaB\n",
    "Bmoze\n",
    "Bbzd\n",
    "Boe\n",
    "BambooHype!\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python f-strings \n",
    "\n",
    "Python f-strings (formatted string literals), introduced in Python 3.6, provide a concise and readable way to embed expressions and variables directly into strings by **interpolation** and **formatting**. \n",
    "\n",
    "#### Basic Usage: Interpolation\n",
    "To create an f-string, prefix the string with the letter f or F. Inside the string, you can include expressions and/or variables within curly braces {}. This results in **interpolation**, where the output replaces the variable in the appropriate place in the string by the referenced value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice and I am 30 years old.\n",
      "My name is Bob and I am 28 years old.\n"
     ]
    }
   ],
   "source": [
    "name = \"Alice\"\n",
    "age = 30\n",
    "\n",
    "#Note that the f-string string starts with an 'f' just before the quote\n",
    "print(f\"My name is {name} and I am {age} years old.\")\n",
    "\n",
    "name = \"Bob\"\n",
    "age = 28\n",
    "\n",
    "#Note that the f-string string starts with an 'f' just before the quote\n",
    "print(f\"My name is {name} and I am {age} years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can avoid repeating the same instruction over and over by putting it in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice and I am 30 years old.\n",
      "My name is Bob and I am 28 years old.\n",
      "My name is Charlie and I am (unknown) years old.\n"
     ]
    }
   ],
   "source": [
    "def print_name_age(name, age=\"(unknown)\"):\n",
    "    print(f\"My name is {name} and I am {age} years old.\")\n",
    "\n",
    "print_name_age(\"Alice\", 30)\n",
    "print_name_age(\"Bob\", 28)\n",
    "print_name_age(\"Charlie\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can embed expressions inside f-strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 375 and 23 is 398.\n",
      "375 divided by 23 is 16.304347826086957, with quotient 16 and remainder 7\n",
      "Thus, the compound fraction of 375/23 is 16(7/23)\n"
     ]
    }
   ],
   "source": [
    "a = 375\n",
    "b = 23\n",
    "print(f\"The sum of {a} and {b} is {a + b}.\")\n",
    "print(f\"{a} divided by {b} is {a/b}, with quotient {a//b} and remainder {a%b}\")\n",
    "print(f\"Thus, the compound fraction of {a}/{b} is {a//b}({a%b}/{b})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formatting Numbers\n",
    "f-strings support formatting options for numbers, such as specifying the number of decimal places for a float type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi to three decimal places is 3.142.\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14159\n",
    "print(f\"Pi to three decimal places is {pi:.3f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the use of `:M.N` and `f` in the formatting instruction following the variable. Here, the `M (N)` is the number of characters to the left (right) of the decimal that will be printed, and the `f` at the end instructs the interpreter to do floating point formatting.\n",
    "\n",
    "For integer formatting, we can do the following"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ram        ==>       4127\n",
      "Shyam      ==>       4098\n",
      "Carl       ==>        768\n"
     ]
    }
   ],
   "source": [
    "def print_pretty(name, ph):\n",
    "    print(f'{name:10} ==> {ph:10d}')\n",
    "\n",
    "name1 = 'Ram'\n",
    "ph1 = 4127\n",
    "print_pretty(name1, ph1)\n",
    "\n",
    "name2 = 'Shyam'\n",
    "ph2 = 4098\n",
    "print_pretty(name2, ph2)\n",
    "\n",
    "print_pretty('Carl', 768)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the use of `d` rather than `f` at the end of the format command.\n",
    "\n",
    "f-strings are a powerful feature in Python that make string interpolation and formatting easier and more efficient. They are highly recommended for use in modern Python code.\n",
    "\n",
    "### Exercise 03:\n",
    "\n",
    "1. Create a program that takes a user’s name and age as input and prints a greeting message using f-strings.\n",
    "2. Write a program that takes two numbers as input and prints their sum, difference, product, and quotient using f-strings.\n",
    "3. Create a program that takes a floating-point number as input and prints it rounded to two decimal places using f-strings.\n",
    "4. Write a program that converts a temperature from Celsius to Fahrenheit and prints the result using f-strings. The working formula is\n",
    "\\begin{equation*}\n",
    " F = \\frac{9}{5} C + 32\n",
    "\\end{equation*}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Conditionals\n",
    "\n",
    "### Introduction\n",
    "Conditionals are used to execute an indented code block based on certain conditions. The primary conditional statements in Python are `if`, `elif`, and `else`, although there are others like `try-except` that we shall not cover here. In all conditional statements, **the indentation is crucial** in Python, as it defines the scope of the code blocks.\n",
    "\n",
    "### Basic `if` Statement\n",
    "The `if` statement evaluates a condition and executes the code block if the condition is `True`.\n",
    "```python\n",
    "x = 10\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")  # This line is indented, meaning it belongs to the if block\n",
    "``` \n",
    "Here, the condition `x > 5 `is `True` because `x` is `10`. Therefore, the indented print statement is executed, and `x is greater than 5` is printed, as can be seen in the code cell below.\n",
    "\n",
    "Much like a function definition, the `if` statement **must** end with a colon (:). In fact, all conditional statements must end with a colon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n",
      "This will also be printed\n",
      "The program has ended.\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")  # These lines are indented, meaning they belong to the if block\n",
    "    print(\"This will also be printed\")\n",
    "\n",
    "print(\"The program has ended.\") # This line is NOT indented, meaning it is always executed after the if-block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if `x` was not greater than 5? In that case, the condition `x > 5` is `False`, and the indented lines in the scope of the `if` statement are not executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The program has ended.\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")  # These lines are indented, meaning they belong to the if block\n",
    "    print(\"This will also be printed\")\n",
    "\n",
    "print(\"The program has ended.\") # This line is NOT indented, meaning it is always executed after the if-block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if-else Statement\n",
    "\n",
    "The if-else statement provides an alternative code block to execute if the condition is False.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is not greater than 5\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")\n",
    "else:\n",
    "    print(\"x is not greater than 5\")  # This line is also indented correctly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the condition `x > 5` is `False` because `x` is `3`. Therefore, the code block under else is executed, and “x is not greater than 5” is printed.\n",
    "\n",
    "Note that there is also a colon (:) at the end of the `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "if x > 5:\n",
    "    print(\"x is greater than 5\")\n",
    "else:\n",
    "    print(\"x is not greater than 5\")  # This line is also indented correctly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the condition `x > 5` is `True` because `x` is `10`. Therefore, the code block under `if` is executed, and “x is greater than 5” is printed.\n",
    "\n",
    "The important part of this construct is the conditional. The conditional expression can be any expression that evaluates to a boolean, either `True` or `False`. Look at the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'racecar' is a palindrome and its length is greater than 5.\n"
     ]
    }
   ],
   "source": [
    "word = \"racecar\"\n",
    "\n",
    "if word == word[::-1] and len(word) > 5:\n",
    "    print(f\"'{word}' is a palindrome and its length is greater than 5.\")\n",
    "else:\n",
    "    print(f\"'{word}' is either not a palindrome or its length is 5 or less.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* word == word[::-1] checks if the string is the same when reversed. Such strings are called 'palindromes'\n",
    "* len(word) > 5 checks if the length of the string is greater than 5.\n",
    "* The and operator ensures both conditions must be True for the if block to execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'I am a student' is either not a palindrome or its length is 5 or less.\n"
     ]
    }
   ],
   "source": [
    "word = \"I am a student\" # Not a palindrome\n",
    "\n",
    "if word == word[::-1] and len(word) > 5:\n",
    "    print(f\"'{word}' is a palindrome and its length is greater than 5.\")\n",
    "else:\n",
    "    print(f\"'{word}' is either not a palindrome or its length is 5 or less.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'ere' is either not a palindrome or its length is 5 or less.\n"
     ]
    }
   ],
   "source": [
    "word = \"ere\" # A short Palindrome\n",
    "\n",
    "if word == word[::-1] and len(word) > 5:\n",
    "    print(f\"'{word}' is a palindrome and its length is greater than 5.\")\n",
    "else:\n",
    "    print(f\"'{word}' is either not a palindrome or its length is 5 or less.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will always print this\n",
      "True\n",
      "This also gets printed.\n",
      "10 10 20\n"
     ]
    }
   ],
   "source": [
    "# In principle, the conditional expression can be a literal boolean\n",
    "b = 10\n",
    "\n",
    "if True:\n",
    "    print(\"I will always print this\")\n",
    "    a = b\n",
    "    print(a==b)\n",
    "\n",
    "\n",
    "if False:\n",
    "    print(\"I will never print this\")\n",
    "    a = b+1\n",
    "    print(a==b)\n",
    "\n",
    "    \n",
    "if False:\n",
    "    print(\"I will never print this either\")\n",
    "    a = b-1\n",
    "    print(a==b)\n",
    "else:\n",
    "    print(\"This also gets printed.\")\n",
    "    print(a, b, a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### if-elif-else Statement\n",
    "\n",
    "The if-elif-else statement allows you to check multiple conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5 but less than or equal to 10\n"
     ]
    }
   ],
   "source": [
    "x = 7\n",
    "if x > 10:\n",
    "    print(\"x is greater than 10\")\n",
    "elif x > 5:\n",
    "    print(\"x is greater than 5 but less than or equal to 10\")\n",
    "else:\n",
    "    print(\"x is 5 or less\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the first condition `x > 10` is `False`, so the code moves to the `elif` condition `x > 5`, which is `True`. Therefore, the corresponding code block is executed, and “x is greater than 5 but less than or equal to 10” is printed.\n",
    "\n",
    "The final `else` block is executed only if all the conditionals above it are `False`. \n",
    "\n",
    "\n",
    "Note that all `else` blocks are optional. If no `else` block exists (the first `if` example did not have one), then the code execution simply continues to the next line.\n",
    "\n",
    "#### Nested Conditionals\n",
    "\n",
    "You can also nest conditional statements within each other. Each conditional must be properly indented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5 and even\n"
     ]
    }
   ],
   "source": [
    "x = 8\n",
    "if x > 5:\n",
    "    if x % 2 == 0:\n",
    "        print(\"x is greater than 5 and even\")\n",
    "    else:\n",
    "        print(\"x is greater than 5 and odd\")\n",
    "else:\n",
    "    print(\"x is 5 or less\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outer if condition `x > 5` is `True`, so the code enters the nested `if` block. The nested condition `x % 2 == 0` (`%` is the remainder operator) is also `True` because `8` is even. Therefore, “x is greater than 5 and even” is printed.\n",
    "\n",
    "#### Ternary If-Else Expression\n",
    "\n",
    "Python also supports a shorthand for `if-else` statements, known as the ternary `if-else` expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "result = \"x is greater than 5\" if x > 5 else \"x is not greater than 5\"\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The condition `x > 5` is `True`, so the expression \"x is greater than 5\" is assigned to result. The `print(result)` statement then outputs “x is greater than 5”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "big number\n",
      "small number\n"
     ]
    }
   ],
   "source": [
    "y = 20\n",
    "x = 'big number' if y > 10 else 0\n",
    "print(x)\n",
    "\n",
    "y = 3\n",
    "x = 5 if y > 10 else 'small number'\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 04\n",
    "1. Write a program that checks if a number is positive, negative, or zero.\n",
    "2. Write a program that checks if a year is a leap year. A year is a leap year if it is divisible by 4 but not by 100, except if it is also divisible by 400.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra: Another pythonic idiom\n",
    "\n",
    "Here is another clever idiom in python. Suppose you want to check if some given words are found in a long string\n",
    "\n",
    "```python\n",
    "paragraph = \"In the heart of the bustling city, a small café stood as a tranquil oasis. The aroma of freshly brewed coffee mingled with the soft hum of conversations, creating a cozy atmosphere. Patrons, lost in their thoughts or engaged in lively discussions, found solace in this charming retreat from the urban chaos.\"\n",
    "```\n",
    "\n",
    "The problem: Are the words \"aroma\", \"stood\", and \"rural\" present in the paragraph above?\n",
    "\n",
    "The logical way of determining this programatically is to stride through the entire `paragraph` string word-by-word (this is done using a `for`-loop or `while`-loop: You'll learn about these later), and compare each word with the given words, yielding `True` if any of them matches and `False` if none of them do.\n",
    "\n",
    "For those of you who know C/C++ programming, here is how to do this in C.\n",
    "\n",
    "#### C-code for searching strings:\n",
    "\n",
    "```C\n",
    "#include <stdio.h>\n",
    "\n",
    "int searchWord(const char *str, const char *word) {\n",
    "    const char *s = str;\n",
    "    const char *w;\n",
    "    while (*s) {\n",
    "        w = word;\n",
    "        const char *temp = s;\n",
    "        while (*temp && *w && (*temp == *w)) {\n",
    "            temp++;\n",
    "            w++;\n",
    "        }\n",
    "        if (!*w) {\n",
    "            return 1; // Word found\n",
    "        }\n",
    "        s++;\n",
    "    }\n",
    "    return 0; // Word not found\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    const char *str = \"In the heart of the bustling city, a small café stood as a tranquil oasis. The aroma of freshly brewed coffee mingled with the soft hum of conversations, creating a cozy atmosphere. Patrons, lost in their thoughts or engaged in lively discussions, found solace in this charming retreat from the urban chaos.\";\n",
    "\n",
    "    if (searchWord(str, \"aroma\")) {\n",
    "        printf(\"The word \\\"aroma\\\" was found in the paragraph.\\n\");\n",
    "    } else {\n",
    "        printf(\"The word \\\"aroma\\\" was not found in the paragraph.\\n\");\n",
    "    }\n",
    "\n",
    "    if (searchWord(str, \"stood\")) {\n",
    "        printf(\"The word \\\"stood\\\" was found in the paragraph.\\n\");\n",
    "    } else {\n",
    "        printf(\"The word \\\"stood\\\" was not found in the paragraph.\\n\");\n",
    "    }\n",
    "\n",
    "    if (searchWord(str, \"rural\")) {\n",
    "        printf(\"The word \\\"rural\\\" was found in the paragraph.\\n\");\n",
    "    } else {\n",
    "        printf(\"The word \\\"rural\\\" was not found in the paragraph.\\n\");\n",
    "    }\n",
    "\n",
    "    return 0;\n",
    "}\n",
    "```\n",
    "\n",
    "#### End code\n",
    "\n",
    "That was hard! You can simplify it a bit by using library string functions.\n",
    "\n",
    "### C Code for searching strings (easier):\n",
    "\n",
    "```C\n",
    "#include <stdio.h>\n",
    "#include <string.h>\n",
    "\n",
    "void searchWord(const char *str, const char *word) {\n",
    "    if (strstr(str, word) != NULL) {\n",
    "        printf(\"The word \\\"%s\\\" was found in the string.\\n\", word);\n",
    "    } else {\n",
    "        printf(\"The word \\\"%s\\\" was not found in the string.\\n\", word);\n",
    "    }\n",
    "}\n",
    "\n",
    "int main() {\n",
    "    const char *str = \"In the heart of the bustling city, a small café stood as a tranquil oasis. The aroma of freshly brewed coffee mingled with the soft hum of conversations, creating a cozy atmosphere. Patrons, lost in their thoughts or engaged in lively discussions, found solace in this charming retreat from the urban chaos.\";\n",
    "\n",
    "    searchWord(str, \"aroma\");\n",
    "    searchWord(str, \"stood\");\n",
    "    searchWord(str, \"rural\");\n",
    "\n",
    "    return 0;\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "#### End code\n",
    "\n",
    "Still, it seems very complicated!\n",
    "\n",
    "But there is a simple idiomatic way to do this in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "paragraph = \"In the heart of the bustling city, a small café stood as a tranquil oasis.\\\n",
    "             The aroma of freshly brewed coffee mingled with the soft hum of conversations,\\\n",
    "             creating a cozy atmosphere. Patrons, lost in their thoughts or engaged in lively discussions,\\\n",
    "             found solace in this charming retreat from the urban chaos.\"\n",
    "\n",
    "print(\"aroma\" in paragraph)\n",
    "print(\"stood\" in paragraph)\n",
    "print(\"rural\" in paragraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make it pretty by putting it in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The word aroma was found in the paragraph.\n",
      "The word stood was found in the paragraph.\n",
      "The word rural was not found in the paragraph.\n"
     ]
    }
   ],
   "source": [
    "def find_word(word, paragraph):\n",
    "    if word in paragraph:\n",
    "        print(f\"The word {word} was found in the paragraph.\")\n",
    "    else:\n",
    "        print(f\"The word {word} was not found in the paragraph.\")\n",
    "\n",
    "\n",
    "paragraph = \"In the heart of the bustling city, a small café stood as a tranquil oasis.\\\n",
    "             The aroma of freshly brewed coffee mingled with the soft hum of conversations,\\\n",
    "             creating a cozy atmosphere. Patrons, lost in their thoughts or engaged in lively discussions,\\\n",
    "             found solace in this charming retreat from the urban chaos.\"\n",
    "\n",
    "find_word(\"aroma\", paragraph)\n",
    "find_word(\"stood\", paragraph)\n",
    "find_word(\"rural\", paragraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Very easy!"
   ]
  }
 ],
 "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
}