class_08_20191208_List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List & Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to check methods, attributes\n",
    "\n",
    "len(dir(list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#index #   0,       1,       2,     3,  4, 5, 6, 7\n",
    "\n",
    "names = [\"Adnan\",\"Ismail\",\"Zafar\",\"Ali\",1, 2, 3, 4]\n",
    "\n",
    "#index #   -8,      -7,      -6,    -5,-4,-3,-2,-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 4]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Slicing\n",
    "\n",
    "List[Start:Stop:Step]\n",
    "print(names[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Append Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# append method is used to insert new values at the end.\n",
    "\n",
    "names = []\n",
    "\n",
    "names.append(\"A\")\n",
    "names.append(\"B\")\n",
    "names.append(\"C\")\n",
    "\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clear Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clear method clears / removes all values from list\n",
    "\n",
    "names.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now aftetr executing clear() list 'names' is empty\n",
    "\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Adnan\",\"Ismail\",\"Zafar\",\"Ali\",1, 2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 4]\n",
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "name = names      # this is a shallow copy, it copies only address rather than contents\n",
    "print(names)\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "name[7]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 0]\n"
     ]
    }
   ],
   "source": [
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 0]\n"
     ]
    }
   ],
   "source": [
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Adnan\",\"Ismail\",\"Zafar\",\"Ali\",1, 2, 3, 4]\n",
    "\n",
    "name = names.copy()    # This is a type of Deep Copy, it copies contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "name[7]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 0]\n"
     ]
    }
   ],
   "source": [
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Adnan', 'Ismail', 'Zafar', 'Ali', 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\"A\",\"B\",\"A\",\"C\",\"D\",\"C\",\"C\"]\n",
    "names.count(\"C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [\"A\",\"B\",\"C\"]\n",
    "l2 = [\"X\",\"Y\",\"Z\"]\n",
    "\n",
    "l3 = l1 + l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C', 'X', 'Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "l3 = l1.extend(l2)     # In memory operation performed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "['A', 'B', 'C', 'X', 'Y', 'Z']\n",
      "['X', 'Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "print(l3)\n",
    "print(l1)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1.index(\"C\")    # returns index of value 'C', it returns only index of first 'C'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = ['A', 'B', 'C', 'A', 'D', 'E','A']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(l1.index(\"A\",1))\n",
    "print(l1.index(\"A\",4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Z', 'Y', 'X', 'A', 'B', 'C', 'A', 'D', 'E', 'A']\n"
     ]
    }
   ],
   "source": [
    "l1.insert(0,\"X\")\n",
    "l1.insert(0,\"Y\")\n",
    "l1.insert(0,\"Z\")\n",
    "\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1.insert(1,\"M\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Z', 'M', 'Y', 'X', 'A', 'B', 'C', 'A', 'D', 'E', 'A']\n"
     ]
    }
   ],
   "source": [
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pop Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B']\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "# pop() removes item from list from the end (by default), however, it also removes from the given index also\n",
    "# it also has 'return'\n",
    "\n",
    "l1 = [\"A\",\"B\",\"C\"]\n",
    "a = l1.pop()    # variable 'a' is defined to store deleted values / items from list 'l1'\n",
    "print(l1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'B'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [\"A\",\"B\",\"C\"]\n",
    "l1.pop(1)   # this will remove value 'B' from list 'l1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1  # remaining values of list 'l1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'C', 'D', 'C']\n"
     ]
    }
   ],
   "source": [
    "#  Remove by text value\n",
    "\n",
    "l1 = [\"A\",\"B\",\"C\",\"C\",\"D\",\"C\"]\n",
    "l1.remove(\"C\")\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'Z', 'C', 'X', 'M']\n",
      "['M', 'X', 'C', 'Z', 'B', 'A']\n"
     ]
    }
   ],
   "source": [
    "# it reverse the values / contents without any order\n",
    "\n",
    "l1 = ['A','B','Z','C','X','M']\n",
    "print(l1)\n",
    "l1.reverse()\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'Z', 'C', 'X', 'M']\n",
      "['A', 'B', 'C', 'M', 'X', 'Z']\n",
      "['Z', 'X', 'M', 'C', 'B', 'A']\n"
     ]
    }
   ],
   "source": [
    "# it sorts in ascending order\n",
    "\n",
    "l1 = ['A','B','Z','C','X','M']\n",
    "print(l1)\n",
    "l1.sort()\n",
    "print(l1)\n",
    "\n",
    "l1.reverse()\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addition through __add__ Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C', 'D', 'E']"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [\"A\",\"B\",\"C\"]\n",
    "l1.__add__([\"D\",\"E\"])   # in line operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = ['A','C','D']\n",
    "l1.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contains Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "l1 = ['A','C','D']\n",
    "print(l1.__contains__(\"A\"))\n",
    "\n",
    "print(\"A\" in l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan',\n",
       " 'Pakistan']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# loops are used to perform any action iteratively / repeatedly \n",
    "\n",
    "[\"Pakistan\"] * 10 # it prints Pakistan for 10 times"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Loop contains following three elements:\n",
    "\n",
    "1) counter\n",
    "2 logic / condition\n",
    "3) Increment / Decrement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Pakistan\n",
      "2 Pakistan\n",
      "3 Pakistan\n",
      "4 Pakistan\n",
      "5 Pakistan\n",
      "6 Pakistan\n",
      "7 Pakistan\n",
      "8 Pakistan\n",
      "9 Pakistan\n",
      "10 Pakistan\n"
     ]
    }
   ],
   "source": [
    "counter = 1    # counter\n",
    "\n",
    "while counter <= 10:     # logic / condition\n",
    "    print(counter, \"Pakistan\")\n",
    "    counter += 1      # increment 1 upon each iteration"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "for (count; logic; increment){\n",
    "    \n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Pakistan\n",
      "2 Pakistan\n",
      "3 Pakistan\n",
      "4 Pakistan\n",
      "5 Pakistan\n",
      "6 Pakistan\n",
      "7 Pakistan\n",
      "8 Pakistan\n",
      "9 Pakistan\n",
      "10 Pakistan\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(i, \"Pakistan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 Pakistan\n",
      "99 Pakistan\n",
      "98 Pakistan\n",
      "97 Pakistan\n",
      "96 Pakistan\n",
      "95 Pakistan\n",
      "94 Pakistan\n",
      "93 Pakistan\n",
      "92 Pakistan\n",
      "91 Pakistan\n",
      "90 Pakistan\n"
     ]
    }
   ],
   "source": [
    "counter = 100    # counter\n",
    "\n",
    "while counter >= 90:     # logic / condition\n",
    "    print(counter, \"Pakistan\")\n",
    "    counter -= 1      # increment 1 upon each iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Pakistan1',\n",
       " 'Pakistan2',\n",
       " 'Pakistan3',\n",
       " 'Pakistan4',\n",
       " 'Pakistan5',\n",
       " 'Pakistan6',\n",
       " 'Pakistan7',\n",
       " 'Pakistan8',\n",
       " 'Pakistan9',\n",
       " 'Pakistan10']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"Pakistan\" + str(x) for x in range(1,11)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 X 1 = 2\n",
      "2 X 2 = 4\n",
      "2 X 3 = 6\n",
      "2 X 4 = 8\n",
      "2 X 5 = 10\n",
      "2 X 6 = 12\n",
      "2 X 7 = 14\n",
      "2 X 8 = 16\n",
      "2 X 9 = 18\n",
      "2 X 10 = 20\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    print(2, \"X\", i , \"=\", 2*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 X 1 = 2\n",
      "2 X 2 = 4\n",
      "2 X 3 = 6\n",
      "2 X 4 = 8\n",
      "2 X 5 = 10\n",
      "2 X 6 = 12\n",
      "2 X 7 = 14\n",
      "2 X 8 = 16\n",
      "2 X 9 = 18\n",
      "2 X 10 = 20\n"
     ]
    }
   ],
   "source": [
    "# printing table of '2' using for loop with '+' sign concatenation\n",
    "\n",
    "for i in range(1,11):\n",
    "    print(\"2 X \" + str(i) +  \" = \" + str(2*i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2 X 1 = 2',\n",
       " '2 X 2 = 4',\n",
       " '2 X 3 = 6',\n",
       " '2 X 4 = 8',\n",
       " '2 X 5 = 10',\n",
       " '2 X 6 = 12',\n",
       " '2 X 7 = 14',\n",
       " '2 X 8 = 16',\n",
       " '2 X 9 = 18',\n",
       " '2 X 10 = 20']"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for loop in single line\n",
    "\n",
    "[\"2 X \" + str(i) +  \" = \" + str(2*i) for i in range(1,11)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1,2,3,2,1)\n",
    "a.count(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find index of value 3 of tuple 'a'\n",
    "\n",
    "a.index(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Take name, father_name, contact_no from user\n",
    "and store in list until user opt 'No'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 1\n",
    "data = []\n",
    "check = True\n",
    "\n",
    "while check == True:\n",
    "    data.append(input(\"Please enter your name: \"))\n",
    "    data.append(input(\"Please enter father name: \"))\n",
    "    data.append(input(\"Please enter your contact number: \"))\n",
    "\n",
    "    if check == True:\n",
    "        check = input(\"Do you want to insert more records (y/n): \")\n",
    "        check = check.lower()\n",
    "    if check != 'y' or check != 'n':\n",
    "        print(\"Please select correct options, 'Y' or 'N': \")\n",
    "        check = check.lower()\n",
    "        if check == 'y' or check == 'Y':\n",
    "            check = True\n",
    "        else:\n",
    "            check = False\n",
    "                \n",
    "print(data)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print 1000 to 990 decreasingly using while loop\n",
    "\n",
    "counter = 1000    # counter\n",
    "\n",
    "while counter >= 990:     # logic / condition\n",
    "    print(counter)\n",
    "    counter -= 1      # decrement 1 upon each iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print 1000 to 990 decreasingly using for loop\n",
    "\n",
    "for i in range(1000,990-1,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 65-90, 97-122, 48-57\n",
    "# A a 0\n",
    "# B b 1\n",
    "# C c 3\n",
    "\n",
    "for i in range(65,90+1):\n",
    "    i += 1\n",
    "    for m in range(97,122+1):\n",
    "        print(chr(i) + \" \" + chr(m) + \" \" + str(n))    \n",
    "        m += 1\n",
    "        for n in range(48,57+1):\n",
    "            n +=1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "take input from user\n",
    "if user enter 3\n",
    "\n",
    "then your output:\n",
    "    \n",
    "1 x 1 =              2 x 1 =           3 x 1 =   \n",
    "1 x 2 =              2 x 2 =           3 x 2 =   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,11):    \n",
    "    print(1, \"X\", i , \"=\", 1*i, \"     \", 2, \"X\", i , \"=\", 2*i, \"     \", 3, \"X\", i , \"=\", 3*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 4 "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print row number and column number of fol matrix if any element is divisible by '5'\n",
    "\n",
    "[[2,5,9],\n",
    "[8,9,10],\n",
    "[20,30,27],\n",
    "[35,9,20]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l= [[2,5,9],\n",
    "    [8,9,10],\n",
    "    [20,30,27],\n",
    "    [35,9,20]]\n",
    "\n",
    "for ri, r in enumerate(l):\n",
    "    for ci,c in enumerate(r):\n",
    "        if c % 5 == 0:\n",
    "            print((ri,ci,c), end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 5"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# find numbers contains in table of 5, 7 & 20 from 1 - 1000\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for num in range(1,31):\n",
    "    if num % 5 == 0:\n",
    "        print(num, \"is in Table of 5.\")\n",
    "    elif num % 7 == 0:\n",
    "        print(num, \"is in Table of 7.\")\n",
    "    elif num % 20 == 0:\n",
    "        print(num, \"is in Table of 20.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Task # 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Class Task # 6\n",
    "if man_proposes == True:                      # case no.1\n",
    "    print(\"Its Direct Marketing\")\n",
    "elif friend_msg == True:                         # case no.2\n",
    "    print(\"Its Advertising\")\n",
    "elif girl_proposes == True:                           # case no.3\n",
    "    print(\"Its Brand Recognition\")\n",
    "elif man_proposes == True and slap == True:                # case no.4\n",
    "    print(\"Its Customer Feedback\")\n",
    "elif man_proposes == True and intro_huby == True:               # case no.5\n",
    "    print(\"Its Demand and Supply Gap\")\n",
    "else:\n",
    "    print(\"That's restriction from entering a new market\")          # case no.6\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initiative = input(\"Who Proposes? Enter 'You', 'friend' or 'girl': \") # you, girl, friend\n",
    "initiative = initiative.lower()\n",
    "\n",
    "if initiative == 'friend':\n",
    "    print(\"It's Advertising.\")\n",
    "elif initiative == 'girl':\n",
    "    print(\"It's Brand Recognition.\")\n",
    "elif initiative == 'you':\n",
    "    slap = input(\"Please enter 'Y' or 'N' for slap: \")\n",
    "    slap = slap.lower()\n",
    "    if initiative == 'you' and slap == 'y':\n",
    "        print(\"It's Customer's Feedback.\")\n",
    "    else:\n",
    "        husband = input(\"Please enter 'Y' or 'N' for husband: \")\n",
    "        husband = husband.lower()\n",
    "        if initiative == 'you' and husband == 'y':\n",
    "            print(\"It's Demand and Supply Gap.\")\n",
    "        else:\n",
    "            if initiative == 'you' and slap != 'y' and husband != 'y':\n",
    "                print(\"It's Direct Marketing.\")\n",
    "else:\n",
    "    print(\"It's restriction to enter new market.\") "
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}