Day6_List_in_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5d026391",
   "metadata": {},
   "source": [
    "## Lists\n",
    "In Python, Lists can be considered as the most general version of a \"sequence\". \n",
    "\n",
    "Unlike strings, they are mutable which means the elements inside a list can be changed!\n",
    "\n",
    "Lists are constructed with brackets [] and commas separating every element in the list.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7ad62ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign a list to an variable named my_list\n",
    "my_list = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "125c501b",
   "metadata": {},
   "source": [
    "We just created a list of integers, but lists can actually hold different object types, different data-types. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a2287e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['A string', 23, 100.54,'D', True]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9156226",
   "metadata": {},
   "source": [
    "Just like strings, the len() function will tell you how many items are in the sequence of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1753da58",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a7894603",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A string', 23, 100.54, 'D', True]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "45483461",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1,2,3,4,5]\n",
    "\n",
    "A[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6a4a9c4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1,2,3,4,5.0, \"Sunil\", 1+2j, True] \n",
    "\n",
    "type(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f5fb7643",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5.0 Sunil (1+2j) True "
     ]
    }
   ],
   "source": [
    "for element in A:\n",
    "    print(element, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a92dab68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4a249c25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5.0 Sunil (1+2j) True "
     ]
    }
   ],
   "source": [
    "for i in range(len(A)):\n",
    "    print(A[i],end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c65fd0db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " i = 0, value = 1, datatype = <class 'int'>\n",
      " i = 1, value = 2, datatype = <class 'int'>\n",
      " i = 2, value = 3, datatype = <class 'int'>\n",
      " i = 3, value = 4, datatype = <class 'int'>\n",
      " i = 4, value = 5.0, datatype = <class 'float'>\n",
      " i = 5, value = Sunil, datatype = <class 'str'>\n",
      " i = 6, value = (1+2j), datatype = <class 'complex'>\n",
      " i = 7, value = True, datatype = <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(A)):\n",
    "    print(f\" i = {i}, value = {A[i]}, datatype = {type(A[i])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7f56865",
   "metadata": {},
   "source": [
    "Que-What is the difference between list of python and array of C or C++?\n",
    "\n",
    "Ans-In array element only one dataype in python list all elements can be of different or same dataype."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc68767a",
   "metadata": {},
   "source": [
    "## Indexing and Slicing\n",
    "Indexing and slicing of lists works just like in Strings. \n",
    "Similar to string, list index starts at 0 and it can be sliced and concatenated and all operations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f5df3cf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = ['one','two','three',4, 5, True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e587e39d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab element at index 0\n",
    "new_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "22af331d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['two', 'three', 4, 5, True]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab index 1 and everything past it\n",
    "new_list[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c74c18bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab everything UP TO index 3\n",
    "new_list[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "82978793",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Negative slicing\n",
    "new_list[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "76067c20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5.0, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "28e0eadd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5.0, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "514462e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5.0, (1+2j)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0::2] # [start index: end index: STEP]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d62770cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "2 3\n",
      "4 5.0\n",
      "6 (1+2j)\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 8, 2):    # start, end, steps\n",
    "    print(i, A[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1b86a15d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5.0, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1ac45b63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, (1+2j), 'Sunil', 5.0, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9ccdbdf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, 'Sunil', 4, 2]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e8964fe1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "2 3\n",
      "4 5.0\n",
      "6 (1+2j)\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(A), 2):\n",
    "    print(i, A[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "06fa0d3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 2\n",
      "2 3\n",
      "3 4\n",
      "4 5.0\n",
      "5 Sunil\n",
      "6 (1+2j)\n",
      "7 True\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(A)):\n",
    "    print(i, A[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "051e102e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 True\n",
      "-2 (1+2j)\n",
      "-3 Sunil\n",
      "-4 5.0\n",
      "-5 4\n",
      "-6 3\n",
      "-7 2\n",
      "-8 1\n"
     ]
    }
   ],
   "source": [
    "for i in range(-1, -len(A) - 1, -1):\n",
    "    print(i, A[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7a9d418e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5.0, (1+2j)]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9de1e486",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 'Sunil', True]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "17ab523d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5.0, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "6d92dc61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "5 Sunil\n",
      "6 (1+2j)\n",
      "7 True\n"
     ]
    }
   ],
   "source": [
    "for i in [1,5,6,7]:\n",
    "    print(i, A[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "973eb288",
   "metadata": {},
   "source": [
    "## Updating list element at specific index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "de2a451e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New value at index 5 : 6\n"
     ]
    }
   ],
   "source": [
    "new_list[5] = 6\n",
    "print(f\"New value at index 5 : {new_list[5]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6fb95c5",
   "metadata": {},
   "source": [
    "We can also use \"+\" to concatenate lists, just like we did for Strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ec8d9f2e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 6, 'new item', 5]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list + ['new item',5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf73c33",
   "metadata": {},
   "source": [
    "**Note: This doesn't actually change the original list!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b34ff8b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 6]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb34206f",
   "metadata": {},
   "source": [
    "* In this case, you have to reassign the list to make the permanent change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2b8eeddd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reassign\n",
    "new_list = new_list + ['add new item permanently']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "77e4aa68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 6, 'add new item permanently']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3b1d0bd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5.0, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "dfca2eef",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[4] = 999 # mutable operation allowed in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a2c5225b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 999, 'Sunil', (1+2j), True]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5ac91698",
   "metadata": {},
   "outputs": [],
   "source": [
    "A[-2] = \"Data Scientist\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fa8580c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 999, 'Sunil', 'Data Scientist', True]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "aa5950b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "B = [75, 92, 140.35]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e992881e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 999, 'Sunil', 'Data Scientist', True, 75, 92, 140.35]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "d12bb588",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "731a6c7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 999, 'Sunil', 'Data Scientist', True, 75, 92, 140.35]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2145629e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'list' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [44]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mB\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'list' and 'list'"
     ]
    }
   ],
   "source": [
    "A - B"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b46fb253",
   "metadata": {},
   "source": [
    "## Repeatition of list\n",
    "We can also use the * for a duplication method similar to strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "e5ba6ed6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one',\n",
       " 'two',\n",
       " 'three',\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 'add new item permanently',\n",
       " 'one',\n",
       " 'two',\n",
       " 'three',\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 'add new item permanently']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make the list double\n",
    "new_list * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1b380a1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 6, 'add new item permanently']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Again doubling not permanent\n",
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "28f7e41d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4e6c2b05",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [48]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "A / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "11532c99",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [49]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mA\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'list'"
     ]
    }
   ],
   "source": [
    "A * A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "6a40ed2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "dbb97280",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + A + A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "6b201bfe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * (-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "add43576",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * (-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0bebd4f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35,\n",
       " 1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 999,\n",
       " 'Sunil',\n",
       " 'Data Scientist',\n",
       " True,\n",
       " 75,\n",
       " 92,\n",
       " 140.35]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + 2 * A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a24e8be5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d9b79cb",
   "metadata": {},
   "source": [
    "## Basic List Methods\n",
    "If you are familiar with another programming language, start to draw parallels between lists in Python and arrays in other language. There are two reasons which tells why the lists in Python are more flexible than arrays in other programming language:\n",
    "\n",
    "* They have no fixed size (which means we need not to specify how big the list will be)\n",
    "\n",
    "* They have no fixed type constraint.\n",
    "\n",
    "Special methods for lists:\n",
    "len()\n",
    "length of a list can be calculated using in built len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "38beb98c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [15,25,7,5,\"Data Analytics\", True, False, 95, 105.35]\n",
    "\n",
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4db1d9c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "aeca1ed7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "33c51fae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = [] # NOT RECOMMEDED\n",
    "\n",
    "len(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2a587f15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = list() # RECOMMEDED\n",
    "\n",
    "len(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "38ad2a05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No of item you want to purchase: 4\n",
      "Enter the item that you want to purchase: Notebook\n",
      "Enter the item that you want to purchase: Pen\n",
      "Enter the item that you want to purchase: Sharpner\n",
      "Enter the item that you want to purchase: Pencil\n",
      "['Notebook', 'Pen', 'Sharpner', 'Pencil']\n"
     ]
    }
   ],
   "source": [
    "list_of_item_to_purchase = list() # empty list\n",
    "\n",
    "N = int(input(\"No of item you want to purchase: \"))\n",
    "for i in range(N):\n",
    "    user_input = input(\"Enter the item that you want to purchase: \")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [user_input]\n",
    "\n",
    "print(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "e23aa75b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No of item you want to purchase: 3\n",
      "Enter the item that you want to purchase: Ink bottle\n",
      "Enter the item that you want to purchase: Compass\n",
      "Enter the item that you want to purchase: Eraser\n",
      "['Ink bottle', 'Compass', 'Eraser']\n"
     ]
    }
   ],
   "source": [
    "list_of_item_to_purchase = list() # empty list\n",
    "\n",
    "N = int(input(\"No of item you want to purchase: \"))\n",
    "i = 0\n",
    "while i < N:\n",
    "    user_input = input(\"Enter the item that you want to purchase: \")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [user_input]\n",
    "    i = i + 1\n",
    "print(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a091b008",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 95]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[10, 20, 30, 40] + [95] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "f5bf9ec9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No of item you want to purchase: 4\n",
      "Enter the item that you want to purchase: Geometry Box\n",
      "current i: 1=> Current list: ['Geometry Box']\n",
      "Enter the item that you want to purchase: Sketch Pen\n",
      "current i: 2=> Current list: ['Geometry Box', 'Sketch Pen']\n",
      "Enter the item that you want to purchase: Marker\n",
      "current i: 3=> Current list: ['Geometry Box', 'Sketch Pen', 'Marker']\n",
      "Enter the item that you want to purchase: Drawing Sheet\n",
      "current i: 4=> Current list: ['Geometry Box', 'Sketch Pen', 'Marker', 'Drawing Sheet']\n",
      "['Geometry Box', 'Sketch Pen', 'Marker', 'Drawing Sheet']\n"
     ]
    }
   ],
   "source": [
    "list_of_item_to_purchase = list() # empty list\n",
    "\n",
    "N = int(input(\"No of item you want to purchase: \"))\n",
    "i = 0\n",
    "while i < N:\n",
    "    user_input = input(\"Enter the item that you want to purchase: \")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [user_input]\n",
    "    i = i + 1\n",
    "    print(f\"current i: {i}=> Current list: {list_of_item_to_purchase}\") \n",
    "print(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "499d8599",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb9a7dc0",
   "metadata": {},
   "source": [
    "## Check membership in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e9976503",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if 5 exists in list l\n",
    "5 in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "70cf66c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Mobile Phone cover\" in list_of_item_to_purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "aa96db09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"pen\" in list_of_item_to_purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3e0a6fd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Pen\" in list_of_item_to_purchase # Case sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "21927864",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO, adding into the list\n"
     ]
    }
   ],
   "source": [
    "if \"Mobile Phone cover\" in list_of_item_to_purchase:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO, adding into the list\")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [\"Mobile Phone cover\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e1ff098f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Geometry Box', 'Sketch Pen', 'Marker', 'Drawing Sheet', 'Mobile Phone cover']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_item_to_purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "5a47df0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "YES\n"
     ]
    }
   ],
   "source": [
    "if \"Mobile Phone cover\" in list_of_item_to_purchase:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO, adding into the list\")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [\"Mobile Phone cover\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5ff8d511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NO, adding into the list\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Geometry Box',\n",
       " 'Sketch Pen',\n",
       " 'Marker',\n",
       " 'Drawing Sheet',\n",
       " 'Mobile Phone cover',\n",
       " 'Milk']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if \"Milk\" not in list_of_item_to_purchase:\n",
    "    print(\"NO, adding into the list\")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [\"Milk\"]\n",
    "list_of_item_to_purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "001a8530",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any thing else to add:3\n",
      "NO, adding into the list\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Geometry Box',\n",
       " 'Sketch Pen',\n",
       " 'Marker',\n",
       " 'Drawing Sheet',\n",
       " 'Mobile Phone cover',\n",
       " 'Milk',\n",
       " '3']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_item = input(\"Any thing else to add:\")\n",
    "\n",
    "if new_item not in list_of_item_to_purchase:\n",
    "    print(\"NO, adding into the list\")\n",
    "    list_of_item_to_purchase = list_of_item_to_purchase + [new_item]\n",
    "list_of_item_to_purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0e30edb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acd9e8af",
   "metadata": {},
   "source": [
    "# max()\n",
    "We can find max value from a given list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "898f8096",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ML Engineer\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "list1 = [\"Data Scientist\",\"ML Engineer\",\"Big-data\",\"Data Analytics\"]\n",
    "list2 = [5,6,2,9,7,5,0]\n",
    "print(max(list1))\n",
    "print(max(list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "70aaae70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "999"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example = [1,45,999,10]\n",
    "\n",
    "max(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "57204067",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_example = [\"b\", \"a\", \"d\", \"c\"]\n",
    "\n",
    "max(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "787b5e8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'viraj'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_example = [\"sunil\", \"santosh\", \"viraj\", \"Wonder\", \"Doctor\"]\n",
    "\n",
    "max(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "064e955d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sunil'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_example = [\"sunil\", \"santosh\", \"rahul\", \"ABK\", \"school\", \"Gym\"]\n",
    "\n",
    "max(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "474caea4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABK'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_example = [\"sunil\", \"santosh\", \"rahul\", \"ABK\", \"school\", \"Gym\"]\n",
    "\n",
    "min(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "348485c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GY'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_example = [\"sunil\", \"santosh\", \"K\", \"school\", \"GY\"]\n",
    "\n",
    "min(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "5a2472b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sunil 5\n",
      "santosh 7\n",
      "K 1\n",
      "school 6\n",
      "GY 2\n",
      "RESULT: max_len: 7 name: santosh\n"
     ]
    }
   ],
   "source": [
    "# print the name with highest no of character.\n",
    "\n",
    "max_len = 0\n",
    "result = \"\"\n",
    "for example in string_example:\n",
    "    print(example, len(example))\n",
    "    if len(example) > max_len:\n",
    "        max_len = len(example)\n",
    "        result = example\n",
    "\n",
    "print(f\"RESULT: max_len: {max_len} name: {result}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "cc9d1a9a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [85]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m string_example \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124md\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m]\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mstring_example\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "string_example = [\"b\", \"a\", \"d\", \"c\", \"D\", 1, 2]\n",
    "\n",
    "max(string_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "b626c502",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example = [1, 2, 99.0]\n",
    "\n",
    "max(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "93960aa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example = [1, 2, 99.0, 1000, -500]\n",
    "\n",
    "max(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "d0a13fa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-500"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example = [1, 2, 99.0, 1000, -500]\n",
    "\n",
    "min(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "02aa5564",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'complex' and 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [89]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m example \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m99.0\u001b[39m, \u001b[38;5;241m1\u001b[39m\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m5\u001b[39mj]\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mexample\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'complex' and 'float'"
     ]
    }
   ],
   "source": [
    "example = [1, 2, 99.0, 1+5j]\n",
    "\n",
    "max(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "2f286f1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4000"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example = [1, 2, 99.0, 1000, -500, 200*20]\n",
    "\n",
    "max(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "1c3738cb",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [91]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# In python 3, you can not find max with different data-types in a list\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mmax\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msunil zambare\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: '>' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "# In python 3, you can not find max with different data-types in a list\n",
    "\n",
    "print(max([1,2,\"sunil zambare\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a22f90cd",
   "metadata": {},
   "source": [
    "# min()\n",
    "We can find min value from a given list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "1f0532ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Analytics\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "list1 = [\"Sunil DataScientist\",\"Datascience\",\"Big-data\",\"Analytics\"]\n",
    "list2 = [5,6,2,9,7,5,0]\n",
    "print(min(list1))\n",
    "print(min(list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "a3024a8d",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [93]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# In python 3, you can't find min with different data-types in a list\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28;43mmin\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAnalytics\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "# In python 3, you can't find min with different data-types in a list\n",
    "print(min([1,2,\"Analytics\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "823d2e96",
   "metadata": {},
   "source": [
    "There is another list() method which will helpful to convert tuple into list, which we will look when we will talk about tuple section. Just giving a brief idea, tuple is similar to list but tuple are unmutable means we can't change value of elements and they can define using () bracket. \n",
    "We will look into this in future topics."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "971ab64e",
   "metadata": {},
   "source": [
    "## Append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "05b87498",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a new list\n",
    "l = [1,2,3,5,6,7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9c84a7",
   "metadata": {},
   "source": [
    "Use the append method to permanently add an item to the end of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "0a6f6de4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show or execution\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "4226958c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 77, 'new element']"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1,2,77]\n",
    "\n",
    "A = A + [\"new element\"]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "0ada3d22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 77, 'new element', 'INDIA']"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.append(\"INDIA\")\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "b8da018e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "list.append() takes exactly one argument (2 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [98]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mSantosh\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mTushar\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      3\u001b[0m A\n",
      "\u001b[1;31mTypeError\u001b[0m: list.append() takes exactly one argument (2 given)"
     ]
    }
   ],
   "source": [
    "A.append(\"Santosh\", \"Tushar\")\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "333f5fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 77, 'new element', 'INDIA', ['Santosh', 'Tushar']]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.append([\"Santosh\", \"Tushar\"])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "9041a2d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 77,\n",
       " 'new element',\n",
       " 'INDIA',\n",
       " ['Santosh', 'Tushar'],\n",
       " ['Santosh', 'Tushar']]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.append([\"Santosh\", \"Tushar\"])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "254001d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 77,\n",
       " 'new element',\n",
       " 'INDIA',\n",
       " ['Santosh', 'Tushar'],\n",
       " ['Santosh', 'Tushar'],\n",
       " 'Santosh',\n",
       " 'Tushar']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = A + [\"Santosh\", \"Tushar\"]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "c1e0940c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No of item you want to purchase: 3\n",
      "Enter the item that you want to purchase: Blue Ball Pen\n",
      "Enter the item that you want to purchase: Ruler\n",
      "Enter the item that you want to purchase: Notebook\n",
      "['Blue Ball Pen', 'Ruler', 'Notebook']\n"
     ]
    }
   ],
   "source": [
    "list_of_item_to_purchase = list() # empty list\n",
    "\n",
    "N = int(input(\"No of item you want to purchase: \"))\n",
    "for i in range(N):\n",
    "    user_input = input(\"Enter the item that you want to purchase: \")\n",
    "    list_of_item_to_purchase.append(user_input) # RECOMMENDED\n",
    "\n",
    "print(list_of_item_to_purchase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d869ee7d",
   "metadata": {},
   "source": [
    "# pop()\n",
    "Use pop to \"pop off\" an item from the list. \n",
    "By default pop takes off the last index, but you can also specify which index to pop off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "85720d23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 4, 2, 13]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [7,4,2,13, \"Sunil\"]\n",
    "\n",
    "A.pop()\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "ee1d6949",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 13, 'Sunil']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [7,4,2,13, \"Sunil\"]\n",
    "\n",
    "A.pop(0)\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "853349a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 4, 13, 'Sunil']"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [7,4,2,13, \"Sunil\"]\n",
    "\n",
    "A.pop(2)\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "7759a866",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pop off the 0 indexed item\n",
    "A.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "2524025c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 13, 'Sunil']"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "9e12f627",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sunil'"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "removed_item = A.pop(2)\n",
    "\n",
    "removed_item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "6ea66fe2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 13]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "007286f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "odd num: 1\n",
      "1 37\n",
      "odd num: 37\n",
      "2 76\n",
      "even num: 76\n",
      "3 89\n",
      "odd num: 89\n",
      "4 102\n",
      "even num: 102\n"
     ]
    }
   ],
   "source": [
    "# print odd nos\n",
    "\n",
    "A = [1, 37, 76, 89, 102]\n",
    "\n",
    "for idx in range(len(A)):\n",
    "    num = A[idx]\n",
    "    print(idx, num)\n",
    "    if num%2 != 0:   #odd condition % gives remainder value\n",
    "        print(f\"odd num: {num}\")\n",
    "    else:\n",
    "        print(f\"even num: {num}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "9ddf996b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 7]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show or execution\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "20044799",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign the popped element, remember default popped index is -1\n",
    "popped_item = l.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "ce09f38f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "popped_item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "620a906c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show remaining list\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7469c02",
   "metadata": {},
   "source": [
    "* Note:- lists indexing will return an error if there is no element at that index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "3fc2ae1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 37, 76, 89, 102]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "8f8e919a",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [116]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1000\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "A[1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e00340e0",
   "metadata": {},
   "source": [
    "* We can use the sort method and the reverse methods to also effect your lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "a4fe3af7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-14, -5, -3, 1, 25, 37, 68, 79]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1, 25, 37, 68, 79, -5,-3, -14]\n",
    "\n",
    "sorted(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "2177b351",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 25, 37, 68, 79, -5, -3, -14]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "06e0fcb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-14, -5, -3, 1, 25, 37, 68, 79]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = sorted(A)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "30bd751c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[79, 68, 37, 25, 1, -3, -5, -14]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "96f9ca0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [1, 25, 37, 68, 79, -5,-3, -14]\n",
    "\n",
    "A.sort() # permanent change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "1124c92c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-14, -5, -3, 1, 25, 37, 68, 79]"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "2e1ca27b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[79, 68, 37, 25, 1, -3, -5, -14]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "0374955d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[79, 68, 37, 25, 1, -3, -5, -14]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1, 25, 37, 68, 79, -5,-3, -14]\n",
    "\n",
    "A.sort(reverse=True) # directly get answer in descending order\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "ce134bfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[79, 68, 37, 25, 1, -3, -5, -14]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "534dc6c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "A.reverse() # inplace solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "e4bcf141",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-14, -5, -3, 1, 25, 37, 68, 79]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "d81f1382",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Data Scientist', 'Sunil', 23, 19, 13]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [13, 19, 23, \"Sunil\", \"Data Scientist\"]\n",
    "\n",
    "A = A[::-1]\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "e7c85fd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Big-Data', 'Sunil', 45, 23, 1]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1, 23, 45, \"Sunil\", \"Big-Data\"]\n",
    "\n",
    "A.reverse()\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "39863f0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = ['a','e','x','b','c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "9f64f746",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'e', 'x', 'b', 'c']"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "698ee9c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use reverse to reverse order (this is permanent!)\n",
    "new_list.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "d315850b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'b', 'x', 'e', 'a']"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "766da8d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use sort to sort the list (in this case alphabetical order, but for numbers it will go ascending)\n",
    "new_list.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "7b63122c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'e', 'x']"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301ec2ce",
   "metadata": {},
   "source": [
    "# Nesting Lists\n",
    "Nesting Lists is one of the great features in Python data structures. Nesting Lists means we can have data structures within data structures.\n",
    "\n",
    "For example: A list inside a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "5fb8d3bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's make three lists\n",
    "lst_1=[1,2,3]\n",
    "lst_2=[4,5,6]\n",
    "lst_3=[7,8,9]\n",
    "\n",
    "# Make a list of lists to form a matrix\n",
    "matrix = [lst_1,lst_2,lst_3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "6566f998",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "e385d0b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix[2][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e35835",
   "metadata": {},
   "source": [
    "We can re-use indexing to grab elements, but now there are two levels for the index.\n",
    "\n",
    "* The items in the matrix object\n",
    "\n",
    "* The items inside the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "0463c3d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab first item in matrix object\n",
    "matrix[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "c4d26074",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab first item of the first item in the matrix object\n",
    "matrix[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdcab629",
   "metadata": {},
   "source": [
    "# List Comprehensions\n",
    "Python has an advanced feature called list comprehensions which allows for quick construction of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "b12d70d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a list comprehension by deconstructing a for loop within a []\n",
    "first_col = [row[0] for row in matrix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "fc624eed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7]"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "5df21ba3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "02f84e5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 7]"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_col"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "91eac7cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use normal for loop for the above thing and seperate every element in a single list\n",
    "whole_element = []\n",
    "for row in matrix:\n",
    "    for l in row:\n",
    "        whole_element.append(l)\n",
    "        \n",
    "whole_element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "951ef2bc",
   "metadata": {},
   "source": [
    "# Advanced Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "0f37a763",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60d2221b",
   "metadata": {},
   "source": [
    "* append()\n",
    "Definitely, You have used this method by now, which merely appends an element to the end of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "b76e9887",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.append(4)\n",
    "\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1ff376b",
   "metadata": {},
   "source": [
    "* \n",
    "count() takes in an element and returns the number of times it occures in your list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "84fa5dde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.count(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "5bf9ee30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.count(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1dae49b",
   "metadata": {},
   "source": [
    "* extend\n",
    "find the difference between extend and append to be unclear.\n",
    "\n",
    "append: Appends object at end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "5b792415",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.append([4, 5])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ba30a6d",
   "metadata": {},
   "source": [
    "* extend: extends list by appending elements from the iterable. It will append content of list elements to the existing list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "f02867b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'S', 'Z']\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "x.extend('SZ')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "0d0262ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extended list\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['AI', 'ML', 'DS', 'BDA', 0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [\"AI\",\"ML\",\"DS\", \"BDA\"]\n",
    "l2 = list(range(5))\n",
    "print(\"extended list\")\n",
    "l1.extend(l2)\n",
    "l1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301a5a66",
   "metadata": {},
   "source": [
    "* Note:- how extend append each element in that iterable. That is the key difference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "802314c9",
   "metadata": {},
   "source": [
    "* index returns the lowest index of element placed as an argument. \n",
    "* Make a note that if the element is not in the list then it returns an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "bd5957d6",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "'append me!' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [153]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43ml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mindex\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mappend me!\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mValueError\u001b[0m: 'append me!' is not in list"
     ]
    }
   ],
   "source": [
    "l.index('append me!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "3ff82dd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "fed570e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.index(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "c9057c0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1,2,3,6,3]\n",
    "l.index(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbeb9210",
   "metadata": {},
   "source": [
    "* insert\n",
    "Two arguments can be placed in insert method.\n",
    "\n",
    "Syntax: insert(index,object)\n",
    "\n",
    "This method places the object at the index supplied. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "1ab8dc7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "9a02d365",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "4d085e8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 'new element', 4, 5]"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.insert(3,\"new element\")\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "97109eff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Place a letter at the index 2\n",
    "l.insert(100,'inserted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "1a2f4e24",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [161]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43ml\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "l[100]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6330f6cc",
   "metadata": {},
   "source": [
    "* pop\n",
    "You most likely have already seen pop(), which allows us to \"pop\" off the last element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "4cc0ca70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 45, 5, 6]"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l= [1,2,3,45,5,6]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "5334254d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pop1 = l.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "691660f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pop1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "b62c477c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 45, 5]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "2dd4f8c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "ele = l.pop(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "7a88efff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ele"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "936eeea5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 45, 5]"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abeedb8f",
   "metadata": {},
   "source": [
    "* remove\n",
    "The remove() method removes the first occurrence of a value. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "8085b337",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 45, 5]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "bba66890",
   "metadata": {},
   "outputs": [],
   "source": [
    "l.remove(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "7f9a1cac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 45]"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "de318b0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "702da629",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 3]"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "a9264005",
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we have same element coming multiple times, it will remove first occuring element only\n",
    "l.remove(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "888768de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 3]"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0effecab",
   "metadata": {},
   "source": [
    "* reverse\n",
    "As the name suggests, reverse() helps you to reverse a list. \n",
    "Note this occurs in place! Meaning it effects your list permanently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "1d5be7b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "l.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "139f50a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 2, 1]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06770859",
   "metadata": {},
   "source": [
    "* sort will sort your list in place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "f35c2b25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 2, 1]"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "7eb28e1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "l.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "182aee9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "0b342c4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [0, 1, 2, \"sunil\", \"DS\", \"zambare\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "ebdb9b1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 'sunil', 'DS', 'zambare']"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "a23b805a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [183]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Sorting can be done using same types of data in a list\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43ml\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "# Sorting can be done using same types of data in a list\n",
    "l.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a084123",
   "metadata": {},
   "source": [
    "## Iterating through a string by using list Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "d49a6069",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['z', 'a', 'm', 'b', 'a', 'r', 'e']"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Without using list comprehension\n",
    "letter = []\n",
    "for ch in 'zambare':\n",
    "    letter.append(ch)\n",
    "letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "b0b80ac5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['s', 'u', 'n', 'i', 'l']\n"
     ]
    }
   ],
   "source": [
    "# With using list comprehension\n",
    "letter = [ ch for ch in 'sunil' ]\n",
    "print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b508025",
   "metadata": {},
   "source": [
    "* Use of conditional statements using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "499eea45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Without list comprehension\n",
    "l=[]\n",
    "for i in range(20):\n",
    "    if i%2 == 0:\n",
    "        l.append(i)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "63daeffd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "# With list comprehension\n",
    "number = [ i for i in range(20) if i % 2 == 0]\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "f5f5e79d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd']"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = []\n",
    "for i in range(20):\n",
    "    if i%2 != 0:\n",
    "        l.append(\"Odd\")\n",
    "    else:\n",
    "        l.append(\"Even\")\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "d7cd5476",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd',\n",
       " 'Even',\n",
       " 'Odd']"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if else in list comprehension\n",
    "odd_even = [\"Odd\" if i%2!=0 else \"Even\" for i in range(20)]\n",
    "odd_even"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "b4b6b440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [0, 1, 2], [0, 1, 2]]"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nested for loop without list comprehention\n",
    "matrix = []\n",
    "for i in range(3):\n",
    "    matrix.append([])\n",
    "    for j in range(3):\n",
    "        matrix[i].append(j)\n",
    "\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "c35ff716",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [0, 1, 2], [0, 1, 2]]"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nested for loop with list comprehention\n",
    "matrix_with_List_Comp = [[j for j in range(3)] for i in range(3)]\n",
    "matrix_with_List_Comp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "d150fefb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 6]"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nested conditions\n",
    "[i for i in range(8) if i%2==0 if i%3==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "e26e385f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 6]"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = []\n",
    "for i in range(8):\n",
    "    if i%2 ==0:\n",
    "        if i%3 == 0:\n",
    "            l.append(i)\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "225ffee9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['yes', 'no', 'idle', 'idle', 'idle', 'idle', 'idle', 'idle', 'idle']"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For if elif else\n",
    "l = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "['yes' if i == 1 else 'no' if i == 2 else 'idle' for i in l]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "a359826c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['yes', 'no', 'idle', 'idle', 'idle', 'idle', 'idle', 'idle', 'idle']"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "res = []\n",
    "for i in l:\n",
    "    if i == 1:\n",
    "        res.append(\"yes\")\n",
    "    elif i == 2:\n",
    "        res.append(\"no\")\n",
    "    else:\n",
    "        res.append(\"idle\")\n",
    "        \n",
    "res"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}