Day1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6332f113-d709-43c4-b0ad-2490d9423297",
   "metadata": {},
   "source": [
    "<h1> Python Basics - Data Types and Control Structures </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80d58692-4bf4-4407-aea8-dfbdf69d7683",
   "metadata": {},
   "source": [
    "### Learning agenda of this notebook\n",
    "\n",
    "- **Introduction to Python(Why, and what Python)**\n",
    "- **Code Editor and IDE, why jupyter Notebook?**\n",
    "- **Variables in Python**\n",
    "- **Datatypes**\n",
    "- **Comments in Python**\n",
    "- **Operators in Python**\n",
    "- **Python Indentation**\n",
    "- **Branching with `if`, `else`, and `elif`**\n",
    "- **The `pass` statement**\n",
    "- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3a57d99-7c18-489a-a343-f4603d4d4699",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0a8eb236-c884-49e7-831e-96214ae82b0f",
   "metadata": {},
   "source": [
    "<h2 align=center style=\"color:red;\">  Introduction to Python  </h2>\n",
    "\n",
    "#### History\n",
    "\n",
    "- Python is an interpreted, general-purpose, high-level programming language.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"images/python-features.png\" height=500px width=500px align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5148b75-f860-45bb-b08e-783397875ab4",
   "metadata": {},
   "source": [
    "### Importance of Python\n",
    "\n",
    "<img align=\"center\" width=\"900\" height=\"800\"  src=\"images/1_RtbFZYTMO9nptOxNSQdUTw.png\" > "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2755ced-9ca4-4d78-bdc3-232513b4517b",
   "metadata": {},
   "source": [
    "### Important Libraries and Frame Works\n",
    "\n",
    "<img align=\"center\" width=\"600px\" height=\"500px\"  src=\"images/5.jpg\" >\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f7cff98-6760-4064-9ca5-ec94dbca7b18",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21ec0bcf-c8fa-4c6d-811f-86243c396f1d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "acdd1c8f-ad49-4bf7-80cc-75c82f1f6020",
   "metadata": {},
   "source": [
    "### Applications of Python\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"images/python-applications.png\" height=500px width=500px>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c997135-03b0-4725-b4b6-8739d91809e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d13f329f-62b8-4c41-a6aa-68be9d837f52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "690e70ea-d05c-44ac-9cf8-37b43f8f1808",
   "metadata": {},
   "source": [
    "<h2 align=center style=\"color:red;\"> Introduction to Jupyter Notebook </h2>\n",
    "\n",
    "\n",
    "<img src=\"images/code_ide.png\" height=500px width=500px>\n",
    "\n",
    "#### What is Jupyter Notebook\n",
    "\n",
    "- Jupyter Notebook is an open-source, web-based interactive environment, which allows you to create and share documents that contain live code, mathematical equations, graphics, maps, plots, visualizations, and narrative text. It integrates with many programming languages like Python, PHP, R, C#, etc. Jupyter Notebook mainly used for Python because Python is used with Artificial Intelligence (AI), Machine learning, as well as Deep learning.\n",
    "- Notebook is a single document where you can run code, display the output, and also add explanations, formulas, charts, and make your work more transparent, understandable, repeatable, and shareable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cbb86b0-48b9-47d3-adb2-baf440575fce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4952e509-9c86-415e-9d7e-917dc0d506f7",
   "metadata": {},
   "source": [
    "<h2 align=center style=\"color:red;\">  Variables in Python  </h2>\n",
    "\n",
    "\n",
    "- **print() Function / Built-in function**\n",
    "- **Variables in Python**\n",
    "    - Variables Names\n",
    "    - What is variable\n",
    "    - Declaring Variables and Assigning Values\n",
    "    - Object References\n",
    "    - Object Identity\n",
    "    - Multiple Assignments\n",
    "    - Python Variables Types\n",
    "    - Delete a variable\n",
    "    - Maximum possible value of integer in python\n",
    "    - Print single and multiple variables in python\n",
    "- **Python Data Types**\n",
    "    - Immutable\n",
    "    - Mutable\n",
    "- **Input(), int(), float() functions**\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"images/Python-Variables.jpg\" height=500px width=500px>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e4f6325f-ad14-40b7-a3d4-8b9deb2951f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1194b417-f24e-46cf-92e9-e5c04137c466",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "54b560e2-d115-43ed-8f3e-2ba445a781a6",
   "metadata": {},
   "source": [
    "#### Python `print()` Function\n",
    "- This function prints the given `object` on the screen or other `standard output devices`.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "\n",
    "\n",
    "print(object(s) , sep= separator, end=end)\n",
    "\n",
    "- `object(s)`: It is an object to be printed. The Symbol * indicates that there may be more than one object.\n",
    "- `sep` ='separator' (optional): The objects are separated by sep. The default value of sep is “ ”.\n",
    "- `end` = 'end' (optional): it determines which object should be print at last.\n",
    "\n",
    "\n",
    "<img src=\"images/print-func.png\" height=500px width=500px>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6f0ba484-0015-494d-9f5b-9ce74c9ab155",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method vs Function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b52c10cc-5035-43b8-8d1b-626cff7d9015",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning Practical Data Science\n"
     ]
    }
   ],
   "source": [
    "print(\"Learning Practical Data Science\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5efbebd0-8ff7-4673-ac45-da2f54390fbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning Practical Data Science\n"
     ]
    }
   ],
   "source": [
    "print('Learning Practical Data Science')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "37ecfa9e-3c44-40d2-9cb0-771cebc062ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Learning Practical Data Science'\n",
    "print(type(str1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7e45c668-6879-433e-9fa0-6c8c32d6e70a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning Practical Data Science\n"
     ]
    }
   ],
   "source": [
    "print(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eeec0852-55d1-4f46-b434-88dd9b6392e9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a36d5fe7-95cc-47f4-8092-9f696d2a1431",
   "metadata": {},
   "source": [
    "#### 1. what is a variable and variable names\n",
    "\n",
    "- . Python variable is also known as an identifier and used to hold value.\n",
    "\n",
    "\n",
    "<img src=\"images/variable-rules.jpg\" height=500px width=500px>\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ae335060-4ebb-44e0-bf6a-54cca75c597d",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Ali\"\n",
    "NAME = \"Ehtisham\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0a996ff1-8136-476b-911d-1e9696add5f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Ali', 'Ehtisham')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name, NAME"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c27de347-1d8b-4220-9dcf-8265d763f97a",
   "metadata": {},
   "source": [
    "#### 2. Declaring Variable and Assigning Values\n",
    "Python does not bind us to declare a variable before using it in the application. It allows us to create a variable at the required time.\n",
    "The equal (=) operator is used to assign value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1538c9b0-dd03-493a-a9fb-58c9e003930d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Syntax of C++\n",
    "# int age;\n",
    "# age = 23;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "612b7041-5bf5-4d3f-8ad0-c7b69ee186eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Ali\"\n",
    "NAME = \"Ehtisham\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "d6e00d0a-10c0-4164-abc4-dba14e6d77cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "fe3437fe-07d2-4906-9ad8-772725ef4738",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Suleman'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1e5b10-f936-4a3c-bfdd-3c5c3d08c0b6",
   "metadata": {},
   "source": [
    "#### 3. Object References\n",
    "- It is necessary to understand how the Python interpreter works when we declare a variable. The process of treating variables is somewhat different from many other programming languages.\n",
    "- In python, each variable belongs to specific data type or class.\n",
    "- To check the type of variable , we use a Python built-in `type()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "28a338ca-3434-4b2d-bed6-54c34f63122e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 50\n",
    "# -infinity to +infinity\n",
    "#  the variable a refers to an integer object.\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306ab246-c5ee-40f0-8ca1-abe1db5fad0c",
   "metadata": {},
   "source": [
    "<img src=\"images/var-1.png\" height=200px width=200px>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "fa1aede8-753e-49d7-a9d4-97de8936454f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4340855432\n",
      "4340855432\n"
     ]
    }
   ],
   "source": [
    "# Suppose we assign the integer value 50 to a new variable b.\n",
    "a = 50\n",
    "b = a\n",
    "print(id(a))\n",
    "print(id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdab6c5-bab7-4995-91ec-6fda6dd81c07",
   "metadata": {},
   "source": [
    "<img src=\"images/var-2.png\" height=200px width=200px>\n",
    "\n",
    "\n",
    "\n",
    "The variable `b` refers to the same object that `a` points to, because Python does not create another object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0db59c5a-7adb-4628-a002-c96223b960c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4340855432\n",
      "4340857032\n"
     ]
    }
   ],
   "source": [
    "# Let's assign the new value to b. Now both variables will refer to the different objects.\n",
    "a = 50\n",
    "b = 100\n",
    "print(id(a))\n",
    "print(id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b385960c-3dcc-4b8c-b056-05eab1a3dcd5",
   "metadata": {},
   "source": [
    "#### 5. Multiple Assignment\n",
    "Python allows us to assign a value to multiple variables in a single statement, which is also known as multiple assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a16ebf84-c83d-4cce-8291-fbf3fcf6d19e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# statement vs expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "83f2a1c8-af5d-4dd1-9023-b4ab6208e27b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "40\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "x = y = z = 40 # single statement\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9a64edd7-03a7-4393-be25-9fb069729c0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lahore\n",
      "21\n",
      "3.43\n"
     ]
    }
   ],
   "source": [
    "##### Assigning multiple values to multiple variables\n",
    "x , y, z = \"Lahore\", 21, 3.43 # single statement\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6713c164-3198-42ee-b092-6f2b00e33090",
   "metadata": {},
   "source": [
    "#### Deleting a Variable\n",
    "\n",
    "- We can delete the variable using the `del` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "75885550-a874-48c1-815c-071e7d141957",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# Assigning a value to x  \n",
    "x = 6  \n",
    "\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "7e01855e-b330-4e70-ab3f-49a30362d5d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "del x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "a4b4d267-2502-42fe-954e-74806e0011a3",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' 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[44], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m x\n",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64fa4f72-c667-4282-b1bd-6499e7457ec8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8708a0be-fca6-422e-a352-c7e40ae94130",
   "metadata": {},
   "source": [
    "#### Maximum Possible Value of an Integer in Python\n",
    "Unlike the other programming languages, Python doesn't have long int or float data types. It treats all integer values as an int data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3eb26562-ec8c-4b65-9f6b-96fe02f66dfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "10000000000000000000000000000000000000000001\n"
     ]
    }
   ],
   "source": [
    "# A Python program to display that we can store large numbers in Python  \n",
    "  \n",
    "a = 10000000000000000000000000000000000000000000\n",
    "\n",
    "a = a + 1  \n",
    "print(type(a))  \n",
    "print (a) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "411ead6d-87f1-46b7-ae00-75baedfbdda0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6c4e6ff-d66a-4b93-a8dc-39dbee80ddbd",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" style = \"color:red\">Python Data Types</h1>\n",
    "\n",
    "\n",
    "<img src=\"images/7.jpeg\" height=600px width=600px>\n",
    "\n",
    "\n",
    "- Variables can hold values, and every value has a data-type. Python is a dynamically typed language; hence we do not need to define the type of the variable while declaring it. The interpreter implicitly binds the value with its type.\n",
    "- The variable `a` holds integer value `five` and we did not define its type. Python interpreter will automatically interpret variables `a` as an integer type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "8abcd07f-446e-4890-99c3-00581de0bfe6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a = 10\n",
    "# a = '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "a0311745-6b68-43f1-a70b-e481ed69662a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "types of x is <class 'int'>\n",
      "types of a is <class 'int'>\n",
      "types of b is <class 'str'>\n",
      "types of c is <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "a = 10  \n",
    "b = \"Hi Python\"  \n",
    "c = 10.5  \n",
    "print(f\"types of x is {type(x)}\")\n",
    "print(f\"types of a is {type(a)}\")\n",
    "print(f\"types of b is {type(b)}\")\n",
    "print(f\"types of c is {type(c)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41c0cd45-8434-47b6-ad80-9132619a9a15",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a30cca13-c60d-4e47-97cf-dbc190fbd9b6",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" style = \"color:red\">Comments in Python </h1>\n",
    "\n",
    "\n",
    "<img src=\"images/comment-1.png\" height=400px width=400px align=\"left\">\n",
    "<img src=\"images/comment-2.png\" height=400px width=400px align=\"right\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "8e2134e3-e86f-4952-b2cd-617f4caa267c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# `a` is integer type variable\n",
    "a = 23\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd5eb702-8820-488c-93aa-1cee7a0a14b2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7ae38c1b-40c3-4536-bb95-5e9e908deb44",
   "metadata": {},
   "source": [
    "###  Conversion/Type Casting\n",
    "\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "\n",
    "<img src=\"images/type-casting.png\" height=400px width=400px align=right>\n",
    "<img src=\"images/type_casting.jpg\" height=350px width=350px align=left>\n",
    "\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "- **Implicit Type Conversion:** While performing arithmetic operations, integers are automatically converted to `float` if any of the operands is a `float`. Also, the division operator `/` always returns a `float`, even if both operands are integers. Use the `//` operator if you want the result of the division to be an `int`.\n",
    "\n",
    "- **Explicit Type Conversion or Type Casting** refers to the conversion of an object from one data type to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "dba4dd04-0f89-4350-a951-86bc18b171b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95.2\n"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "\n",
    "marks = 74.2\n",
    "\n",
    "c = age + marks\n",
    "\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "cdf3d57a-73aa-4846-ad5e-32ccee3f6a7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "63711621-59aa-4895-bddd-f3f31f90132e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[51], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m age \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m21\u001b[39m\n\u001b[1;32m      2\u001b[0m name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEhtisham\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 3\u001b[0m age \u001b[38;5;241m+\u001b[39m name\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "age = 21\n",
    "name = \"Ehtisham\"\n",
    "age + name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "320657e8-0cbf-477f-a420-6460cf074859",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'21Ehtisham'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = str(age)\n",
    "age + name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89fcb1f0-61b8-4732-92d0-f3302ac3e37e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1391e64e-6339-4c51-98c9-7da1a743c581",
   "metadata": {},
   "source": [
    "###  Explicit Type Conversion (Type Casting)\n",
    "\n",
    "\n",
    "<img src=\"images/Tye-Conversion-and-Type-Casting-in-Python.jpg\" height=450px width=450px>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "577b0093-064b-4111-a702-39d6694c8a3d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "94da8fb7-a050-433c-980c-04b298b95460",
   "metadata": {},
   "source": [
    "#### Working of `input()` Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "21930de4-85b8-4022-acf9-0b58785af78d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  Ehtisham\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Ehtisham'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = input(\"Enter your name: \")\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "10a9894b-9f53-4ca5-aa51-4fb5bcd8ee76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "9616a673-e0d4-4d43-a360-86bc831e6b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age :  23\n"
     ]
    }
   ],
   "source": [
    "age = int(input(\"Enter your age : \")) # returns a string value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "b01b543d-5990-4dbb-9f83-43a78341b51d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "fc0bcdb6-8eee-4ad4-8cf3-8f137decf8ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "246d0353-a9ca-41be-9727-f64f4bad4fc3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edeaf0f6-cc5c-4f40-b7cb-6a161c0c8e9b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "20998709-7b6b-467f-8e10-781234420d42",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" style = \"color:red\">Operators in Python </h1>\n",
    "\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "<img src=\"images/operator.png\" height=300px width=300px align=\"left\">\n",
    "<img align=\"center\" width=\"400px\" height=\"250px\"  src=\"images/operators.png\" align= \"right\">\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "The operator can be defined as a symbol which is responsible for a particular operation between two operands. Operators are the pillars of a program on which the logic is built in a specific programming language. Python provides a variety of operators, which are described as follows.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fc6e27b-e2c7-483e-b6ec-556711344cf5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3de6585c-bcd9-4028-8190-5135f3a60115",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24510c0a-5b04-432b-9c9e-b79ae9332afe",
   "metadata": {},
   "source": [
    "### i. Arithmetic operators in Python\n",
    "- Arithmetic operators are used to perform arithmetic operations between two operands.\n",
    "- Python supports the following arithmetic operators:\n",
    "\n",
    "| Operator   | Purpose           | Example     | Result    |\n",
    "|------------|-------------------|-------------|-----------|\n",
    "| `+`        | Addition          | `2 + 3`     | `5`       |\n",
    "| `-`        | Subtraction       | `3 - 2`     | `1`       |\n",
    "| `*`        | Multiplication    | `8 * 12`    | `96`      |\n",
    "| `/`        | Division          | `100 / 7`   | `14.28..` |\n",
    "| `//`       | Floor Division    | `100 // 7`  | `14`      |    \n",
    "| `%`        | Modulus/Remainder | `100 % 7`   | `2`       |\n",
    "| `**`       | Exponent          | `5 ** 3`    | `125`     |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "edb8edc3-6ed6-47cc-b3a2-ecdda863d192",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x + y = 13\n",
      "x - y = 7\n",
      "x * y = 30\n",
      "x / y = 3.3333333333333335\n",
      "x // y = 3\n",
      "x ** y = 1000\n",
      "x % y = 1\n"
     ]
    }
   ],
   "source": [
    "# Here x and y are operands\n",
    "x = 10\n",
    "y = 3\n",
    "\n",
    "# Output: x + y \n",
    "print('x + y =',x+y)\n",
    "\n",
    "# Output: x - y \n",
    "print('x - y =',x-y)\n",
    "\n",
    "# Output: x * y \n",
    "print('x * y =',x*y)\n",
    "\n",
    "# Output: x / y \n",
    "print('x / y =',x/y)\n",
    "\n",
    "# Floor Division: Output: x // y \n",
    "print('x // y =',x//y)\n",
    "\n",
    "# Output: x ^ y \n",
    "# Ouput of Exponent\n",
    "print('x ** y =',x**y)\n",
    "# x = 10 , y =3 , 1000\n",
    "\n",
    "# Output: x % y \n",
    "print('x % y =',x%y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b978f264-e495-4942-8c68-18f445f5f607",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ed7d3847-6911-4ef3-9b9b-3d194b8dda85",
   "metadata": {},
   "source": [
    "### ii.Assignment Operators\n",
    "- The assignment operators are used to assign the value of the right expression to the left operand.\n",
    "- Python supports the following Assignment operators:\n",
    "- If a = 10, b = 20\n",
    "\n",
    "| Operator | Description | Representation | Example | Result |\n",
    "|----------|-------------|----------------|---------|--------|\n",
    "| =        | It assigns the value of the right expression to the left operand | = | a=b | 20 |\n",
    "| +=       | It increases the value of the left operand by the value of the right operand and assigns the modified value back to left operand. | a+ = b will be equal to a = a+ b | a+=b | 30 |\n",
    "| -=       | It decreases the value of the left operand by the value of the right operand and assigns the modified value back to left operand. | a- = b will be equal to a = a- b  | a-=b | -10 |\n",
    "| *=       | It multiplies the value of the left operand by the value of the right operand and assigns the modified value back to then the left operand. | a*=b will be equal to a = a*b | a*=b | 200 |\n",
    "| %=       | It divides the value of the left operand by the value of the right operand and assigns the reminder back to the left operand. | a%=b will be equala to a = a%b | a%=b | 1 |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a45d5b71-05fc-4501-900c-3f0c6385a29c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "4\n",
      "20\n",
      "4.0\n",
      "1024.0\n"
     ]
    }
   ],
   "source": [
    "#Assignment operators in Python\n",
    "x = 4\n",
    "x += 5    # <->  x = x + 5\n",
    "print(x)\n",
    "\n",
    "#    x = x - 5\n",
    "x -= 5      \n",
    "print(x)\n",
    "\n",
    "#    x = x * 5\n",
    "x *= 5     \n",
    "print(x)\n",
    "\n",
    "#    x = x / 5\n",
    "x /= 5  \n",
    "print(x)\n",
    "\n",
    "\n",
    "x **= 5      \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08211970-45e1-45bd-a98e-0d918b290462",
   "metadata": {},
   "source": [
    "### iii. Identity Operators in Python\n",
    "- Identity operators are used to compare the ID of objects (not their values)\n",
    "- Returns True if both objects refer to same memory location\n",
    "- The two identity operators in Python are `is` and `is not`.\n",
    "\n",
    "\n",
    "| Operator | Description |\n",
    "|----------|-------------|\n",
    "| is       | It is evaluated to be true if the reference present at both sides point to the same object. |\n",
    "| is not   | It is evaluated to be true if the reference present at both sides do not point to the same object. |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "23354902-837b-4506-aa72-22ee70c62d7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4340853992\n",
      "4412278896\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Identity operators in Python\n",
    "a = 5\n",
    "b = 5.0\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(a is b) # compare IDs\n",
    "print(a == b) # COMPARE VALUES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f02409dd-d506-42aa-96e3-27719cb48254",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "593d3b48-2b67-4efd-ab39-ac93fa7d7112",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4a4f7eeb-ab22-4378-83b4-023c691114da",
   "metadata": {},
   "source": [
    "### iv. Membership Operators\n",
    "- Python membership operators are used to check the membership of value inside a Python data structure. If the value is present in the data structure, then the resulting value is true otherwise it returns false.\n",
    "\n",
    "\n",
    "| Operator | Description |\n",
    "|----------|-------------|\n",
    "| in       | It is evaluated to be true if the first operand is found in the second operand (list, tuple, or dictionary). |\n",
    "| not in   | It is evaluated to be true if the first operand is not found in the second operand (list, tuple, or dictionary). |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b42e13da-ad24-45a3-a200-c971ed662b40",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Ehtisham Sadiq\"\n",
    "a = 'a'\n",
    "b = 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a9114180-2cf4-40f4-9363-bd421f51d51f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# check `a` in name\n",
    "rv = a in name\n",
    "print(rv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4f35e747-47d9-4b10-8b46-26f22da4c2b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# check `b` in name\n",
    "rv = b in name\n",
    "print(rv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a99f33a2-adc1-4866-b7c6-d581d743953e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "413908d5-7d35-4820-9ba9-214fa7cb796f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd88e048-4694-4e40-9dd6-034e85c88528",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04a638ab-8837-40d2-abec-e8a262a54b88",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ddca3811-b0cf-4316-ab69-2d1ceb6d0355",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Suleman\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57afcec7-b71d-4d70-854c-a0c2c9a0a465",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "52ea0585-fa9c-4ad6-bf51-77adc85738e2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        body {\n",
       "            background-color: #f2fff2;\n",
       "        }\n",
       "        h1 {\n",
       "            text-align: center;\n",
       "            font-weight: bold;\n",
       "            font-size: 36px;\n",
       "            color: #4295F4;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 15px;\n",
       "        }\n",
       "        \n",
       "        h2 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #4A000A;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 10px;\n",
       "        }\n",
       "        \n",
       "        h3 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #f0081e;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 5px;\n",
       "        }\n",
       "\n",
       "        \n",
       "        p {\n",
       "            text-align: center;\n",
       "            font-size: 12 px;\n",
       "            color: #0B9923;\n",
       "        }\n",
       "    </style>\n",
       "\n",
       "<h1>Hello</h1>\n",
       "<p>Hello World</p>\n",
       "<h2> Hello</h2>\n",
       "<h3> World </h3>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "\n",
    "style = \"\"\"\n",
    "    <style>\n",
    "        body {\n",
    "            background-color: #f2fff2;\n",
    "        }\n",
    "        h1 {\n",
    "            text-align: center;\n",
    "            font-weight: bold;\n",
    "            font-size: 36px;\n",
    "            color: #4295F4;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 15px;\n",
    "        }\n",
    "        \n",
    "        h2 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #4A000A;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 10px;\n",
    "        }\n",
    "        \n",
    "        h3 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #f0081e;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 5px;\n",
    "        }\n",
    "\n",
    "        \n",
    "        p {\n",
    "            text-align: center;\n",
    "            font-size: 12 px;\n",
    "            color: #0B9923;\n",
    "        }\n",
    "    </style>\n",
    "\"\"\"\n",
    "\n",
    "html_content = \"\"\"\n",
    "<h1>Hello</h1>\n",
    "<p>Hello World</p>\n",
    "<h2> Hello</h2>\n",
    "<h3> World </h3>\n",
    "\"\"\"\n",
    "\n",
    "HTML(style + html_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d6cf79e-2549-4169-81df-d481e2ae7e59",
   "metadata": {},
   "outputs": [],
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}