Let's Learn Python/08. Python - Conditional Statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Conditional-Statements-in-Python_Watermarked.b6b7d30ff62b.jpg\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Python Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Indentation:\n",
    "\n",
    "Python uses indentation to define blocks of code. It is essential for maintaining the structure and readability of your code. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Five is greater than three\n"
     ]
    }
   ],
   "source": [
    "if 5 > 3:\n",
    "    print('Five is greater than three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the print statement is indented with four spaces. The indentation indicates that the print statement is part of the if block. If the condition 5 > 3 evaluates to True, the indented code block will execute. After : if you push Enter, it will automatically creates the indent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **if** statement allows you to execute a block of code conditionally. It is structured with the following components:\n",
    "\n",
    "**1. The if keyword:** This is the keyword that marks the beginning of the if statement.\n",
    "\n",
    "**2. Condition:** After the if keyword, you write a condition that evaluates to either True or False. This condition determines whether the associated block of code should be executed. You can use various comparison operators (such as <, >, ==, !=, <=, >=, etc.) to create conditions.\n",
    "\n",
    "**3. Colon (:):** After the condition, you need to include a colon (:) at the end of the line. The colon is a syntax requirement and indicates that the code block associated with the if statement follows.\n",
    "\n",
    "**4. Indented code block:** The code block associated with the if statement must be indented. It typically consists of one or more lines of code that are executed when the condition is True. Python uses indentation (usually four spaces or a tab) to determine the beginning and end of the code block. It's crucial to maintain consistent indentation throughout your code.\n",
    "\n",
    "\n",
    "``if condition:\n",
    "    code block to execute if the condition is True``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 3\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 3:\n",
    "    print('x is greater than 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the condition x > 3 checks if the value of x is greater than 3. If the condition is True, the code inside the indented block will be executed. In this case, it will print the message 'x is greater than 3'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "\n",
    "if x > 3:\n",
    "    print('x is greater than 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the condition is False, the code block is skipped."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 3\n",
      "This line is also inside the if block\n",
      "This line is outside the if block\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 3:\n",
    "    print('x is greater than 3')\n",
    "    print('This line is also inside the if block')\n",
    "    \n",
    "print('This line is outside the if block')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, both print statements are indented and will be executed if the condition x > 3 is True. The last print statement, which is not indented, will be executed regardless of the condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Else Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The else statement is used in conjunction with an if statement and provides an alternative block of code to execute when the condition of the if statement is False. Here's the general syntax:\n",
    "\n",
    "``\n",
    "if condition:\n",
    "    code block to execute if the condition is True\n",
    "else:\n",
    "    code block to execute if the condition is False``\n",
    "    \n",
    "The else statement does not require a condition. It is executed only when the preceding if statement's condition is False. Only one of the two code blocks (either the one following the if statement or the one following the else statement) will be executed.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is less than or equal to 10\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 10:\n",
    "    print('x is greater than 10')\n",
    "else:\n",
    "    print('x is less than or equal to 10')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, if x is greater than 10, the first print statement will be executed. Otherwise, if x is less than or equal to 10, the second print statement (inside the else block) will be executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elif Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elif (short for \"else if\") statement allows you to check multiple conditions after an initial if statement. It provides an additional condition to be evaluated if the preceding if or elif statements' conditions are False.\n",
    "\n",
    "``if condition1:\n",
    "    code block to execute if condition1 is True\n",
    "elif condition2:\n",
    "    code block to execute if condition2 is True\n",
    "else:\n",
    "    code block to execute if all conditions are False``\n",
    "    \n",
    "You can have multiple elif statements to check different conditions in sequence. The code blocks associated with elif statements are executed only if their respective conditions evaluate to True.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is less than or equal to 5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 10:\n",
    "    print('x is greater than 10')\n",
    "elif x > 5:\n",
    "    print('x is greater than 5')\n",
    "else:\n",
    "    print('x is less than or equal to 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the conditions are evaluated sequentially. If x is greater than 10, the first print statement is executed. If x is not greater than 10 but is greater than 5, the second print statement is executed. If neither condition is met, the code inside the else block is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "if x > 0:\n",
    "    print('x is positive')\n",
    "elif x == 0:\n",
    "    print('x is zero')\n",
    "else:\n",
    "    print('x is negative')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can have multiple if statements in Python. Each if statement will be evaluated independently, regardless of the other if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 5\n",
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 10:\n",
    "    print('x is greater than 10')\n",
    "    \n",
    "if x > 4:\n",
    "    print('x is greater than 5')\n",
    "    \n",
    "if x > 0:\n",
    "    print('x is positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to create mutually exclusive conditions where only one block should execute, you can use if, elif, and else statements together. Keep in mind that elif statements can be more than one in mutually exclusive conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is greater than 3\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "if x > 10:\n",
    "    print('x is greater than 10')\n",
    "elif x > 7:\n",
    "    print('x is greater than 7')\n",
    "elif x > 5:\n",
    "    print('x is greater than 5')\n",
    "elif x > 3:\n",
    "    print('x is greater than 3')\n",
    "else:\n",
    "    print('x is less than or equal to 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we have multiple elif statements that are evaluated in sequence. Each elif statement provides an additional condition to be checked if the preceding conditions are False. Only the code block associated with the first elif statement (whose condition evaluates to True) will be executed.\n",
    "\n",
    "\n",
    "\n",
    "Let's assume x is 5 in this example. Here's how the conditions are evaluated:\n",
    "\n",
    "The first elif condition x > 10 is False, so the associated code block is not executed.\n",
    "\n",
    "The second elif condition x > 7 is also False, so its code block is skipped.\n",
    "\n",
    "The third elif condition x > 5 is False, so its code block is skipped as well.\n",
    "\n",
    "The fourth elif condition x > 3 is True, so the associated code block print(\"x is greater than 3\") is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "y = 5\n",
    "\n",
    "if x < y:\n",
    "    print('yes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Condition is true\n"
     ]
    }
   ],
   "source": [
    "if 'hello' in ['hello', 'world', 'python']:\n",
    "    print('Condition is true')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**and operator:** The first if statement checks two conditions using the and operator. The code block is executed only if both conditions (x > 3 and y < 15) are True.\n",
    "\n",
    "**or operator:** The second if statement checks two conditions using the or operator. The code block is executed if at least one of the conditions (x > 7 or y > 15) is True.\n",
    "\n",
    "**not operator:** The third if statement uses the not operator to negate a condition. The code block is executed only if the negation of the condition (not x > 10) is True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example that demonstrates the use of logical operators (or, and, etc.) in conditional statements in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both conditions are satisfied\n",
      "Negation of the condition is satisfied\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "\n",
    "if x > 3 and y < 15:\n",
    "    print('Both conditions are satisfied')\n",
    "\n",
    "if x > 7 or y > 15:\n",
    "    print('At least one condition is satisfied')\n",
    "\n",
    "if not x > 10:\n",
    "    print('Negation of the condition is satisfied')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming x is 5 and y is 10, here's how the conditions are evaluated:\n",
    "\n",
    "In the first if statement, both conditions are satisfied (x > 3 is True and y < 15 is True), so the code block is executed and the message \"Both conditions are satisfied\" is printed.\n",
    "\n",
    "In the second if statement, the first condition x > 7 is False, but the second condition y > 15 is False as well. Since neither condition is satisfied, the code block is not executed.\n",
    "\n",
    "In the third if statement, the condition x > 10 is False. However, the not operator negates the condition, resulting in True. Hence, the code block is executed, and the message \"Negation of the condition is satisfied\" is printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Expressions (ternary operator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The purpose of the conditional expression is to provide a concise way to choose between two values or expressions based on a condition.\n",
    "\n",
    "The general syntax of a conditional expression is as follows:\n",
    "\n",
    "``value_if_true if condition else value_if_false``\n",
    "\n",
    "1. value_if_true: This is the value or expression that will be returned if the condition evaluates to True.\n",
    "\n",
    "2. condition: The condition is an expression that evaluates to either True or False. It determines which value (either value_if_true or value_if_false) will be returned.\n",
    "\n",
    "3. value_if_false: This is the value or expression that will be returned if the condition evaluates to False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "result = 'Positive' if x > 0 else 'Non-positive'\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the condition x > 0 is evaluated. If the condition is True, the value \"Positive\" is assigned to the variable result. If the condition is False, the value \"Non-positive\" is assigned. In this case, since x is 5 (which is greater than 0), the output will be Positive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional expressions are useful when you want to assign a value based on a condition without the need for an explicit if-else statement. They offer a concise and readable way to express simple conditional logic.\n",
    "\n",
    "It's important to note that conditional expressions should be used judiciously to maintain code readability. If the logic becomes more complex or involves multiple conditions, it is generally recommended to use traditional if-else statements instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'minor'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = 13\n",
    "'minor' if age < 21 else 'adult'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = y = 20\n",
    "\n",
    "z = 2 + x if x > y+1 else y + 3\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = y = 20\n",
    "\n",
    "z = 2 + (x if x > y+1 else y) + 3\n",
    "z"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}