Lists_Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal is Panther\n",
      "Animal is lion\n",
      "Animal is Tiger\n",
      "Animal is leopard\n",
      "Animal is Puma\n",
      "Animal is Cougar\n",
      "Animal is Cheetah\n",
      "Animal is snow leopard\n"
     ]
    }
   ],
   "source": [
    "Feline_species=[\"Panther\",\"lion\",\"Tiger\",\"leopard\",\"Puma\",\"Cougar\",\"Cheetah\"]\n",
    "Feline_species.append(\"snow leopard\")\n",
    "for i in  Feline_species:\n",
    "    print(\"Animal is {}\".format(i))\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "numbers in disarray\n"
     ]
    }
   ],
   "source": [
    "even=[2,4,6,8]\n",
    "odd=[1,3,5,7]\n",
    "numbers=even+odd\n",
    "ordered_numbers=sorted(numbers)\n",
    "print(ordered_numbers)\n",
    "\n",
    "if ordered_numbers==numbers:\n",
    "    print(\"numbers in order\")\n",
    "else:\n",
    "    print(\"numbers in disarray\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the list 1 is [] \n",
      "the list 2 is [] \n",
      "match\n",
      "['m', 'a', 't', 'c', 'h']\n"
     ]
    }
   ],
   "source": [
    "list1=[]\n",
    "list2=list() #constructor is being called without any parameters\n",
    "print(\"the list 1 is {} \".format(list1))\n",
    "print(\"the list 2 is {} \".format(list2))\n",
    "if list1==list2:\n",
    "    print(\"match\")\n",
    "else:\n",
    "    \n",
    "    print(\"match not found  \")\n",
    "    \n",
    "    \n",
    "print(list(\"match\"))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n",
      "[8, 6, 4, 2]\n",
      "no match found\n"
     ]
    }
   ],
   "source": [
    "even=[2,4,6,8]\n",
    "another_even=list(even) #constructor is being called with  parameter as even.\n",
    "another_even.sort(reverse=True)\n",
    "print(even)\n",
    "print(another_even)\n",
    "\n",
    "if even== another_even:\n",
    "    print(\"match\")\n",
    "else:\n",
    "    print(\"no match found\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "[2, 4, 6, 8, 10]\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "even=[2,4,6,8,10]\n",
    "odd=[1,3,5,7,9]\n",
    "numbers=[odd,even]\n",
    "for i in numbers:\n",
    "    print(i)\n",
    "    for j in i:\n",
    "        print(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['eggs', 'sausage', 'bacon']\n",
      "eggs\n",
      "sausage\n",
      "bacon\n"
     ]
    }
   ],
   "source": [
    "menu=[]\n",
    "menu.append([\"eggs\",\"spam\",\"bacon\"])\n",
    "menu.append([\"eggs\",\"sausage\",\"bacon\"])\n",
    "menu.append([\"eggs\",\"spam\"])\n",
    "menu.append([\"eggs\",\"bacon\",\"spam\"])\n",
    "menu.append([\"eggs\",\"bacon\",\"sausage\",\"spam\"])\n",
    "menu.append([\"spam\",\"eggs\",\"sausage\",\"bacon\"])\n",
    "menu.append([\"spam\",\"sausage\",\"eggs\",\"bacon\"])\n",
    "menu.append([\"spam\",\"eggs\",\"sausage\",\"spam\"])\n",
    "for meal in menu:\n",
    "    if not \"spam\" in meal:\n",
    "        print(meal)\n",
    "        for ingredients in meal:\n",
    "            print(ingredients)\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "mealeggs\n",
      "e g g s \n",
      "\n",
      "mealbacon\n",
      "b a c o n "
     ]
    }
   ],
   "source": [
    "menu=[]\n",
    "menu.append([\"eggs\",\"spam\",\"bacon\"])\n",
    "menu.append([\"eggs\",\"sausage\",\"bacon\"])\n",
    "menu.append([\"eggs\",\"spam\"])\n",
    "menu.append([\"eggs\",\"bacon\",\"spam\"])\n",
    "menu.append([\"eggs\",\"bacon\",\"sausage\",\"spam\"])\n",
    "menu.append([\"spam\",\"eggs\",\"sausage\",\"bacon\"])\n",
    "menu.append([\"spam\",\"sausage\",\"eggs\",\"bacon\"])\n",
    "menu.append([\"spam\",\"eggs\",\"sausage\",\"spam\"])\n",
    "\n",
    "\n",
    "i=0\n",
    "for meal in menu[i]:\n",
    "    \n",
    "    \n",
    "    if  meal[i] in \"spam\":\n",
    "        \n",
    "        \n",
    "        continue\n",
    "        \n",
    "            \n",
    "    print(\"\\n\")    \n",
    "    print(\"meal\" +  meal)\n",
    "    for ingredients in meal:\n",
    "        print( ingredients,end=\" \")\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 6, 5, 3, 2]\n",
      "enter the valuse of list2\n",
      "5\n",
      "runner up\n"
     ]
    }
   ],
   "source": [
    "list=[2,3,6,6,5]\n",
    "list.sort(reverse=True)\n",
    "print(list)\n",
    "i=int(input(\"enter the valuse of list\"))\n",
    "if list[i]==max(list):\n",
    "    print(\"winner\")\n",
    "elif list[i]==max(list)-1:\n",
    "    print(list[i])\n",
    "    print(\"runner up\")\n",
    "else:\n",
    "    print(\"you  are too far behind\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "list=[2,3,6,6,5]\n",
    "print(max(list)-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'len'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-104-4a51088d1368>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'apple'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'mango'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'orange'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'banana'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'pears'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mmy_iterator\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0miter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mn\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'list' object has no attribute 'len'"
     ]
    }
   ],
   "source": [
    "list=['apple','mango','orange','banana','pears']\n",
    "my_iterator=iter(list)\n",
    "n=list.len()\n",
    "for i in range(n):\n",
    "    \n",
    "    print(next(my_iterator))\n",
    "    \n",
    "    \n",
    " \n",
    "print(\"\\n\")    \n",
    "for i in list:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "mango\n",
      "orange\n",
      "banana\n",
      "pears\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-115-c5c746ec0ee8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_iterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_iterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_iterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "list=['apple','mango','orange','banana','pears']\n",
    "my_iterator=iter(list)\n",
    "\n",
    "print(next(my_iterator))\n",
    "print(next(my_iterator))\n",
    "print(next(my_iterator))\n",
    "print(next(my_iterator))\n",
    "print(next(my_iterator))\n",
    "print(next(my_iterator))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "\n",
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]\n",
      "\n",
      "\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n"
     ]
    }
   ],
   "source": [
    "my_list=list(range(10))\n",
    "print(my_list)\n",
    "\n",
    "even=list(range(0,100,2))\n",
    "odd=list(range(0,100,1))\n",
    "print(\"\\n\")\n",
    "\n",
    "print(even)\n",
    "print(\"\\n\")\n",
    "print(odd)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "string=\"12345566577454858uirohsojfslfjslt34tl\"\n",
    "print(string.index('5'))\n",
    "print(string[16])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 150, 2)\n",
      "47\n",
      "11\n",
      "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149]\n"
     ]
    }
   ],
   "source": [
    "Decimals=range(1,150,2)\n",
    "print(Decimals)\n",
    "print(Decimals[23])\n",
    "print(Decimals.index(23))\n",
    "print(list(Decimals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter the value less than 30? 21\n",
      "21 is divisble by 7\n"
     ]
    }
   ],
   "source": [
    "sevens=range(0,100,7)\n",
    "x=int(input(\"enter the value less than 30? \"))\n",
    "if x in sevens:\n",
    "    \n",
    "    print(\"{} is divisble by 7\".format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]\n"
     ]
    }
   ],
   "source": [
    "sevens=range(0,100,7)\n",
    "\n",
    "print(list(sevens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "\n",
      "\n",
      "40\n",
      "\n",
      "\n",
      "35\n",
      "\n",
      "\n",
      "30\n",
      "\n",
      "\n",
      "25\n",
      "\n",
      "\n",
      "20\n",
      "\n",
      "\n",
      "15\n",
      "\n",
      "\n",
      "10\n",
      "\n",
      "\n",
      "5\n",
      "\n",
      "\n",
      "0\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y=range(0,50,5)\n",
    "for i in y[::-1]:\n",
    "    print(i)\n",
    "    print(\"\\n\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "45\n",
      "40\n",
      "35\n",
      "30\n",
      "25\n",
      "20\n",
      "15\n",
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "y=range(50,0,-5)\n",
    "for i in y:\n",
    "    \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "\n",
      "\n",
      "-x-x-x-x-x-x-x-x-x-x--x-x-x-x-x-x--x-x-x-x-x--x-x--x-x--x-x--x-x--x-x--x-x-x--x-x-x-x--x-x-x--x--x-x--x-x-x-x--x-x-x--x\n",
      "\n",
      "\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "XXXXXXXXXXXXXXXXXXXX\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "decimals=range(0,50)\n",
    "my_range=decimals[0:50:5]\n",
    "for i in my_range:\n",
    "    print('X'* 20 )\n",
    "print(\"\\n\")\n",
    "print(\"-x-x-x-x-x-x-x-x-x-x--x-x-x-x-x-x--x-x-x-x-x--x-x--x-x--x-x--x-x--x-x--x-x-x--x-x-x-x--x-x-x--x--x-x--x-x-x-x--x-x-x--x\")\n",
    "print(\"\\n\")\n",
    "\n",
    "    \n",
    "    \n",
    "for i in range(0,50,5):\n",
    "    print('X' * 20)\n",
    "    \n",
    "    \n",
    "print(my_range==i)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 30, 2)\n",
      "0\n",
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "o=range(0,30,2)\n",
    "print(o)\n",
    "\n",
    "p=o[::5]\n",
    "for i in p:\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "r=range(0,20)\n",
    "print( list(r[::-1]))\n",
    "\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(3, 40, 3)\n",
      "[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39]\n",
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n",
      "30\n",
      "33\n",
      "36\n",
      "39\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "decimals=range(0,100)\n",
    "my_range=decimals[3:40:3]\n",
    "print(my_range)\n",
    "print(list(my_range))\n",
    "for i in my_range:\n",
    "    print(i)\n",
    "print(my_range==range(3,40,3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('name', 'address', 'age')\n",
      "('name', 'Addresses', 'age')\n"
     ]
    }
   ],
   "source": [
    "#objects are immutable not  variables\n",
    "t=(\"name\",\"address\",\"age\")\n",
    "print(t)\n",
    "t=t[0],\"Addresses\",t[2]\n",
    "print(t)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13 12\n"
     ]
    }
   ],
   "source": [
    "a,b=12,13\n",
    "a,b=b,a\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-a405affd8614>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#unpacking of tuple\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "#unpacking of tuple\n",
    "x,y,z=t\n",
    "print(x,y,z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18, 16, 14, 12, 10, 8, 6, 4, 2, 0, "
     ]
    }
   ],
   "source": [
    "even = range(0, 20, 2)\n",
    " \n",
    "for number in even[::-1]:\n",
    "    print(number, end=', ')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Add options from list below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:Mouse\n",
      "0:Finish\n",
      "1\n",
      "adding 1\n",
      "2\n",
      "adding 2\n",
      "3\n",
      "adding 3\n",
      "\n",
      "4\n",
      "adding 4\n",
      "5\n",
      "adding 5\n",
      "5\n",
      "adding 5\n",
      "5\n",
      "adding 5\n",
      "66\n",
      "Add options from list below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:Mouse\n",
      "0:Finish\n",
      "\n",
      "0\n",
      "['Modem', 'CPU', 'Printer', 'Keyboard', 'Harddisk', 'Harddisk', 'Harddisk']\n"
     ]
    }
   ],
   "source": [
    "current_choice=\"_\"\n",
    "\n",
    "computer_parts=[] #empty list\n",
    "while current_choice!='0':\n",
    "    if current_choice in \"1234567\":\n",
    "        if current_choice== \"1\":\n",
    "            computer_parts.append(\"Modem\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "        elif current_choice==\"2\":\n",
    "            computer_parts.append(\"CPU\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "        elif current_choice==\"3\":\n",
    "            computer_parts.append(\"Printer\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "        elif current_choice==\"4\":\n",
    "            computer_parts.append(\"Keyboard\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "        elif current_choice==\"5\":\n",
    "            \n",
    "            computer_parts.append(\"Harddisk\")\n",
    "\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "            \n",
    "        elif current_choice==\"6\":\n",
    "             computer_parts.append(\"Mouse\")\n",
    "             print(\"adding {}\".format(current_choice))\n",
    "            \n",
    "        elif current_choice==\"7\":\n",
    "             computer_parts.append(\"HDMI Cable\")\n",
    "             print(\"adding {}\".format(current_choice))\n",
    "                \n",
    "    else:\n",
    "        print(\"Add options from list below:\")\n",
    "        print(\"1:Modem\")\n",
    "        print(\"2:CPU\")\n",
    "        print(\"3:Printer\")\n",
    "        print(\"4:Keyboard\")\n",
    "        print(\"5:Harddisk\")\n",
    "        print(\"6:Mouse\")\n",
    "        print(\"7:Mouse\")\n",
    "        print(\"0:Finish\")\n",
    "        \n",
    "    current_choice=input()\n",
    "    \n",
    "print(computer_parts)\n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "1\n",
      "adding 1\n",
      "2\n",
      "adding 2\n",
      "3\n",
      "adding 3\n",
      "4\n",
      "adding 4\n",
      "5\n",
      "adding 5\n",
      "6\n",
      "adding 6\n",
      "7\n",
      "adding 7\n",
      "8\n",
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "0\n",
      "['Modem', 'CPU', 'Printer', 'Keyboard', 'Harddisk', 'Mouse', 'HDMI Cable']\n"
     ]
    }
   ],
   "source": [
    "current_choice=\"_\"\n",
    "computer_parts=[]\n",
    "available_parts=[\"Modem\",\"CPU\",\"Printer\",\"Keyboard\",\"Harddisk\",\"Mouse\",\"HDMI Cable\"]\n",
    "\n",
    "while current_choice!='0':\n",
    "    if current_choice in\"1234567\":\n",
    "        if current_choice==\"1\":\n",
    "            computer_parts.append(\"Modem\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"2\":\n",
    "            computer_parts.append(\"CPU\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"3\":\n",
    "            computer_parts.append(\"Printer\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"4\":\n",
    "            computer_parts.append(\"Keyboard\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"5\":\n",
    "            computer_parts.append(\"Harddisk\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"6\":\n",
    "            computer_parts.append(\"Mouse\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"7\":\n",
    "            computer_parts.append(\"HDMI Cable\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "    else:\n",
    "        print(\"From List of items below:\")\n",
    "            \n",
    "        for parts in available_parts:\n",
    "            \n",
    "                \n",
    "                \n",
    "            print(\"{0}:{1}\".format(available_parts.index(parts)+1,parts))\n",
    "            \n",
    "                      \n",
    "    current_choice = input()\n",
    "                      \n",
    "print(computer_parts)\n",
    "                  \n",
    "                         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "1\n",
      "adding 1\n",
      "2\n",
      "adding 2\n",
      "3\n",
      "adding 3\n",
      "5\n",
      "adding 5\n",
      "9\n",
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "0\n",
      "['Modem', 'CPU', 'Printer', 'Harddisk']\n"
     ]
    }
   ],
   "source": [
    "current_choice=\"_\"\n",
    "computer_parts=[]\n",
    "available_parts=[\"Modem\",\"CPU\",\"Printer\",\"Keyboard\",\"Harddisk\",\"Mouse\",\"HDMI Cable\"]\n",
    "\n",
    "while current_choice!='0':\n",
    "    if current_choice in\"1234567\":\n",
    "        if current_choice==\"1\":\n",
    "            computer_parts.append(\"Modem\")\n",
    "            \n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"2\":\n",
    "            computer_parts.append(\"CPU\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"3\":\n",
    "            computer_parts.append(\"Printer\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"4\":\n",
    "            computer_parts.append(\"Keyboard\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"5\":\n",
    "            computer_parts.append(\"Harddisk\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"6\":\n",
    "            computer_parts.append(\"Mouse\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "        elif current_choice==\"7\":\n",
    "            computer_parts.append(\"HDMI Cable\")\n",
    "            print(\"adding {}\".format(current_choice))\n",
    "\n",
    "    else:\n",
    "        print(\"From List of items below:\")\n",
    "        \n",
    "            \n",
    "        for number,parts in enumerate(available_parts):\n",
    "            \n",
    "        \n",
    "            \n",
    "                \n",
    "                \n",
    "            print(\"{0}:{1}\".format(number+1,parts))\n",
    "            \n",
    "                      \n",
    "    current_choice = input()\n",
    "                      \n",
    "print(computer_parts)\n",
    "                  \n",
    "                         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4', '5', '6', '7']\n",
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "1\n",
      "adding 1\n",
      "2\n",
      "adding 2\n",
      "3\n",
      "adding 3\n",
      "0\n",
      "['Modem', 'CPU', 'Printer']\n"
     ]
    }
   ],
   "source": [
    "#refactoringthecode\n",
    "current_choice=\"_\"\n",
    "computer_parts=[]\n",
    "available_parts=[\"Modem\",\"CPU\",\"Printer\",\"Keyboard\",\"Harddisk\",\"Mouse\",\"HDMI Cable\"]\n",
    "\n",
    "\n",
    "valid_choices=[]\n",
    "\n",
    "for i in range(1,len(available_parts)+1):\n",
    "    \n",
    "    valid_choices.append(str(i))\n",
    "print(valid_choices)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "while current_choice!='0':\n",
    "    if current_choice in valid_choices:\n",
    "        index=int(current_choice)-1\n",
    "        choice=available_parts[index]\n",
    "        computer_parts.append(choice)\n",
    "        \n",
    "        \n",
    "        print(\"adding {}\".format(current_choice))\n",
    "            \n",
    "            \n",
    "\n",
    "        \n",
    "    else:\n",
    "        print(\"From List of items below:\")\n",
    "        \n",
    "            \n",
    "        for number,parts in enumerate(available_parts):\n",
    "            \n",
    "        \n",
    "            print(\"{0}:{1}\".format(number+1,parts))\n",
    "            \n",
    "                      \n",
    "    current_choice = input()\n",
    "                      \n",
    "print(computer_parts)\n",
    "                  \n",
    "                         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bellflower - Flower', 'China Pink - Flower', 'Daffodil - Flower', 'Evening Primrose - Flower', 'French Marigold - Flower', 'Iris - Flower', \"Queen Anne's Lace - Flower\", 'Red Hot Poker - Flower', 'Snapdragon - Flower', 'Sunflower - Flower', 'Tiger Lily - Flower']\n",
      "['Andromeda - Shrub', 'Hydrangea - Shrub', 'Japanese Camellia - Shrub', 'Lavender - Shrub', 'Lilac- Shrub', 'Magnolia - Shrub', 'Peony - Shrub', 'Witch Hazel - Shrub']\n"
     ]
    }
   ],
   "source": [
    "data = [\n",
    "    \"Andromeda - Shrub\",\n",
    "    \"Bellflower - Flower\",\n",
    "    \"China Pink - Flower\",\n",
    "    \"Daffodil - Flower\",\n",
    "    \"Evening Primrose - Flower\",\n",
    "    \"French Marigold - Flower\",\n",
    "    \"Hydrangea - Shrub\",\n",
    "    \"Iris - Flower\",\n",
    "    \"Japanese Camellia - Shrub\",\n",
    "    \"Lavender - Shrub\",\n",
    "    \"Lilac- Shrub\",\n",
    "    \"Magnolia - Shrub\",\n",
    "    \"Peony - Shrub\",\n",
    "    \"Queen Anne's Lace - Flower\",\n",
    "    \"Red Hot Poker - Flower\",\n",
    "    \"Snapdragon - Flower\",\n",
    "    \"Sunflower - Flower\",\n",
    "    \"Tiger Lily - Flower\",\n",
    "    \"Witch Hazel - Shrub\",\n",
    "]\n",
    "\n",
    "flowers = [Flower for Flower in data  if \"Flower\" in Flower]\n",
    "shrubs = [Shrub for Shrub in data  if \"Shrub\" in Shrub]\n",
    "print(flowers)\n",
    "print(shrubs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4', '5', '6', '7']\n",
      "From List of items below:\n",
      "1:Modem\n",
      "2:CPU\n",
      "3:Printer\n",
      "4:Keyboard\n",
      "5:Harddisk\n",
      "6:Mouse\n",
      "7:HDMI Cable\n",
      "1\n",
      "Adding 1\n",
      "your list now contains ['Modem']\n",
      "2\n",
      "Adding 2\n",
      "your list now contains ['Modem', 'CPU']\n",
      "3\n",
      "Adding 3\n",
      "your list now contains ['Modem', 'CPU', 'Printer']\n",
      "4\n",
      "Adding 4\n",
      "your list now contains ['Modem', 'CPU', 'Printer', 'Keyboard']\n",
      "3\n",
      "Removing 3\n",
      "your list now contains ['Modem', 'CPU', 'Keyboard']\n",
      "0\n",
      "['Modem', 'CPU', 'Keyboard']\n"
     ]
    }
   ],
   "source": [
    "#RemovingitemsformList\n",
    "current_choice=\"_\"\n",
    "computer_parts=[]\n",
    "available_parts=[\"Modem\",\"CPU\",\"Printer\",\"Keyboard\",\"Harddisk\",\"Mouse\",\"HDMI Cable\"]\n",
    "\n",
    "\n",
    "valid_choices=[]\n",
    "\n",
    "for i in range(1,len(available_parts)+1):\n",
    "    \n",
    "    valid_choices.append(str(i))\n",
    "print(valid_choices)\n",
    "    \n",
    "while current_choice!='0':\n",
    "    if current_choice in valid_choices:\n",
    "        index=int(current_choice)-1\n",
    "        choice=available_parts[index]\n",
    "        if choice in computer_parts:\n",
    "            print(\"Removing {}\".format(current_choice))\n",
    "            computer_parts.remove(choice)\n",
    "        else:\n",
    "            print(\"Adding {}\".format(current_choice))\n",
    "            \n",
    "            computer_parts.append(choice)\n",
    "        print(\"your list now contains {}\".format(computer_parts))\n",
    "\n",
    "            \n",
    "    else:\n",
    "        print(\"From List of items below:\")\n",
    "        \n",
    "            \n",
    "        for number,parts in enumerate(available_parts):\n",
    "            \n",
    "        \n",
    "            print(\"{0}:{1}\".format(number+1,parts))\n",
    "            \n",
    "                      \n",
    "    current_choice = input()\n",
    "                      \n",
    "print(computer_parts)\n",
    "                  \n",
    "                         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 1, 3, 5, 7]\n",
      "[2, 4, 6, 8, 1, 3, 5, 7]\n",
      "[8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "even=[2,4,6,8]\n",
    "odd=[1,3,5,7]\n",
    "even.extend(odd)\n",
    "print(even)\n",
    "another_even=even\n",
    "print(another_even)\n",
    "\n",
    "even.sort(reverse=True)\n",
    "print(even)\n",
    "print(another_even)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', ' ', ' ', ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'o', 'o', 'o', 'p', 'q', 'r', 'r', 's', 't', 'u', 'u', 'v', 'w', 'x', 'y', 'z']\n",
      "[1, 1, 2, 4, 5, 7, 9, 11]\n",
      "[1, 1, 2, 4, 5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "pangram=\"the quick brown fox jumps over lazy dog\"\n",
    "letters=sorted(pangram)\n",
    "print(letters)\n",
    "\n",
    "numbers=[1,2,4,7,9,11,1,5]\n",
    "m=sorted(numbers)\n",
    "print(m)\n",
    "\n",
    "numbers.sort()\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['eon', 'fiat', 'Honda', 'Hyundai', 'maruti', 'Tata']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#caseinsensitivesorting\n",
    "car_names=[\"eon\",\"maruti\",\"Hyundai\",\"Honda\",\"Tata\",\"fiat\"]\n",
    "car_names.sort(key=str.casefold)\n",
    "\n",
    "print(car_names)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 1, 3, 5, 7]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "False\n",
      "True\n",
      "[1, 2, 3, 4, 5, 6, 7, 8]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "#Diffwaysofcreatingalist\n",
    "even=[2,4,6,8]\n",
    "odd=[1,3,5,7]\n",
    "numbers=even+odd\n",
    "print(numbers)\n",
    "numbers.sort()\n",
    "print(numbers)\n",
    "Sorted_numbers=sorted(numbers)\n",
    "more_numbers=numbers.copy()\n",
    "print(more_numbers)\n",
    "print(Sorted_numbers)\n",
    "print(numbers is Sorted_numbers)\n",
    "print(numbers == Sorted_numbers)\n",
    "\n",
    "more_numbers=numbers[:]\n",
    "print(more_numbers)\n",
    "\n",
    "\n",
    "more_numbers=list(numbers)\n",
    "print(more_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['modem', 'cpu', 'monitor', 'printer', 'scanner', 'gpu']\n"
     ]
    }
   ],
   "source": [
    "computer_parts=[\"modem\",\"cpu\",\"monitor\",\"mouse\",\"keyboard\",\"trackball\"]\n",
    "computer_parts[3:]=[\"printer\",\"scanner\",\"gpu\"]\n",
    "print(computer_parts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 100, 140, 178, 102, 200, 236]\n"
     ]
    }
   ],
   "source": [
    "#deletingitemsfromlist\n",
    "Data=[12,1,3,100,140,240,178,102,200,210,236]\n",
    "max_range=200\n",
    "min_range=100\n",
    "for index,value in enumerate(Data):\n",
    "    \n",
    "    if value<100 or value>200:\n",
    "        del Data[index]\n",
    "        \n",
    "print(Data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "12\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "3\n",
      "100\n",
      "3\n",
      "[100, 140, 240, 178, 102, 200, 210, 236]\n"
     ]
    }
   ],
   "source": [
    "#Removingthelowvalues\n",
    "\n",
    "Data=[12,1,3,100,140,240,178,102,200,210,236]\n",
    "max_range=200\n",
    "min_range=100\n",
    "stop=0\n",
    "for index,value in enumerate(Data):\n",
    "    print(index)\n",
    "    print(value)\n",
    "    if value>=min_range:\n",
    "        stop=index\n",
    "        break\n",
    "        \n",
    "        \n",
    "print(stop)#debugging\n",
    "    \n",
    "del Data[:stop]\n",
    "\n",
    "print(Data)\n",
    "#print(stop)\n",
    "\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "12\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "3\n",
      "100\n",
      "4\n",
      "140\n",
      "5\n",
      "240\n",
      "6\n",
      "178\n",
      "7\n",
      "102\n",
      "8\n",
      "200\n",
      "9\n",
      "210\n",
      "10\n",
      "236\n",
      "3\n",
      "[100, 140, 240, 178, 102, 200, 210, 236]\n"
     ]
    }
   ],
   "source": [
    "#Removingthehighvalues\n",
    "\n",
    "Data=[12,1,3,100,140,240,178,102,200,210,236]\n",
    "max_range=200\n",
    "min_range=100\n",
    "start=0\n",
    "for index,value in enumerate(Data):\n",
    "    \n",
    "    print(index)\n",
    "    print(value)\n",
    "    if value<=min_range:\n",
    "        stop=index\n",
    "    continue\n",
    "        \n",
    "        \n",
    "print(stop)#debugging\n",
    "    \n",
    "del Data[:stop]\n",
    "\n",
    "print(Data)\n",
    "#print(stop)\n",
    "\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "6\n",
      "5\n",
      "6\n",
      "[100, 140, 240, 178, 102, 200]\n"
     ]
    }
   ],
   "source": [
    "#removing High values\n",
    "Data=[100,140,240,178,102,200,210,236]\n",
    "max_range=200\n",
    "min_range=100\n",
    "start=0\n",
    "for index in range(len(Data)-1,-1,-1):\n",
    "    print(index)\n",
    "    if Data[index]<=max_range:\n",
    "        start=index+1\n",
    "        break\n",
    "        \n",
    "print(start)\n",
    "del Data[start:]\n",
    "print(Data)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "[104, 101, 4, 5, 308, 103, 107, 100, 306, 102, 108] 8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "[104, 101, 4, 5, 308, 103, 107, 100, 102, 108] 4\n",
      "3\n",
      "[104, 101, 4, 5, 103, 107, 100, 102, 108] 3\n",
      "2\n",
      "[104, 101, 4, 103, 107, 100, 102, 108] 2\n",
      "1\n",
      "0\n",
      "[104, 101, 103, 107, 100, 102, 108]\n"
     ]
    }
   ],
   "source": [
    "#removing hgh & low end values\n",
    "data=[104,101,4,5,308,103,107,100,306,102,108]\n",
    "min_valid=100\n",
    "max_valid=200\n",
    "for index in range(len(data)-1,-1,-1):\n",
    "    print(index)\n",
    "    if data[index]<min_valid or data[index]>max_valid:\n",
    "        print(data,index)\n",
    "        del data[index]\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 [104, 101, 4, 5, 308, 103, 107, 100, 306, 102, 108]\n",
      "102\n",
      "7 [104, 101, 4, 5, 308, 103, 107, 100, 102, 108]\n",
      "108\n",
      "6 [104, 101, 4, 5, 308, 103, 107, 102, 108]\n"
     ]
    },
    {
     "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)",
      "\u001b[1;32m<ipython-input-3-a63ad5ede98f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtop_index\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m         \u001b[1;32mdel\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mtop_index\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "data=[104,101,4,5,308,103,107,100,306,102,108]\n",
    "min_valid=100\n",
    "max_valid=200\n",
    "top_index=len(data)-1\n",
    "for index,value in enumerate(reversed(data)):\n",
    "    if data[index]<min_valid or data[index]>max_valid:\n",
    "        \n",
    "        \n",
    "        print(top_index-index,data)\n",
    "        del data[top_index-index]\n",
    "        print(data[8])\n",
    "\n",
    "   \n",
    "        \n",
    "\n",
    "\n",
    "print(data)\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 4, 6, 8], [1, 3, 5, 7]]\n",
      "[2, 4, 6, 8]\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "[1, 3, 5, 7]\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "#Nested List\n",
    "even=[2,4,6,8]\n",
    "odd=[1,3,5,7]\n",
    "numbers=[even,odd]\n",
    "print(numbers)\n",
    "\n",
    "for numbers_list in numbers:\n",
    "    print(numbers_list)\n",
    "    for num in numbers_list:\n",
    "        print(num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['egg', 'bacon']\n",
      "egg\n",
      "bacon\n",
      "['egg', 'sausage', 'bacon']\n",
      "egg\n",
      "sausage\n",
      "bacon\n",
      "['egg', 'bacon', 'spam'] has a spam score of 1\n",
      "['egg', 'bacon', 'sausage', 'spam'] has a spam score of 1\n",
      "['spam', 'sausage', 'spam', 'bacon', 'spam', 'tomato', 'spam'] has a spam score of 4\n",
      "['spam', 'egg', 'spam', 'spam', 'bacon', 'spam'] has a spam score of 4\n"
     ]
    }
   ],
   "source": [
    "menu=[\n",
    "    [\"egg\",\"bacon\"],\n",
    "    [\"egg\",\"sausage\",\"bacon\"],\n",
    "    [\"egg\",\"bacon\",\"spam\"],\n",
    "    [\"egg\",\"bacon\",\"sausage\",\"spam\"],\n",
    "    [\"spam\",\"sausage\",\"spam\",\"bacon\",\"spam\",\"tomato\",\"spam\"],\n",
    "    [\"spam\",\"egg\",\"spam\",\"spam\",\"bacon\",\"spam\"],\n",
    "]\n",
    "\n",
    "\n",
    "for meal in menu:\n",
    "    \n",
    "    if \"spam\" not in meal:\n",
    "        \n",
    "        print(meal)\n",
    "        \n",
    "        for item in meal:\n",
    "            \n",
    "            print(item)\n",
    "    else:\n",
    "        print(\"{0} has a spam score of {1}\".format(meal,meal.count(\"spam\")))\n",
    "        \n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "1\n",
      "0\n",
      "['egg', 'bacon']\n",
      "2\n",
      "1\n",
      "0\n",
      "['egg', 'sausage', 'bacon']\n",
      "2\n",
      "1\n",
      "0\n",
      "['egg', 'bacon']\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "['egg', 'bacon', 'sausage']\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "['sausage', 'bacon', 'tomato']\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "['egg', 'bacon']\n"
     ]
    }
   ],
   "source": [
    "#NospamChallange\n",
    "menu=[\n",
    "    [\"egg\",\"bacon\"],\n",
    "    [\"egg\",\"sausage\",\"bacon\"],\n",
    "    [\"egg\",\"bacon\",\"spam\"],\n",
    "    [\"egg\",\"bacon\",\"sausage\",\"spam\"],\n",
    "    [\"spam\",\"sausage\",\"spam\",\"bacon\",\"spam\",\"tomato\",\"spam\"],\n",
    "    [\"spam\",\"egg\",\"spam\",\"spam\",\"bacon\",\"spam\"],\n",
    "]\n",
    "print(len(menu))\n",
    "for meal in menu :\n",
    "    for index in range(len(meal)-1,-1,-1):\n",
    "        print(index)\n",
    "        if meal[index]==\"spam\":\n",
    "            del meal[index]\n",
    "            \n",
    "    print(meal)\n",
    "    \n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "egg\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "egg,bacon,egg\n",
      "\n",
      "\n",
      "sausage\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "egg,sausage,bacon,egg\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "egg,bacon,spam,egg\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "sausage\n",
      "\n",
      "\n",
      "egg,bacon,sausage,spam,sausage\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "tomato\n",
      "\n",
      "\n",
      "spam,sausage,spam,bacon,spam,tomato,spam,egg\n",
      "\n",
      "\n",
      "bacon\n",
      "\n",
      "\n",
      "spam,egg,spam,spam,bacon,spam,"
     ]
    }
   ],
   "source": [
    "#Second Approach\n",
    "menu=[\n",
    "    [\"egg\",\"bacon\"],\n",
    "    [\"egg\",\"sausage\",\"bacon\"],\n",
    "    [\"egg\",\"bacon\",\"spam\"],\n",
    "    [\"egg\",\"bacon\",\"sausage\",\"spam\"],\n",
    "    [\"spam\",\"sausage\",\"spam\",\"bacon\",\"spam\",\"tomato\",\"spam\"],\n",
    "    [\"spam\",\"egg\",\"spam\",\"spam\",\"bacon\",\"spam\"],\n",
    "]\n",
    "\n",
    "for meal in menu:\n",
    "    for item in meal:\n",
    "        if item!=\"spam\":\n",
    "            print(item)\n",
    "            print(\"\\n\")\n",
    "    print(\",\".join(meal),end=\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunflower->Tulip->Iris->Dahlia->Rose\n"
     ]
    }
   ],
   "source": [
    "flowers=[\"Sunflower\",\"Tulip\",\"Iris\",\"Dahlia\",\"Rose\"]\n",
    "\n",
    "   \n",
    "print(\"->\".join(flowers))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Ride the lightning', 'Metallica', '1984')\n",
      "['Ride the lightning', 'Metallica', '1984']\n",
      "['master of puppets', 'Metallica', '1984']\n"
     ]
    }
   ],
   "source": [
    "#Tuples\n",
    "metallica=\"Ride the lightning\",\"Metallica\",\"1984\"\n",
    "print(metallica)\n",
    "metallica2=list(metallica)\n",
    "print(metallica2)\n",
    "metallica2[0]=\"master of puppets\"\n",
    "print(metallica2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#unpacking the Tuple\n",
    "data_tuple=1,2,4\n",
    "x,y,z=data_tuple\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n",
      "3 d\n",
      "4 e\n",
      "5 f\n",
      "6 g\n",
      "7 h\n",
      "8 i\n"
     ]
    }
   ],
   "source": [
    "#More Unpacking\n",
    "for t in enumerate(\"abcdefghi\"):\n",
    "    index,character=t\n",
    "    print(index,character)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20000\n",
      "area is 20000\n"
     ]
    }
   ],
   "source": [
    "table=(\"cofee table\",200,100,75,34.50)\n",
    "print(table[1]* table[2])\n",
    "name,length,width,height,price=table\n",
    "print(\"area is\" , length * width)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "Album: Welcome to my Nightmare, Artist: Alice Cooper, Year: 1975\n",
      "Album: Bad Company, Artist: Bad Company, Year: 1974\n",
      "Album: Nightflight, Artist: Budgie, Year: 1981\n",
      "Album: More Mayhem, Artist: Emilda May, Year: 2011\n",
      "Album: Ride the Lightning, Artist: Metallica, Year: 1984\n",
      "Album: Welcome to my Nightmare, Artist: Alice Cooper, Year: 1975\n",
      "Album: Bad Company, Artist: Bad Company, Year: 1974\n",
      "Album: Nightflight, Artist: Budgie, Year: 1981\n",
      "Album: More Mayhem, Artist: Emilda May, Year: 2011\n",
      "Album: Ride the Lightning, Artist: Metallica, Year: 1984\n"
     ]
    }
   ],
   "source": [
    "#More UnPacking\n",
    "albums = [(\"Welcome to my Nightmare\", \"Alice Cooper\", 1975),\n",
    "          (\"Bad Company\", \"Bad Company\", 1974),\n",
    "          (\"Nightflight\", \"Budgie\", 1981),\n",
    "          (\"More Mayhem\", \"Emilda May\", 2011),\n",
    "          (\"Ride the Lightning\", \"Metallica\", 1984),\n",
    "          ]\n",
    "\n",
    "print(len(albums))\n",
    "\n",
    "for album in albums:\n",
    "    name,artist,year=album\n",
    "    \n",
    "    print(\"Album: {}, Artist: {}, Year: {}\"\n",
    "          .format(name, artist, year))\n",
    "    \n",
    "    \n",
    "    \n",
    "for name,artist,year in albums:\n",
    "    \n",
    "    print(\"Album: {}, Artist: {}, Year: {}\"\n",
    "          .format(name, artist, year))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Album: Welcome to my Nightmare, Artist: Alice Cooper, Year: 1975\n",
      "Album: Bad Company, Artist: Bad Company, Year: 1974\n",
      "Album: Nightflight, Artist: Budgie, Year: 1981\n",
      "Album: More Mayhem, Artist: Emilda May, Year: 2011\n",
      "Album: Ride the Lightning, Artist: Metallica, Year: 1984\n"
     ]
    }
   ],
   "source": [
    "for name,artist,year in albums:\n",
    "    \n",
    "    print(\"Album: {}, Artist: {}, Year: {}\"\n",
    "          .format(name, artist, year))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "album:Welcome to my Nightmare, name:Alice Cooper,year:1975,song:[(1, 'Welcome to my Nightmare'), (2, \"Devil's Food\"), (3, 'The Black Widow'), (4, 'Some Folks'), (5, 'Only Women Bleed')]\n",
      "\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "(3, 'Mayhem')\n",
      "album:Bad Company, name:Bad Company,year:1974,song:[(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')]\n",
      "\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "(3, 'Mayhem')\n",
      "album:Nightflight, name:Budgie,year:1981,song:[(1, 'I Turned to Stone'), (2, 'Keeping a Rendezvous'), (3, 'Reaper of the Glory'), (4, 'She Used Me Up')]\n",
      "\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "(3, 'Mayhem')\n",
      "album:More Mayhem, name:Imelda May,year:2011,song:[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "(3, 'Mayhem')\n"
     ]
    }
   ],
   "source": [
    "albums = [\n",
    "    (\"Welcome to my Nightmare\", \"Alice Cooper\", 1975,\n",
    "     [\n",
    "         (1, \"Welcome to my Nightmare\"),\n",
    "         (2, \"Devil's Food\"),\n",
    "         (3, \"The Black Widow\"),\n",
    "         (4, \"Some Folks\"),\n",
    "         (5, \"Only Women Bleed\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Bad Company\", \"Bad Company\", 1974,\n",
    "     [\n",
    "         (1, \"Can't Get Enough\"),\n",
    "         (2, \"Rock Steady\"),\n",
    "         (3, \"Ready for Love\"),\n",
    "         (4, \"Don't Let Me Down\"),\n",
    "         (5, \"Bad Company\"),\n",
    "         (6, \"The Way I Choose\"),\n",
    "         (7, \"Movin' On\"),\n",
    "         (8, \"Seagull\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Nightflight\", \"Budgie\", 1981,\n",
    "     [\n",
    "         (1, \"I Turned to Stone\"),\n",
    "         (2, \"Keeping a Rendezvous\"),\n",
    "         (3, \"Reaper of the Glory\"),\n",
    "         (4, \"She Used Me Up\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"More Mayhem\", \"Imelda May\", 2011,\n",
    "     [\n",
    "         (1, \"Pulling the Rug\"),\n",
    "         (2, \"Psycho\"),\n",
    "         (3, \"Mayhem\"),\n",
    "         (4, \"Kentish Town Waltz\"),\n",
    "     ]\n",
    "     ),\n",
    "]\n",
    "\n",
    "for album,name,year,song in albums:\n",
    "    \n",
    "        \n",
    "    print(\"album:{}, name:{},year:{},song:{}\".format(album,name,year,song))\n",
    "    print()\n",
    "    album=albums[3]\n",
    "    print(album)\n",
    "    songs=album[3]\n",
    "    print(songs)\n",
    "    song=songs[2]\n",
    "    print(song)\n",
    "    songes=song[1]\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 'Psycho')\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "Mayhem\n"
     ]
    }
   ],
   "source": [
    "print(song)\n",
    "print(songs)\n",
    "print(album)\n",
    "\n",
    "mayhem=albums[3][3][2][1]\n",
    "print(mayhem)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 'Mayhem')\n",
      "Mayhem\n"
     ]
    }
   ],
   "source": [
    "print(song)\n",
    "print(songes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Bad Company', 'Bad Company', 1974, [(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')])\n",
      "\n",
      "[(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')]\n",
      "\n",
      "(6, 'The Way I Choose')\n",
      "\n",
      "The Way I Choose\n"
     ]
    }
   ],
   "source": [
    "albums = [\n",
    "    (\"Welcome to my Nightmare\", \"Alice Cooper\", 1975,\n",
    "     [\n",
    "         (1, \"Welcome to my Nightmare\"),\n",
    "         (2, \"Devil's Food\"),\n",
    "         (3, \"The Black Widow\"),\n",
    "         (4, \"Some Folks\"),\n",
    "         (5, \"Only Women Bleed\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Bad Company\", \"Bad Company\", 1974,\n",
    "     [\n",
    "         (1, \"Can't Get Enough\"),\n",
    "         (2, \"Rock Steady\"),\n",
    "         (3, \"Ready for Love\"),\n",
    "         (4, \"Don't Let Me Down\"),\n",
    "         (5, \"Bad Company\"),\n",
    "         (6, \"The Way I Choose\"),\n",
    "         (7, \"Movin' On\"),\n",
    "         (8, \"Seagull\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Nightflight\", \"Budgie\", 1981,\n",
    "     [\n",
    "         (1, \"I Turned to Stone\"),\n",
    "         (2, \"Keeping a Rendezvous\"),\n",
    "         (3, \"Reaper of the Glory\"),\n",
    "         (4, \"She Used Me Up\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"More Mayhem\", \"Imelda May\", 2011,\n",
    "     [\n",
    "         (1, \"Pulling the Rug\"),\n",
    "         (2, \"Psycho\"),\n",
    "         (3, \"Mayhem\"),\n",
    "         (4, \"Kentish Town Waltz\"),\n",
    "     ]\n",
    "     ),\n",
    "]\n",
    " \n",
    "print(albums[1])\n",
    "print()\n",
    "print(albums[1][3])\n",
    "print()\n",
    "\n",
    "print(albums[1][3][5])\n",
    "print()\n",
    "\n",
    "print(albums[1][3][5][1])\n",
    "\n",
    "print(albums[2])\n",
    "print()\n",
    "print(albums[2][2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Nightflight', 'Budgie', 1981, [(1, 'I Turned to Stone'), (2, 'Keeping a Rendezvous'), (3, 'Reaper of the Glory'), (4, 'She Used Me Up')])\n",
      "\n",
      "1981\n"
     ]
    }
   ],
   "source": [
    "print(albums[2])\n",
    "print()\n",
    "print(albums[2][2])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23,2,45,66,77,90,13,3\n",
      "['23', '2', '45', '66', '77', '90', '13', '3']\n",
      "[23, 2, 45, 66, 77, 90, 13, 3]\n"
     ]
    }
   ],
   "source": [
    "values=\"23,2,45,66,77,90,13,3\"\n",
    "print(values)\n",
    "type(values)\n",
    "\n",
    "values_list=values.split(\",\")\n",
    "\n",
    "print(values_list)\n",
    "for index in range(len(values_list)):\n",
    "    \n",
    "    values_list[index]=int( values_list[index])\n",
    "    \n",
    "    \n",
    "    \n",
    "print( values_list,end=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 2, 45, 66, 77, 90, 13, 3]\n"
     ]
    }
   ],
   "source": [
    "empty=[]\n",
    "for value in values_list:\n",
    "    empty.append(int(value))\n",
    "print(empty)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "albums = [\n",
    "    (\"Welcome to my Nightmare\", \"Alice Cooper\", 1975,\n",
    "     [\n",
    "         (1, \"Welcome to my Nightmare\"),\n",
    "         (2, \"Devil's Food\"),\n",
    "         (3, \"The Black Widow\"),\n",
    "         (4, \"Some Folks\"),\n",
    "         (5, \"Only Women Bleed\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Bad Company\", \"Bad Company\", 1974,\n",
    "     [\n",
    "         (1, \"Can't Get Enough\"),\n",
    "         (2, \"Rock Steady\"),\n",
    "         (3, \"Ready for Love\"),\n",
    "         (4, \"Don't Let Me Down\"),\n",
    "         (5, \"Bad Company\"),\n",
    "         (6, \"The Way I Choose\"),\n",
    "         (7, \"Movin' On\"),\n",
    "         (8, \"Seagull\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"Nightflight\", \"Budgie\", 1981,\n",
    "     [\n",
    "         (1, \"I Turned to Stone\"),\n",
    "         (2, \"Keeping a Rendezvous\"),\n",
    "         (3, \"Reaper of the Glory\"),\n",
    "         (4, \"She Used Me Up\"),\n",
    "     ]\n",
    "     ),\n",
    "    (\"More Mayhem\", \"Imelda May\", 2011,\n",
    "     [\n",
    "         (1, \"Pulling the Rug\"),\n",
    "         (2, \"Psycho\"),\n",
    "         (3, \"Mayhem\"),\n",
    "         (4, \"Kentish Town Waltz\"),\n",
    "     ]\n",
    "     ),\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please use your album(invalid chioce exists):\n",
      "1:Welcome to my Nightmare,Alice Cooper,1975,[(1, 'Welcome to my Nightmare'), (2, \"Devil's Food\"), (3, 'The Black Widow'), (4, 'Some Folks'), (5, 'Only Women Bleed')]\n",
      "2:Bad Company,Bad Company,1974,[(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')]\n",
      "3:Nightflight,Budgie,1981,[(1, 'I Turned to Stone'), (2, 'Keeping a Rendezvous'), (3, 'Reaper of the Glory'), (4, 'She Used Me Up')]\n",
      "4:More Mayhem,Imelda May,2011,[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print(\"Please use your album(invalid chioce exists):\")\n",
    "    for index,(title,artist,year,songs) in enumerate(albums):\n",
    "        print(\"{}:{},{},{},{}\".format(index+1,title,artist,year,songs))\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Welcome to my Nightmare Alice Cooper 1975 [(1, 'Welcome to my Nightmare'), (2, \"Devil's Food\"), (3, 'The Black Widow'), (4, 'Some Folks'), (5, 'Only Women Bleed')]\n",
      "2 Bad Company Bad Company 1974 [(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')]\n",
      "3 Nightflight Budgie 1981 [(1, 'I Turned to Stone'), (2, 'Keeping a Rendezvous'), (3, 'Reaper of the Glory'), (4, 'She Used Me Up')]\n",
      "4 More Mayhem Imelda May 2011 [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n"
     ]
    }
   ],
   "source": [
    "for index,value in enumerate(albums):\n",
    "    \n",
    "    title,artist,year,songs=value\n",
    "    \n",
    "    \n",
    "    print(index+1,title,artist,year,songs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please use your album(invalid chioce exists):\n",
      "1:Welcome to my Nightmare\n",
      "2:Bad Company\n",
      "3:Nightflight\n",
      "4:More Mayhem\n",
      "4\n",
      "('More Mayhem', 'Imelda May', 2011, [(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')])\n",
      "[(1, 'Pulling the Rug'), (2, 'Psycho'), (3, 'Mayhem'), (4, 'Kentish Town Waltz')]\n",
      "\n",
      "choose your song\n",
      "1:Pulling the Rug\n",
      "2:Psycho\n",
      "3:Mayhem\n",
      "4:Kentish Town Waltz\n",
      "3\n",
      "playing..... Mayhem\n",
      "========================================\n",
      "Please use your album(invalid chioce exists):\n",
      "1:Welcome to my Nightmare\n",
      "2:Bad Company\n",
      "3:Nightflight\n",
      "4:More Mayhem\n",
      "1\n",
      "('Welcome to my Nightmare', 'Alice Cooper', 1975, [(1, 'Welcome to my Nightmare'), (2, \"Devil's Food\"), (3, 'The Black Widow'), (4, 'Some Folks'), (5, 'Only Women Bleed')])\n",
      "[(1, 'Welcome to my Nightmare'), (2, \"Devil's Food\"), (3, 'The Black Widow'), (4, 'Some Folks'), (5, 'Only Women Bleed')]\n",
      "\n",
      "choose your song\n",
      "1:Welcome to my Nightmare\n",
      "2:Devil's Food\n",
      "3:The Black Widow\n",
      "4:Some Folks\n",
      "5:Only Women Bleed\n",
      "6\n",
      "1:Welcome to my Nightmare\n",
      "2:Devil's Food\n",
      "3:The Black Widow\n",
      "4:Some Folks\n",
      "5:Only Women Bleed\n",
      "playing..... More Mayhem\n",
      "========================================\n",
      "Please use your album(invalid chioce exists):\n",
      "1:Welcome to my Nightmare\n",
      "2:Bad Company\n",
      "3:Nightflight\n",
      "4:More Mayhem\n",
      "2\n",
      "('Bad Company', 'Bad Company', 1974, [(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')])\n",
      "[(1, \"Can't Get Enough\"), (2, 'Rock Steady'), (3, 'Ready for Love'), (4, \"Don't Let Me Down\"), (5, 'Bad Company'), (6, 'The Way I Choose'), (7, \"Movin' On\"), (8, 'Seagull')]\n",
      "\n",
      "choose your song\n",
      "1:Can't Get Enough\n",
      "2:Rock Steady\n",
      "3:Ready for Love\n",
      "4:Don't Let Me Down\n",
      "5:Bad Company\n",
      "6:The Way I Choose\n",
      "7:Movin' On\n",
      "8:Seagull\n",
      "9\n",
      "1:Can't Get Enough\n",
      "2:Rock Steady\n",
      "3:Ready for Love\n",
      "4:Don't Let Me Down\n",
      "5:Bad Company\n",
      "6:The Way I Choose\n",
      "7:Movin' On\n",
      "8:Seagull\n",
      "playing..... More Mayhem\n",
      "========================================\n",
      "Please use your album(invalid chioce exists):\n",
      "1:Welcome to my Nightmare\n",
      "2:Bad Company\n",
      "3:Nightflight\n",
      "4:More Mayhem\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#Simple JukeBox\n",
    "SONGS_LIST_INDEX=3 #constant\n",
    "SONGS_TITLE_INDEX=1 #constant\n",
    "while True:\n",
    "    print(\"Please use your album(invalid chioce exists):\")\n",
    "    for index,(title,artist,year,songs) in enumerate(albums):\n",
    "        print(\"{}:{}\".format(index+1,title))\n",
    "    \n",
    "    choice=int(input())\n",
    "    if 1<=choice<=len(albums):\n",
    "        songs_list=albums[choice-1][SONGS_LIST_INDEX]\n",
    "    else:\n",
    "        break\n",
    "    print(albums[choice-1])\n",
    "    print(songs_list)\n",
    "    print()\n",
    "    \n",
    "    print(\"choose your song\")\n",
    "    for index,(track,song) in enumerate(songs_list):\n",
    "        print(\"{}:{}\".format(index+1,song))\n",
    "    \n",
    "    song_choice=int(input())\n",
    "    if 1<=song_choice<=len(songs_list):\n",
    "        title=songs_list[song_choice-1][SONGS_TITLE_INDEX]\n",
    "    else:\n",
    "        \n",
    "        \n",
    "       for index,(track,song) in enumerate(songs_list):\n",
    "        \n",
    "        print(\"{}:{}\".format(index+1,song))\n",
    "        \n",
    "        break\n",
    "        \n",
    "        \n",
    "        \n",
    "    print(\"playing..... {}\".format(title))\n",
    "    print( '=' * 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}