Day 1/python-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "acd9ab69",
   "metadata": {
    "id": "fe6b3f6d",
    "papermill": {
     "duration": 0.008983,
     "end_time": "2022-10-18T16:30:38.038563",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.029580",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Introduction \n",
    "* Python is a general purpose high level programming language.\n",
    "* Python was developed by Guido Van Rossam in 1989 while working at National Research Institute at Netherlands.\n",
    "* But officially Python was made available to public in 1991."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c51c78e",
   "metadata": {
    "id": "0f12591b",
    "papermill": {
     "duration": 0.007466,
     "end_time": "2022-10-18T16:30:38.053948",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.046482",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### Hello World in Python\n",
    "\n",
    "Syntax : print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2f77091",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.071484Z",
     "iopub.status.busy": "2022-10-18T16:30:38.071002Z",
     "iopub.status.idle": "2022-10-18T16:30:38.088515Z",
     "shell.execute_reply": "2022-10-18T16:30:38.086968Z"
    },
    "id": "21e802a4",
    "outputId": "c57f6a41-82bd-41da-a1f5-7e89cfe575e3",
    "papermill": {
     "duration": 0.029437,
     "end_time": "2022-10-18T16:30:38.091155",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.061718",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26da09ba",
   "metadata": {
    "id": "5166e9da",
    "papermill": {
     "duration": 0.010506,
     "end_time": "2022-10-18T16:30:38.114076",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.103570",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# IDENTIFIERS\n",
    "* A Name in Python Program is called Identifier.\n",
    "* It can be Class Name OR Function Name OR Module Name OR Variable Name.\n",
    "* a = 10\n",
    "\n",
    "### Rules to define Identifiers in Python:\n",
    "* alphabet symbols(either lower case or upper case), digits(0 to 9), and underscore symbol(_) are allowed characters in python.\n",
    "* Identifier should not start with numbers\n",
    "* Identifiers are case sensitive.\n",
    "* We cannot use reserved words as identifiers.\n",
    "\n",
    "\n",
    "#### Note:\n",
    "* If identifier starts with _ symbol then it indicates that it is private\n",
    "* If identifier starts with __(Two Under Score Symbols) indicating that strongly private identifier.\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "465ebe8c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.135209Z",
     "iopub.status.busy": "2022-10-18T16:30:38.134210Z",
     "iopub.status.idle": "2022-10-18T16:30:38.139615Z",
     "shell.execute_reply": "2022-10-18T16:30:38.138580Z"
    },
    "id": "fb17b39a",
    "papermill": {
     "duration": 0.019424,
     "end_time": "2022-10-18T16:30:38.141949",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.122525",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Examples for some valid and invalid identifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68730c87",
   "metadata": {
    "id": "67df8e28",
    "papermill": {
     "duration": 0.008026,
     "end_time": "2022-10-18T16:30:38.160317",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.152291",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# DATA TYPES\n",
    "* Data Type represents the type of data present inside a variable.\n",
    "* In Python we are not required to specify the type explicitly. Based on value provided, the type will be assigned automatically. Hence Python is dynamically Typed Language.\n",
    "\n",
    "### Python contains the following inbuilt data types\n",
    "    1) Int\n",
    "    2) Float\n",
    "    3) Complex\n",
    "    4) Bool\n",
    "    5) Str\n",
    "    6) List\n",
    "    7) Tuple\n",
    "    8) Set\n",
    "    9) Frozenset\n",
    "    10) Dict\n",
    "    11) None\n",
    "    \n",
    "* type() method is used to check the type of variable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e4cd9eb",
   "metadata": {
    "id": "98221822",
    "papermill": {
     "duration": 0.008985,
     "end_time": "2022-10-18T16:30:38.177681",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.168696",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 1) int Data Type:\n",
    "*  to represent whole numbers (integral values)\n",
    "* Python directly supports arbitrary precision integers, also called infinite precision integers or bignums, as a top-level construct.\n",
    "* On a 64-bit machine, it corresponds to $2^{64 - 1}$ = 9,223,372,036,854,775,807"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8a406e6b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.197418Z",
     "iopub.status.busy": "2022-10-18T16:30:38.196677Z",
     "iopub.status.idle": "2022-10-18T16:30:38.203210Z",
     "shell.execute_reply": "2022-10-18T16:30:38.202191Z"
    },
    "id": "13640c87",
    "outputId": "cc17d279-43b9-4dd0-ffa1-ff2dc70bd97e",
    "papermill": {
     "duration": 0.018165,
     "end_time": "2022-10-18T16:30:38.205301",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.187136",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Examples of Integer data Type\n",
    "a = 10\n",
    "b = -14\n",
    "c = 43095728934729279823748345345345345453453456345634653434363\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88066023",
   "metadata": {
    "id": "8a3beaaf",
    "papermill": {
     "duration": 0.00778,
     "end_time": "2022-10-18T16:30:38.221171",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.213391",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 2) Float Data Type:\n",
    "* We can use float data type to represent floating point values (decimal values)\n",
    "* We can also represent floating point values by using exponential form\n",
    "        Eg: f = 1.2e3   (instead of 'e' we can use 'E')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5bd43195",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.239194Z",
     "iopub.status.busy": "2022-10-18T16:30:38.238434Z",
     "iopub.status.idle": "2022-10-18T16:30:38.245808Z",
     "shell.execute_reply": "2022-10-18T16:30:38.244370Z"
    },
    "id": "8fc3e8ec",
    "outputId": "4904edd7-5878-4b74-ad44-770836a96f73",
    "papermill": {
     "duration": 0.01918,
     "end_time": "2022-10-18T16:30:38.248231",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.229051",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9\n",
      "904304.0\n",
      "1200.0\n",
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Examples of float data type\n",
    "a = 1.9\n",
    "b = 904304.0\n",
    "c = 1.2e3\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83680b22",
   "metadata": {
    "id": "f867efd7",
    "papermill": {
     "duration": 0.007769,
     "end_time": "2022-10-18T16:30:38.264289",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.256520",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 3) Complex Data Type:\n",
    "* A complex number is of the form : (a + bj) where j = $\\sqrt{-1}$.\n",
    "* we can perform operations on complex type values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b35c951b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.282122Z",
     "iopub.status.busy": "2022-10-18T16:30:38.281684Z",
     "iopub.status.idle": "2022-10-18T16:30:38.289222Z",
     "shell.execute_reply": "2022-10-18T16:30:38.287855Z"
    },
    "id": "104313fc",
    "outputId": "0b03f16d-71b5-4eba-a3d3-12a96f091e6a",
    "papermill": {
     "duration": 0.019063,
     "end_time": "2022-10-18T16:30:38.291358",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.272295",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  (5+7j)\n",
      "b =  (19-3j)\n",
      "<class 'complex'>\n",
      "<class 'complex'>\n",
      "Subtraction is : (-14+10j)\n",
      "Addition is : (24+4j)\n",
      "5.0\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "# Examples of complex data type\n",
    "a = 5 + 7j\n",
    "b = 19 - 3j\n",
    "print('a = ',a)\n",
    "print('b = ',b)\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(f'Subtraction is : {a - b}')\n",
    "print(f'Addition is : {a + b}')\n",
    "# Complex data type has inbuilt attributes imag and real type\n",
    "print(a.real)\n",
    "print(a.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "573e96d6",
   "metadata": {
    "id": "4c4fbf56",
    "papermill": {
     "duration": 0.007817,
     "end_time": "2022-10-18T16:30:38.307412",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.299595",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 4) bool Data Type:\n",
    "* We can use this data type to represent boolean values.\n",
    "* The only allowed values for this data type are: True and False\n",
    "* Internally Python represents True as 1 and False as 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b9838e5d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.325384Z",
     "iopub.status.busy": "2022-10-18T16:30:38.324979Z",
     "iopub.status.idle": "2022-10-18T16:30:38.331417Z",
     "shell.execute_reply": "2022-10-18T16:30:38.330114Z"
    },
    "id": "b37e3f95",
    "outputId": "67240ea1-1e91-42b6-da48-9a86cc11bc42",
    "papermill": {
     "duration": 0.018014,
     "end_time": "2022-10-18T16:30:38.333613",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.315599",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# Examples of bool data type\n",
    "a = True\n",
    "b = False\n",
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12b76d07",
   "metadata": {
    "id": "bf30a884",
    "papermill": {
     "duration": 0.008005,
     "end_time": "2022-10-18T16:30:38.350012",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.342007",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 5) str Data Type:\n",
    "* str represents String data type.\n",
    "* A String is a sequence of characters enclosed within single quotes or double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "210bf341",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.368281Z",
     "iopub.status.busy": "2022-10-18T16:30:38.367859Z",
     "iopub.status.idle": "2022-10-18T16:30:38.373557Z",
     "shell.execute_reply": "2022-10-18T16:30:38.372190Z"
    },
    "id": "cef0e43d",
    "outputId": "35f46e3a-1bf0-41db-e767-29ddac8b5766",
    "papermill": {
     "duration": 0.017514,
     "end_time": "2022-10-18T16:30:38.375800",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.358286",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lets code...\n"
     ]
    }
   ],
   "source": [
    "# Examples\n",
    "a = \"Lets code...\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef8a9d9d",
   "metadata": {
    "id": "87e24b67",
    "papermill": {
     "duration": 0.008024,
     "end_time": "2022-10-18T16:30:38.392314",
     "exception": false,
     "start_time": "2022-10-18T16:30:38.384290",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "* By using single quotes or double quotes we cannot represent multi line string literals.\n",
    "* For this requirement we should go for triple single quotes(''') or triple double quotes(\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a7701745",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-10-18T16:30:38.410738Z",
     "iopub.status.busy": "2022-10-18T16:30:38.410290Z",
     "iopub.status.idle": "2022-10-18T16:30:38.417791Z",
     "shell.execute_reply": "2022-10-18T16:30:38.416031Z"
    },
    "id": "0656e54b",
    "outputId": "9323bf26-d72a-4443-aa2c-f6a3c3c3ba2f",
    "papermill": {
     "duration": 0.019103,
     "end_time": "2022-10-18T16:30:38.419658",
     "exception": true,
     "start_time": "2022-10-18T16:30:38.400555",
     "status": "failed"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (3804588111.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_19/3804588111.py\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    b = \"Lets\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "b = \"Lets\n",
    "    code\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c2d92be",
   "metadata": {
    "id": "e42bfac8",
    "outputId": "b0110986-dfe8-4f5d-c1c1-73f93792fa87",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "b = '''Lets\n",
    "    code'''\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dce53aa",
   "metadata": {
    "id": "6952e06d",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "#### Slicing of Strings:\n",
    "    1) slice means a piece\n",
    "    2) [ ] operator is called slice operator, which can be used to retrieve parts of String.\n",
    "    3) In Python Strings follows zero based index.\n",
    "    4) The index can be either +ve or -ve.\n",
    "    5) +ve index means forward direction from Left to Right\n",
    "    6) -ve index means backward direction from Right to Left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb4e9c25",
   "metadata": {
    "id": "9b31ee54",
    "outputId": "415b92f0-aeaf-48e5-d60c-246a4a351dba",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = \"Let's code great and change the world\"\n",
    "print(\"a[0] : \", a[0])\n",
    "print(\"a[15] : \", a[15])\n",
    "print(\"a[-1] : \", a[-1])\n",
    "print(\"a[:5]\", a[:5])\n",
    "print(\"a[7:14] : \", a[7:14])\n",
    "\n",
    "b = \"Lets Code\"\n",
    "print(b*3)\n",
    "print(len(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b1e3ed",
   "metadata": {
    "id": "648a4747",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "## TYPE CASTING\n",
    "* We can convert one type value to another type. This conversion is called Typecasting.\n",
    "* The following are various inbuilt functions for type casting.\n",
    "        1) int()\n",
    "        2) float()\n",
    "        3) complex()\n",
    "        4) bool()\n",
    "        5) str()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70224d6b",
   "metadata": {
    "id": "62434834",
    "outputId": "9d59cdc7-2b33-4e09-e3e1-de6d626df08b",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(int(3434.554))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c62ce134",
   "metadata": {
    "id": "c1dd9127",
    "outputId": "4d54e622-92a7-4eb2-a1cf-7cf515850db0",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(int(6 + 6j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "805c626e",
   "metadata": {
    "id": "1aa33352",
    "outputId": "3d915504-111b-466c-f6a1-7cba3b5d886b",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(str(32423))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a53003a1",
   "metadata": {
    "id": "f6e8efd5",
    "outputId": "5292ee1c-9b7e-41c8-bd11-e0014fe1e39c",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(int(\"five\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2a8ee63",
   "metadata": {
    "id": "25b27090",
    "outputId": "fb722ae8-a98b-4eb0-bed0-b32f167dd75a",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(int(\"2345\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f86bc39",
   "metadata": {
    "id": "2f643866",
    "outputId": "488cc31d-eb23-4997-ef76-ae3a4bdc6af4",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(float(244))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce59422d",
   "metadata": {
    "id": "11a4dff2",
    "outputId": "02ee853e-9c1b-4f68-a99f-d8c7d719f17d",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(bool(0))\n",
    "print(bool(2324))\n",
    "print(bool(-34))\n",
    "print(bool(0.0))\n",
    "print(bool(7.8))\n",
    "print(bool(\"False\"))\n",
    "print(bool(\"True\"))\n",
    "print(bool(\"Lets code\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed092e6e",
   "metadata": {
    "id": "ca6b770d",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 6) List Data Type:\n",
    "* Lists are used to store multiple items in a single variable.\n",
    "* Lists are created using square brackets\n",
    "* List items are ordered, changeable, and allow duplicate values.\n",
    "* List items are indexed, the first item has index [0], the second item has index [1] etc.\n",
    "* When we say that lists are ordered, it means that the items have a defined order, and that order will not change.\n",
    "* If you add new items to a list, the new items will be placed at the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a31eddc7",
   "metadata": {
    "id": "29c3e85e",
    "outputId": "817d1538-72d5-4389-b904-3bc0d511044e",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "listt = [5, 6, 'hello', 5.76]\n",
    "print(listt)\n",
    "print(listt[0])\n",
    "print(listt[2])\n",
    "\n",
    "listt.append(376)\n",
    "\n",
    "print(listt)\n",
    "\n",
    "\n",
    "# Iterating over list\n",
    "for i in listt:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66b52ab6",
   "metadata": {
    "id": "83036706",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 7) Tuple Data Type:\n",
    "* Tuples are used to store multiple items in a single variable.\n",
    "* A tuple is a collection which is ordered and unchangeable.\n",
    "* Tuples are written with round brackets.\n",
    "* Tuple items are ordered, unchangeable, and allow duplicate values.\n",
    "* Tuple items are indexed, the first item has index [0], the second item has index [1] etc.\n",
    "* Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b331b62d",
   "metadata": {
    "id": "6d3a05ac",
    "outputId": "1432d068-67ef-46aa-d4b6-c879f65086c0",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "tuple1 = (\"abc\", 34, True, 40, \"male\")\n",
    "print(tuple1)\n",
    "print(tuple[0])\n",
    "print(tuple[3])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e285e14",
   "metadata": {
    "id": "f90ce494",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 8) set Data Type:\n",
    "* Sets are used to store multiple items in a single variable.\n",
    "* A set is a collection which is unordered, unchangeable*, and unindexed.\n",
    "* Sets are written with curly brackets.\n",
    "* Sets are unordered, so you cannot be sure in which order the items will appear.\n",
    "* Set items are unchangeable, but you can remove items and add new items.\n",
    "* Set items can appear in a different order every time you use them, and cannot be referred to by index or key.\n",
    "* Sets cannot have two items with the same value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "224cfa6b",
   "metadata": {
    "id": "6b3e7950",
    "outputId": "05a58322-f904-4ec2-dce9-f242d2197d02",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "set1 = {\"abc\", 34, True, 40, \"male\", 40}\n",
    "print(set1)\n",
    "set1.add(67)\n",
    "print(set1)\n",
    "set1.remove(\"abc\")\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a6872ab",
   "metadata": {
    "id": "ad24e0ad",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 9) frozenset Data Type:\n",
    "* It is exactly same as set except that it is immutable.\n",
    "* Hence we cannot use add or remove functions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa50ffb8",
   "metadata": {
    "id": "7ba2d002",
    "outputId": "0cf281cd-2b85-42f0-9862-18e70e8f4b6a",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "s={10,20,30,40}\n",
    "frozen_set=frozenset(s)\n",
    "print(type(frozen_set))\n",
    "print(frozen_set)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60dd7720",
   "metadata": {
    "id": "0f80c164",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 10) dict Data Type:\n",
    "* Dictionaries are used to store data values in key:value pairs.\n",
    "* A dictionary is a collection which is ordered*, changeable and do not allow duplicates.\n",
    "* Dictionaries are written with curly brackets, and have keys and values.\n",
    "* Dictionary items are ordered, changeable, and does not allow duplicates.\n",
    "* Dictionary items are presented in key:value pairs, and can be referred to by using the key name.\n",
    "* Dictionaries cannot have two items with the same key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea6625d6",
   "metadata": {
    "id": "19399cd4",
    "outputId": "8869af90-2af8-41ad-879c-8d7579e0c0c9",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "dict1 = {\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "\n",
    "print(dict1)\n",
    "print(dict1[\"colors\"])\n",
    "print(dict1[\"colors\"][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "312c9a95",
   "metadata": {
    "id": "6221c41b",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "### 11) None Data Type:\n",
    "* None means nothing or No value associated.\n",
    "* If the value is not available, then to handle such type of cases None introduced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "912aba95",
   "metadata": {
    "id": "cdd8ba31",
    "outputId": "59065fbb-8d4a-436b-d194-8295cac50ae0",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def sum(a,b):\n",
    "    c = a + b\n",
    "\n",
    "s = sum(5,7)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60366155-b8a6-4278-aeda-ae77d43982f4",
   "metadata": {
    "id": "f260bdf4",
    "papermill": {
     "duration": null,
     "end_time": null,
     "exception": null,
     "start_time": null,
     "status": "pending"
    },
    "tags": []
   },
   "source": [
    "# Operators\n",
    "\n",
    "Operators in Python are special symbols that perform specific operations on one or more operands (values or variables). Operators are used to perform mathematical or logical operations on variables and values.\n",
    "\n",
    "There are various types of operators in Python, including:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f2de00-708f-43cc-a99f-5f86e2df1e61",
   "metadata": {},
   "source": [
    "### Arithmetic operators: \n",
    "These operators perform basic mathematical operations such as addition, subtraction, multiplication, and division.\n",
    "1. Addition (+): The addition operator adds two operands and returns the sum.\n",
    "2. Subtraction (-): The subtraction operator subtracts the second operand from the first and returns the difference.\n",
    "3. Multiplication (*): The multiplication operator multiplies two operands and returns the product.\n",
    "4. Division (/): The division operator divides the first operand by the second and returns the quotient.\n",
    "5. Modulus (%): The modulus operator returns the remainder of the division of the first operand by the second.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8bf753bb-0237-4b54-93c0-fcb9b5e97283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "50\n",
      "2.0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 5\n",
    "z = x + y # Addition operator\n",
    "print(z) # Output: 15\n",
    "z1 = x - y\n",
    "print(z1) # Output: 5\n",
    "z2 = x * y\n",
    "print(z2) # Output: 50\n",
    "z3 = x / y\n",
    "print(z3) # Output: 2.0\n",
    "z4 = x % y\n",
    "print(z4) # Output: 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "be32b674-56df-4c0e-93da-3e301132f6fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 5\n",
    "z = (x + y) * 2 # Addition and multiplication are executed first\n",
    "print(z) # Output: 30"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6712c83-5bf5-43ff-8ce4-73f4058a00ea",
   "metadata": {},
   "source": [
    "### Comparison/Logical/Assignment operators: \n",
    "These operators compare two operands and return a Boolean value (True or False) based on the comparison.\n",
    "\n",
    "There are various comparison operators in Python, including:\n",
    "\n",
    "1. Greater than (>)\n",
    "2. Less than (<)\n",
    "3. Greater than or equal to (>=)\n",
    "4. Less than or equal to (<=)\n",
    "5. Equal to (==)\n",
    "6. Not equal to (!=)\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8f755aee-b9bc-4c22-9a42-db3a6e94b103",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 5\n",
    "z = x > y # Greater than operator\n",
    "print(z) # Output: True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9b8025bf-ec4f-4e66-89b8-c3584f3851c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 10\n",
    "c = a < b # Less than operator\n",
    "print(c) # Output: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0756521a-1463-4fa8-ac4e-16b077bd6905",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "p = 5\n",
    "q = 5\n",
    "r = p == q # Equal to operator\n",
    "print(r) # Output: True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0107300e-db39-4077-9e78-2943914a562e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "s = 5\n",
    "t = 6\n",
    "u = s != t # Not equal to operator\n",
    "print(u) # Output: True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462245b6-c9cb-45dd-bed0-79421c4d9358",
   "metadata": {},
   "source": [
    "### Bitwise operators: \n",
    "\n",
    "Bitwise operators in Python are special operators that perform bit-level operations on integers. These operators work by performing operations on the individual bits of an integer value.\n",
    "\n",
    "There are several bitwise operators in Python, including:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3332ba87-c119-49c3-a160-80c1adedb78b",
   "metadata": {},
   "source": [
    "1. AND (&): This operator performs a bit-level AND operation on two integers. It returns a new integer where each bit is set to 1 if both operand bits are 1, otherwise it is set to 0.\n",
    "\n",
    "\n",
    "Example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5b9eca52-3baa-401b-a42e-a377a9c7f08a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "x = 10 # Binary representation: 1010\n",
    "y = 5 # Binary representation: 0101\n",
    "z = x & y # Binary representation: 0000\n",
    "print(z) # Output: 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22b93506-541c-44db-b9ed-d332e708c2f3",
   "metadata": {},
   "source": [
    "2. OR (|): This operator performs a bit-level OR operation on two integers. It returns a new integer where each bit is set to 1 if either operand bit is 1, otherwise it is set to 0.\n",
    "\n",
    "\n",
    "Example:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ca2fcb05-1ecb-4ced-8e73-b7c8ecf260e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x = 10 # Binary representation: 1010\n",
    "y = 5 # Binary representation: 0101\n",
    "z = x | y # Binary representation: 1111\n",
    "print(z) # Output: 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47cbbbed-973b-48c5-871f-45cb075de49a",
   "metadata": {},
   "source": [
    "3. XOR (^): This operator performs a bit-level XOR operation on two integers. It returns a new integer where each bit is set to 1 if one operand bit is 1 and the other operand bit is 0, otherwise it is set to 0.\n",
    "\n",
    "\n",
    "Example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "edb8830b-0611-473e-9c0a-66188b040874",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x = 10 # Binary representation: 1010\n",
    "y = 5 # Binary representation: 0101\n",
    "z = x ^ y # Binary representation: 1111\n",
    "print(z) # Output: 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df4dcac4-2a10-4793-97e2-c2cf43364484",
   "metadata": {},
   "source": [
    "4. NOT (~): This operator performs a bit-level NOT operation on an integer. It returns a new integer where each bit is set to 1 if the operand bit is 0, and vice versa.\n",
    "\n",
    "\n",
    "Example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a025eec2-22f3-4ac9-8460-8fac062e1777",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-11\n"
     ]
    }
   ],
   "source": [
    "\n",
    "x = 10 # Binary representation: 1010\n",
    "y = ~x # Binary representation: 0101\n",
    "print(y) # Output: -11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbf82c44-d143-41cf-a048-24e1a9052190",
   "metadata": {},
   "source": [
    "5. Left shift (<<): This operator shifts the bits of an integer value to the left by a specified number of places. The leftmost bits are lost and replaced with 0s.\n",
    "\n",
    "\n",
    "Example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3d64b0bb-8a9b-4be6-b427-6397c299e0b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "x = 10 # Binary representation: 1010\n",
    "y = x << 2 # Binary representation: 101000\n",
    "print(y) # Output: 40"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f8e9121-35cc-489c-acf6-508e1a2ea791",
   "metadata": {},
   "source": [
    "6. Right shift (>>): This operator shifts the bits of an integer value to the right by a specified number of places. The rightmost bits are lost and replaced with 0s or 1s depending on the sign of the integer.\n",
    "\n",
    "Example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "384217d2-1bec-4d91-8c21-d641e953dc7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 10 # Binary representation: 1010\n",
    "y = x >> 2 # Binary representation: 0010\n",
    "print(y) # Output: 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934f21ad-94d4-4557-9e60-f3c350714b6b",
   "metadata": {},
   "source": [
    "# Exercise Question you will find in Exercise notebook of Day 1 on GitHub."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ec883e1-eaad-4258-bd60-9b15a812ff57",
   "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.9.15"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 9.992632,
   "end_time": "2022-10-18T16:30:39.049485",
   "environment_variables": {},
   "exception": true,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-10-18T16:30:29.056853",
   "version": "2.3.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}