Basic_Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "# single comment\n",
    "# hello will printing on screen\n",
    "print(\"hello\")  # single statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Syntax :\n",
    "\n",
    "---> THe Structure of writing an instructions / rules for writing an instructions with in the program\n",
    "\n",
    "# Program :-\n",
    "\n",
    "---> Collection of instructions to do any one specific task\n",
    "\n",
    "# Instruction :-\n",
    "\n",
    "---> A line of code with in the program\n",
    "\n",
    "# Type of Instructions :-\n",
    "\n",
    "---> Based on exceuiton of instructions with int the programs we have 2 kind of instrcutions\n",
    "\n",
    "   1. comments :-\n",
    "   ----------------\n",
    "          ======> Whatever the instructions which can't be executable by CPU\n",
    "          \n",
    "          ======> To give the brief explanation each abd every statements\n",
    "          \n",
    "          1. single line comment ======>>>     #\n",
    "          \n",
    "          2. Multiline comment  ======>>>     '''     '''\n",
    "   2. statemnets :- \n",
    "   -----------------\n",
    "          ======> Whatever the instructions which can be excutable by CPU\n",
    "          \n",
    "          1. single statement\n",
    "          \n",
    "          2. multiple statements\n",
    "          \n",
    "          3. Multiline statement\n",
    "          \n",
    "          4. Compound statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Hi\n",
      "Bye\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "the below example is used for to understand multiple statement\n",
    "'''\n",
    "print(\"hello\") ; print(\"Hi\") ; print(\"Bye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Hi\n",
      "Bye\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "The below one is used for to understand multiline statement\n",
    "'''\n",
    "print(\"\"\"hello\n",
    "Hi\n",
    "Bye\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello Hi Bye\n"
     ]
    }
   ],
   "source": [
    "print('hello \\\n",
    "Hi \\\n",
    "Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keywords\n",
    "\n",
    "----> The names which are already defined in python interpreter\n",
    "\n",
    "----> Predefined / Built Names\n",
    "\n",
    "----> Each and every keyword it was designed specific task\n",
    "\n",
    "----> The count of the keywords can change version to cersion\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "************************\n",
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n",
      "************************\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "import keyword    # importing all the keywords from keyword library of python.\n",
    "print(\"************************\")\n",
    "print(keyword.kwlist)    # print out the keyword list\n",
    "print(\"************************\")\n",
    "print(len(keyword.kwlist))  # Number of keywords in python interpreter is 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identifier\n",
    "\n",
    "----> User Defined Words / Programmer Words\n",
    "\n",
    "----> To Give the name Entities for variable, functions and class\n",
    "\n",
    "# Rules\n",
    "\n",
    "---> WE can use alphabets [a - z / A - Z ]\n",
    "\n",
    "---> we can use digits [ 0- 9 ]\n",
    "\n",
    "---> WE can use underscore _ \n",
    "\n",
    "---> Don't use as a !st letter as a digit\n",
    "\n",
    "---> Don't use keywords\n",
    "\n",
    "---> Don't use special characters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python Variable\n",
    "print(\"id of 10 : \",id(10))\n",
    "print(\"id of 20 : \",id(20))\n",
    "print(\"id of 30 : \",id(30))\n",
    "\n",
    "# ---> An identifier it can be used to reference the memmory location\n",
    "\n",
    "# ---> We can easily access the data from memmory location\n",
    "\n",
    "# ---> We don't need any variable declaration \n",
    "\n",
    "# ---> simply we can assign the data to Identitfier\n",
    "\n",
    "var = 10\n",
    "print(\"id of var : \",id(var))\n",
    "var = 20\n",
    "print(\"id o var : \",id(var))\n",
    "var = 30\n",
    "print(\"id of var : \",id(var))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "varAI = 12;print(varAI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "_varA = 12\n",
    "print(_varA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-10-1137b7cd2b64>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-10-1137b7cd2b64>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    9var = 123\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "9var = 123 # any identifier can't be start with number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-740cfd4adc01>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-11-740cfd4adc01>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    var@ = 123\u001b[0m\n\u001b[1;37m         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "var@ = 123\n",
    "print(var@) # the identifier var@ is containing @ which is not under rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-12-b2245a128438>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-b2245a128438>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    while = 123\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "while = 123 # here the identifier is functional keyword which is also not under rule."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Data Types : \n",
    "\n",
    "---> In case python all datatypes are predefined class\n",
    "\n",
    "---> The real data is called object\n",
    "\n",
    "---> To specify what type of data holded by variable \n",
    "\n",
    "\n",
    "# Types\n",
    "\n",
    "1. Fundamental Datatype\n",
    "\n",
    "   ---> A single Variable can hold single data element\n",
    "   \n",
    "        1. int\n",
    "        2. float\n",
    "        3. bool\n",
    "        4. complex\n",
    "        5. None\n",
    "2. Sequential Datatype\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id  :   140719674501184\n",
      "data  :   10\n",
      "<class 'int'>\n",
      "size of var  :   28\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "\n",
    "    ---> A single variable can hold single data element\n",
    "    \n",
    "        1. int\n",
    "        2. float\n",
    "        3. bool\n",
    "        4. complex\n",
    "        5. None\n",
    "'''\n",
    "# Integer variable\n",
    "var = 10\n",
    "print(\"id  :  \", id(var))\n",
    "print(\"data  :  \", var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id  :   1924892492784\n",
      "data  :   10.667\n",
      "<class 'float'>\n",
      "size of var  :   24\n"
     ]
    }
   ],
   "source": [
    " # float variable\n",
    "var = 10.667\n",
    "print(\"id  :  \",id(var))\n",
    "print(\"data  :  \",var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id  :   140719674218320\n",
      "data  :   True\n",
      "<class 'bool'>\n",
      "size of var  :   28\n",
      "id  :   140719674218352\n",
      "data  :   False\n",
      "<class 'bool'>\n",
      "size of var  :   24\n"
     ]
    }
   ],
   "source": [
    "# Boolean variable\n",
    "var = True\n",
    "print(\"id  :  \",id(var))\n",
    "print(\"data  :  \",var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())\n",
    "var = False\n",
    "print(\"id  :  \",id(var))\n",
    "print(\"data  :  \",var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id  :   1924892493168\n",
      "data  :   (10+3j)\n",
      "<class 'complex'>\n",
      "size of var  :   32\n"
     ]
    }
   ],
   "source": [
    "# complex variable\n",
    "var = 10 + 3j\n",
    "print(\"id  :  \",id(var))\n",
    "print(\"data  :  \",var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id  :   140719674267776\n",
      "data  :   None\n",
      "<class 'NoneType'>\n",
      "size of var  :   16\n"
     ]
    }
   ],
   "source": [
    "# None type varibale\n",
    "var = None\n",
    "print(\"id  :  \",id(var))\n",
    "print(\"data  :  \",var)\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "size of var  :   16\n"
     ]
    }
   ],
   "source": [
    "def fun(var = None):\n",
    "    print(var)\n",
    "fun()\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seqeuntial Datatype : \n",
    "\n",
    "---> A single variabe can hold multiple data elemnets\n",
    "\n",
    "---> there are 5 datatypes\n",
    "\n",
    "   1. str\n",
    "   \n",
    "   2. list\n",
    "   \n",
    "   3. tuple\n",
    "   \n",
    "   4. dict\n",
    "   \n",
    "   5. set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string varibale\n",
    "'''\n",
    "---> collection of character is called string\n",
    "\n",
    "---> we group the n no of characters with in '     '/ \"      \" / '''         '''/ \"\"\"        \"\"\"\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  python\n",
      "<class 'str'>\n",
      "1924860601264\n",
      "size of var  :   55\n"
     ]
    }
   ],
   "source": [
    "var = 'python'\n",
    "print(\"data with in var : \",var)\n",
    "print(type(var))\n",
    "print(id(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  python\n",
      "<class 'str'>\n",
      "1924860601264\n",
      "size of var  :   55\n"
     ]
    }
   ],
   "source": [
    "var = \"python\"\n",
    "print(\"data with in var : \",var)\n",
    "print(type(var))\n",
    "print(id(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  python\n",
      "<class 'str'>\n",
      "1924860601264\n",
      "size of var  :   55\n"
     ]
    }
   ],
   "source": [
    "var = '''python'''\n",
    "print(\"data with in var : \",var)\n",
    "print(type(var))\n",
    "print(id(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  python\n",
      "<class 'str'>\n",
      "1924860601264\n"
     ]
    }
   ],
   "source": [
    "var = \"\"\"python\"\"\"\n",
    "print(\"data with in var : \",var)\n",
    "print(type(var))\n",
    "print(id(var))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  [12, 45.45, (78+4j), True, None, 'python']\n",
      "1924892143680\n",
      "<class 'list'>\n",
      "size of var  :   88\n"
     ]
    }
   ],
   "source": [
    "# List data type : \n",
    "'''\n",
    "---> group of elemnets we can store with square brackest []\n",
    "'''\n",
    "var = [12, 45.45, 78+4j, True, None, 'python']\n",
    "print(\"data with in var : \", var)\n",
    "print(id(var))\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 90 (4+5j) None True\n",
      "data with in var :  [12, 45.45, (78+4j), True, None, 'python']\n",
      "1924892143680\n",
      "<class 'list'>\n",
      "size of var  :   88\n"
     ]
    }
   ],
   "source": [
    "# tuple datatype: \n",
    "'''\n",
    "---> group of elements we can store with in parenthesis ()\n",
    "\n",
    "'''\n",
    "print(12, 34 +56, 4+5j, None, True)\n",
    "print(\"data with in var : \",var)\n",
    "print(id(var))\n",
    "print(type(var))\n",
    "print(\"size of var  :  \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  {True, None, 12, (7+5j), 56.67}\n",
      "1924892501376\n",
      "<class 'set'>\n",
      "size of var :  712\n"
     ]
    }
   ],
   "source": [
    "# set datatype :\n",
    "'''\n",
    "---> group of elements we can store with in curly braces {}\n",
    "\n",
    "'''\n",
    "var = {12, 56.67, True, 7 + 5j, None}\n",
    "print(\"data with in var : \",var)\n",
    "print(id(var))\n",
    "print(type(var))\n",
    "print(\"size of var : \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  {12: 'python', 34: 'c', 89: 'jhgfr'}\n",
      "1924893196672\n",
      "<class 'dict'>\n",
      "size of var :  216\n"
     ]
    }
   ],
   "source": [
    "# dict datatype : \n",
    "'''\n",
    "---> a group of elements we can store with in curly braces\n",
    "\n",
    "---> the elements which is combination of keys and values\n",
    "\n",
    "---> it can be used for to maintain the records\n",
    "\n",
    "     Examples : \n",
    "        \n",
    "        1. Students\n",
    "        \n",
    "        2. Employees\n",
    "---> dict is unorder datatype\n",
    "\n",
    "'''\n",
    "var = {12:\"python\", 34:\"c\", 89:\"jhgfr\" }\n",
    "print(\"data with in var : \", var)\n",
    "print(id(var))\n",
    "print(type(var))\n",
    "print(\"size of var : \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  {12: 'pyton', 34: 'c', 89: 'jhgfr'}\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-44-e29042e66518>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m# Its unorder datatype so it can't support indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# but we can access values by keys\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvar\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "var = {12:\"pyton\", 34:\"c\", 89:\"jhgfr\" }\n",
    "print(\"data with in var : \",var)\n",
    "# Its unorder datatype so it can't support indexing\n",
    "# but we can access values by keys\n",
    "print(var[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data with in var :  {12: 'pyton', 34: 'c', 89: 'jhgfr'}\n",
      "pyton\n",
      "jhgfr\n"
     ]
    }
   ],
   "source": [
    "var = {12:\"pyton\", 34:\"c\", 89:\"jhgfr\" }\n",
    "print(\"data with in var : \",var)\n",
    "# Its unorder datatype so it can't support indexing\n",
    "# but we can access values by keys\n",
    "print(var[12])\n",
    "print(var[89])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam\n",
      "len of a :  50\n",
      "max char :  y\n",
      "min char :   \n",
      " Ascii value of y is :  121\n",
      "Ascii value of space is :  32\n",
      "character for 65 :  A\n",
      "character for 121 :  y\n"
     ]
    }
   ],
   "source": [
    "a = 'Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam'\n",
    "print(a)\n",
    "print(\"len of a : \",len(a))\n",
    "print(\"max char : \",max(a))\n",
    "print(\"min char : \",min(a))\n",
    "print(\"Ascii value of y is : \",ord('y'))\n",
    "print(\"Ascii value of space is : \",ord(\" \"))\n",
    "print(\"character for 65 : \",chr(65))\n",
    "print(\"character for 121 : \",chr(121))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n",
      "K\n"
     ]
    }
   ],
   "source": [
    "b = 'Akshay Kumar'\n",
    "print(b[5])\n",
    "print(b[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam\n",
      "l Sonu Niga\n",
      "l Sonu Nigam\n",
      "Akshay Kumar Salman Khan Jubin Nautiyal Sonu Niga\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a[38:49])\n",
    "print(a[38:]) # stops ---> len of str\n",
    "print(a[:49])  #start ---> 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akshay Kumar Salman Khan Jubin Nautiyal Sonu Nigam\n",
      "yalKJ iSN\n",
      "y Kumar Salman Khan Jubin Nautiyal Sonu Niga\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a[5:48:5])\n",
    "print(a[5:49:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-58-0c687e8bc3bc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# str is immautable data type means we can't able to modify\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;31m# the existing data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'S'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# str is immautable data type means we can't able to modify\n",
    "# the existing data\n",
    "a[0] = 'S'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman Shahrukh \n",
      "Salman Shahrukh \n"
     ]
    }
   ],
   "source": [
    "a = 'Salman '\n",
    "b = 'Shahrukh '\n",
    "print(a+b)\n",
    "print(a.__add__(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman Salman Salman \n",
      "Salman Salman Salman \n"
     ]
    }
   ],
   "source": [
    "a = 'Salman '\n",
    "       #  b = 'Shahrukh '\n",
    "print(a*3)\n",
    "print(a.__mul__(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = 'Salman'\n",
    "print(len(a))\n",
    "print(a.__len__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 'Salman'\n",
    "b = 'Shahrukh'\n",
    "print(a>b)\n",
    "print(a.__gt__(b))\n",
    "print(a<b)\n",
    "print(a.__lt__(b))\n",
    "print(a==b)\n",
    "print(a.__eq__(b))\n",
    "print(a!=b)\n",
    "print(a.__ne__(b))\n",
    "print(a>=b)\n",
    "print(a.__ge__(b))\n",
    "print(a<=b)\n",
    "print(a.__le__(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 'Khan'\n",
    "b =  \"Shahrukh Khan\"\n",
    "print(a in b)\n",
    "print(b.__contains__(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman khan sk\n",
      "Salman Khan SK\n"
     ]
    }
   ],
   "source": [
    "# print(help(str.capitalize))\n",
    "a = \"Salman Khan SK\"\n",
    "print(a.capitalize())\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SALMAN KHAN SK\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = \"Salman Khan SK\"\n",
    "print(a.upper())\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salman khan sk\n",
      "Salman Khan SK\n"
     ]
    }
   ],
   "source": [
    "print(a.lower())\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman Khan SK\n",
      "sALMAN kHAN sk\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a.swapcase())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman Khan SK\n",
      "Salman Khan Sk\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a.title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman Khan S\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "a = \"Salman Khan S\"\n",
    "print(a)\n",
    "print(a.count('a'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Salman Khan S\n"
     ]
    }
   ],
   "source": [
    "print(a.index('a'))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Salman', 'Khan', 'S']\n",
      "Salman Khan S\n"
     ]
    }
   ],
   "source": [
    "print(a.split())\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salman * Shahrukh * Aamir\n"
     ]
    }
   ],
   "source": [
    "a = ['Salman','Shahrukh','Aamir']\n",
    "print(' * '.join(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = \"SALMAN khan\"\n",
    "print(a.isupper())\n",
    "a = \"SALMAN KHAN\"\n",
    "print(a.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any string : Abhishek Kumar Srivastava\n",
      "<class 'str'>\n",
      "1658071267808\n",
      "size of var :  74\n"
     ]
    }
   ],
   "source": [
    "# print function and input function\n",
    "\n",
    "var = input(\"Enter any string : \")\n",
    "print(type(var))\n",
    "print(id(var))\n",
    "print(\"size of var : \",var.__sizeof__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 'super DUPER'\n",
    "print(a.islower())\n",
    "a = 'SUPER DUPER'\n",
    "print(a.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 'super DUPER'\n",
    "print(a.istitle())\n",
    "a = 'Super Duper'\n",
    "print(a.istitle())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 'superDUPER'\n",
    "print(a.isalpha())\n",
    "a = 'SUPER DUPER123@#'\n",
    "print(a.isalpha())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = '1234'\n",
    "print(a.isdigit())\n",
    "a = '123 A'\n",
    "print(a.isdigit())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 'superDUPER'\n",
    "print(a.isalnum())\n",
    "a = '123456789'\n",
    "print(a.isalnum())\n",
    "a = 'super1234'\n",
    "print(a.isalnum())\n",
    "a = 'Super Duper'\n",
    "print(a.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*Super*'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Super'\n",
    "a.center(7,'*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00Super'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Super'\n",
    "a.zfill(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Datatype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  []\n",
      "id =  1658070398144\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# empty list\n",
    "a = []\n",
    "print(\"a = \",a)\n",
    "print(\"id = \",id(a))\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [12, 34, 56, 78]\n",
      "id =  1658070400256\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# list with int datatype elements\n",
    "a = [12, 34, 56, 78]\n",
    "print(\"a = \",a)\n",
    "print(\"id = \",id(a))\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [12, 45.67, (7+6j), True, None]\n",
      "id =  1658070228160\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "#Hetro list\n",
    "a = [12,45.67, 7+6j, True, None]\n",
    "print(\"a = \",a)\n",
    "print(\"id = \",id(a))\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  ['top', [1, 2, 3]]\n",
      "id =  1658070436992\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# nested list\n",
    "'''\n",
    "with in the list we can store any seq datatype elements\n",
    "\n",
    "'''\n",
    "a = ['top',[1,2,3]]\n",
    "print(\"a = \",a)\n",
    "print(\"id = \",id(a))\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[34, 45]\n",
      "34\n",
      "[12, 45]\n"
     ]
    }
   ],
   "source": [
    "# mutable datatype \n",
    "a = [34, 45]\n",
    "print(a)\n",
    "print(a[0])\n",
    "a[0] = 12\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 4, 90, 23, 56, 12, 89, 4, 8]\n",
      "[90, 23, 56, 12]\n"
     ]
    }
   ],
   "source": [
    "# list slicing\n",
    "a = [6, 4, 90 , 23, 56, 12, 89, 4 , 8]\n",
    "print(a)\n",
    "print(a[2:6]) # start ---> 0 / stop ---> len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 4, 45, 55, 65, 75, 89, 4, 8]\n"
     ]
    }
   ],
   "source": [
    "# slicing assignment\n",
    "a[2:6] = [45, 55, 65, 75]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 4, 45, 55, 65, 75, 89, 4, 8]\n",
      "[6, 45, 65, 89, 8]\n",
      "[6, 55, 89]\n"
     ]
    }
   ],
   "source": [
    "# Dicing\n",
    "print(a)\n",
    "print(a[0:9:2])\n",
    "print(a[0:9:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 45, 10, 65, 75, 100, 4, 8]\n"
     ]
    }
   ],
   "source": [
    "# dicing assignment\n",
    "a[0:9:3] = [1, 10, 100]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 45, 10, 65, 75, 100, 4, 8]\n",
      "9\n",
      "100\n",
      "1\n",
      "312\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(len(a))\n",
    "print(max(a))\n",
    "print(min(a))\n",
    "print(sum(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# list special methods\n",
    "a = [1,2,3]\n",
    "b = [4,5,6]\n",
    "print(a+b)\n",
    "print(a.__add__(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(2 in a)\n",
    "print(a.__contains__(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(a<b)\n",
    "print(a.__lt__(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a.append(2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 2]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a.count(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "b.clear()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[1, 2, 3, 2]\n",
      "[1, 2, 3, 2]\n",
      "[1, 2, 3, 2]\n",
      "[1, 2, 3, 2, 100]\n",
      "[1, 2, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "print(a)\n",
    "b = a.copy()\n",
    "print(b)\n",
    "print(a)\n",
    "b.append(100)\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6]\n",
      "[1, 2, 3, 2]\n",
      "[4, 5, 6, 1, 2, 3, 2]\n",
      "[1, 2, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "c = [4,5,6]\n",
    "print(c)\n",
    "print(a)\n",
    "c.extend(a)\n",
    "print(c)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6, 1, 2, 3, 2]\n",
      "2\n",
      "[4, 5, 6, 1, 2, 3]\n",
      "1\n",
      "[4, 5, 6, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(c)\n",
    "print(c.pop())   # index  ----> -1\n",
    "print(c)\n",
    "print(c.pop(3))    # index  ---> 3\n",
    "print(c)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}