02. Control and Evaluations Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HyperLearning AI - Introduction to Python\n",
    "An introductory course to the Python 3 programming language, with a curriculum aligned to the Certified Associate in Python Programming (PCAP) examination syllabus (PCAP-31-02).<br/>\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python\n",
    "\n",
    "\n",
    "## 02. Control and Evaluations Part 1\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python/modules/2/control-and-evaluations-part-1\n",
    "\n",
    "In this module, we will cover the fundamental building blocks of the Python programming language, namely:\n",
    "\n",
    "* **Basic Concepts** - logical/physical lines, comments, indentation, identifiers and keywords\n",
    "* **Literals** - string, boolean, numeric and special literals\n",
    "* **Operators** - unary, binary, arithmetic, assignment, comparison, logical, identity, membership and bitwise operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Basic Concepts\n",
    "#### 1.1. Logical and Physical Lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My entire string on a single physical line.\n"
     ]
    }
   ],
   "source": [
    "# Logical line spanning a single physical line\n",
    "my_string = 'My entire string on a single physical line.'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2. Explicit Line Joining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first part of the string. The second part of the string\n"
     ]
    }
   ],
   "source": [
    "# String literal spanning two physical lines using explicit line joining\n",
    "my_string = 'The first part of the string. \\\n",
    "The second part of the string'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have entered a valid date\n"
     ]
    }
   ],
   "source": [
    "# Control flow spanning multiple physical lines using explicit line joining\n",
    "year = 2019\n",
    "month = 9\n",
    "day = 15\n",
    "if 1900 < year < 2100 and 1 <= month <= 12 \\\n",
    "    and 1 <= day <= 31:    # Valid date\n",
    "        print(\"You have entered a valid date\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3. Implicit Line Joining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')\n"
     ]
    }
   ],
   "source": [
    "# Implicit line joining\n",
    "days = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',    # Weekdays\n",
    "        'Saturday', 'Sunday')    # Weekend\n",
    "print(days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5. Multi-Logical Physical Lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-09-17\n"
     ]
    }
   ],
   "source": [
    "# Multiple logical lines spanning a single physical line\n",
    "from datetime import date; today = date.today(); print(today)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.7. Indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your number is bigger than or equal to 100\n"
     ]
    }
   ],
   "source": [
    "# Identation is required for control flow in Python\n",
    "x = 101\n",
    "if x >= 100:\n",
    "    print(\"Your number is bigger than or equal to 100\")\n",
    "else:\n",
    "    print(\"Your number is less than 100\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-25-ef612de651e5>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-25-ef612de651e5>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    y = 200    # Incorrect indentation\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# Incorrect indentations lead to IndentationError\n",
    "x = 100\n",
    "    y = 200    # Incorrect indentation\n",
    "if x >= y:\n",
    "print(\"X is bigger than or equal to Y\")    # Incorrect indentation \n",
    "else:\n",
    "    print(\"Y is bigger than X\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.8. Identifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Valid identifiers\n",
    "my_first_number = 100\n",
    "my_first_string = 'Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to operator (<ipython-input-31-d040c6f74b4c>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-31-d040c6f74b4c>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    string-test = 'Invalid Identifier'\u001b[0m\n\u001b[1;37m                                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m can't assign to operator\n"
     ]
    }
   ],
   "source": [
    "# Invalid identifiers\n",
    "1number = 10\n",
    "string-test = 'Invalid Identifier'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Literals\n",
    "#### 2.1. String Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Line 1.\n",
      "Line 2.\n",
      "Line 1.\\nLine 2.\n",
      "résumé\n"
     ]
    }
   ],
   "source": [
    "my_first_string = 'Hello World'\n",
    "my_second_string = 'Line 1.\\nLine 2.'\n",
    "my_third_string = r'Line 1.\\nLine 2.'\n",
    "my_fourth_string = u'r\\u00e9sum\\u00e9'\n",
    "\n",
    "print(my_first_string)\n",
    "print(my_second_string)\n",
    "print(my_third_string)\n",
    "print(my_fourth_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2. Boolean Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "my_first_boolean = True\n",
    "my_second_boolean = False\n",
    "\n",
    "print(my_first_boolean)\n",
    "print(my_second_boolean)\n",
    "print(1==True)\n",
    "print(1==False)\n",
    "print(0==True)\n",
    "print(0==False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.1. Integer Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "100\n",
      "100\n",
      "100\n",
      "100000000\n"
     ]
    }
   ],
   "source": [
    "# Integer literals using different number systems\n",
    "decimal_integer = 100\n",
    "binary_integer = 0b1100100\n",
    "octal_integer = 0o144\n",
    "hexadecimal_integer = 0x64\n",
    "decimal_groupings_integer = 100_000_000\n",
    "\n",
    "print(decimal_integer)\n",
    "print(binary_integer)\n",
    "print(octal_integer)\n",
    "print(hexadecimal_integer)\n",
    "print(decimal_groupings_integer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.2. Floating Point Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "1000.0\n",
      "0.001\n",
      "10.0\n",
      "0.12345\n",
      "3.141593\n"
     ]
    }
   ],
   "source": [
    "# Floating point literals\n",
    "my_first_number = 3.14\n",
    "my_second_number = 10e2\n",
    "my_third_number = 100e-5\n",
    "my_fourth_number = 10.\n",
    "my_fifth_number = .12345\n",
    "my_sixth_number=3.14_15_93\n",
    "\n",
    "print(my_first_number)\n",
    "print(my_second_number)\n",
    "print(my_third_number)\n",
    "print(my_fourth_number)\n",
    "print(my_fifth_number)\n",
    "print(my_sixth_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.3. Imaginary Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10j\n",
      "0.1j 0.0 0.1\n",
      "(2+3j) 2.0 3.0\n"
     ]
    }
   ],
   "source": [
    "# Imaginary literals\n",
    "my_first_complex_number = 10j\n",
    "my_second_complex_number = .10j\n",
    "my_third_complex_number = 2+3j\n",
    "\n",
    "print(my_first_complex_number)\n",
    "print(my_second_complex_number, \n",
    "      my_second_complex_number.real, \n",
    "      my_second_complex_number.imag)\n",
    "print(my_third_complex_number, \n",
    "      my_third_complex_number.real, \n",
    "      my_third_complex_number.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4. Special Literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "X is not True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x)\n",
    "if x:\n",
    "    print('x is True')\n",
    "else:\n",
    "    print('x is not True')\n",
    "print(bool(None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Operators\n",
    "#### 3.1. Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "3\n",
      "512\n",
      "15.0\n",
      "5\n",
      "32\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "# Addition\n",
    "print(13 + 7)\n",
    "\n",
    "# Subtraction\n",
    "print(10 - 7)\n",
    "\n",
    "# Multiplication\n",
    "print(64 * 8)\n",
    "\n",
    "# Division\n",
    "print(225 / 15)\n",
    "\n",
    "# Modulus (remainder after division)\n",
    "print(69 % 8)\n",
    "\n",
    "# Exponentiation (raising by a power)\n",
    "print(2 ** 5)\n",
    "\n",
    "# Floor division (quotient)\n",
    "print(100 // 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2. Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15\n",
      "13\n",
      "52\n",
      "26.0\n",
      "2.0\n",
      "256.0\n",
      "17.0\n",
      "16\n",
      "26\n",
      "24\n",
      "12\n",
      "48\n"
     ]
    }
   ],
   "source": [
    "# Assignment\n",
    "x = 10\n",
    "print(x)\n",
    "\n",
    "# Add and assign (x = x + 5)\n",
    "x += 5\n",
    "print(x)\n",
    "\n",
    "# Substract and assign (x = x - 2)\n",
    "x -= 2\n",
    "print(x)\n",
    "\n",
    "# Multiply and assign (x = x * 4)\n",
    "x *= 4\n",
    "print(x)\n",
    "\n",
    "# Divide and assign (x = x / 2)\n",
    "x /= 2\n",
    "print(x)\n",
    "\n",
    "# Modulus and assign (x = x % 4)\n",
    "x %= 4\n",
    "print(x)\n",
    "\n",
    "# Exponentiation and assign (x = x ** 8)\n",
    "x **= 8\n",
    "print(x)\n",
    "\n",
    "# Floor division and assign (x = x // 15)\n",
    "x //= 15\n",
    "print(x)\n",
    "\n",
    "# Bitwise AND and assign (x = x & 18)\n",
    "x = int(x)\n",
    "x &= 18\n",
    "print(x)\n",
    "\n",
    "# Bitwise OR and assign (x = x | 10)\n",
    "x |= 10\n",
    "print(x)\n",
    "\n",
    "# Bitwise XOR and assign (x = x ^ 2)\n",
    "x ^= 2\n",
    "print(x)\n",
    "\n",
    "# Bitwise signed right shift and assign (x = x >> 1)\n",
    "x >>= 1\n",
    "print(x)\n",
    "\n",
    "# Bitwise zero fill left shift and assign (x = x << 2)\n",
    "x <<= 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3. Comparison Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Equal\n",
    "print(10 == 100)\n",
    "\n",
    "# Not equal\n",
    "print(2 != 5)\n",
    "\n",
    "# Greater than\n",
    "print(13 > 12)\n",
    "\n",
    "# Less than\n",
    "print(100 < 1_000_000)\n",
    "\n",
    "# Greater than or equal to\n",
    "print(15 >= 15)\n",
    "\n",
    "# Less than or equal to\n",
    "print(20 <= 19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4. Logical Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# AND\n",
    "print(1 < 100 and 10 < 100)\n",
    "\n",
    "# OR\n",
    "print(13 > 14 or 1 > 0)\n",
    "\n",
    "# NOT\n",
    "print(not(1 < 100 and 10 < 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5. Identity Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 100.0\n",
    "\n",
    "# IS\n",
    "print(x is y)\n",
    "print(x is x)\n",
    "\n",
    "# IS NOT\n",
    "print(x is not y)\n",
    "\n",
    "x = y\n",
    "print(x is y)\n",
    "print(x is not y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.6. Membership Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "weekdays = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')\n",
    "\n",
    "# IN\n",
    "print('Thursday' in weekdays)\n",
    "print('Saturday' in weekdays)\n",
    "\n",
    "# NOT IN\n",
    "print('Sunday' not in weekdays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.7.8. Bitwise Operators in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "26\n",
      "24\n",
      "-5\n",
      "6\n",
      "48\n"
     ]
    }
   ],
   "source": [
    "# Bitwise AND\n",
    "print(17 & 18)\n",
    "\n",
    "# Bitwise OR\n",
    "print(16 | 10)\n",
    "\n",
    "# Bitwise XOR\n",
    "print(26 ^ 2)\n",
    "\n",
    "# Bitwise NOT\n",
    "print(~4)\n",
    "\n",
    "# Bitwise signed right shift\n",
    "print(24 >> 2)\n",
    "\n",
    "# Bitwise zero fill left shift\n",
    "print(12 << 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.8. Unary Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-5\n",
      "-10\n",
      "True\n",
      "-6\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = -10\n",
    "z = False\n",
    "\n",
    "# Negative\n",
    "print(-x)\n",
    "\n",
    "# Unchanged\n",
    "print(+y)\n",
    "\n",
    "# Not\n",
    "print(not z)\n",
    "\n",
    "# Bitwise NOT\n",
    "print(~x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Homework\n",
    "#### Using only pen and paper, compute the output of the following Python statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question 1\n",
    "print(47 & 55)\n",
    "\n",
    "# Question 2\n",
    "print(59 | 44)\n",
    "\n",
    "# Question 3\n",
    "print(16 ^ 12)\n",
    "\n",
    "# Question 4\n",
    "print(131 // 8)\n",
    "\n",
    "# Question 5\n",
    "print(0b1110101)\n",
    "\n",
    "# Question 6\n",
    "print((2 + 2) ** (2 + 2))\n",
    "\n",
    "# Question 7\n",
    "print(10 * 10 + 2 * (100 / 10))\n",
    "\n",
    "# Question 8\n",
    "print(11 & 13 * 2 ** 3)\n",
    "\n",
    "# Question 9\n",
    "print((1000 % 30 ^ 17 % 3 ** (1 + 1)) ** 8)\n",
    "\n",
    "# Question 10\n",
    "print((~bool(None)) ** 2 << 4)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}