Questions assigned in Full Stack Data Science Class -- 28-05-22.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a54fb1cf",
   "metadata": {},
   "source": [
    "# Questions assigned in Full Stack Data Science Class -- 28-05-22"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75288dce",
   "metadata": {},
   "source": [
    "### q1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934b90c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "ineuron\n",
    "ineuron ineuron\n",
    "ineuron ineuron ineuron\n",
    "ineuron ineuron ineuron ineuron"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f3fe23a",
   "metadata": {},
   "source": [
    "##### ANSWER: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "95f8b1cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ineuron \n",
      "ineuron ineuron \n",
      "ineuron ineuron ineuron \n",
      "ineuron ineuron ineuron ineuron \n"
     ]
    }
   ],
   "source": [
    "n = 4\n",
    "for i in range(4):\n",
    "    for j in range(0, i+1):\n",
    "        print(\"ineuron\", end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "524eb504",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter how many rows you want to print: 4\n",
      "\n",
      "ineuron \n",
      "ineuron ineuron \n",
      "ineuron ineuron ineuron \n",
      "ineuron ineuron ineuron ineuron \n"
     ]
    }
   ],
   "source": [
    "#alternate solution that is more optimized\n",
    "row = int(input(\"Please enter how many rows you want to print: \"))\n",
    "print()\n",
    "for i in range(row):\n",
    "    print(\"ineuron \"*(i+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f81754f",
   "metadata": {},
   "source": [
    "### q2 - "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33e379ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "           ineuron  \n",
    "           \n",
    "    ineuron       ineuron\n",
    "    \n",
    "ineuron      ineuron       ineuron \n",
    "\n",
    "    ineuron       ineuron\n",
    "    \n",
    "          ineuron"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b96b02e",
   "metadata": {},
   "source": [
    "##### ANSWER: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b6a46e83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                  \n",
      "                     ineuron                      \n",
      "                 ineuron ineuron                  \n",
      "             ineuron ineuron ineuron              \n",
      "                 ineuron ineuron                  \n",
      "                     ineuron                      \n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    if i <=3:\n",
    "        n = i\n",
    "    else:\n",
    "        n = 6 - i\n",
    "    print((\"ineuron \"*n).center(50, ' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05f9299e",
   "metadata": {},
   "source": [
    "### l = [[1,2,3,4], (2,3,4,5,6), (3,4,5,6,7), set([23,4,5,45,4,4,5,45,45,4,5]), {'k1': \"sudh\", \"k2\" : \"ineuron\", \"k3\" : \"kumar\", 3:6, 7:8}, [\"ineuron\", \"data science\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5f5d7acc",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [[1,2,3,4], (2,3,4,5,6), (3,4,5,6,7), set([23,4,5,45,4,4,5,45,45,4,5]), {'k1': \"sudh\", \"k2\" : \"ineuron\", \"k3\" : \"kumar\", \n",
    "                                                                             3:6, 7:8}, [\"ineuron\", \"data science\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c89c63fc",
   "metadata": {},
   "source": [
    "### q3: Try to extract all the list entity."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9037b7fd",
   "metadata": {},
   "source": [
    "##### ANSWER: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8aa3feb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['ineuron', 'data science']\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i) == list:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25242435",
   "metadata": {},
   "source": [
    "### q4: Try to extract all the dict entities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9af7d5ab",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7f08862b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'k1': 'sudh', 'k2': 'ineuron', 'k3': 'kumar', 3: 6, 7: 8}\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i) == dict:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f43233cc",
   "metadata": {},
   "source": [
    "### q5: Try to extract all the tuples entities."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1481e8d",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "eb3b552c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4, 5, 6)\n",
      "(3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i) == tuple:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98dc5fee",
   "metadata": {},
   "source": [
    "### q6: Try to extract all the numerical data it maybe a part of dict key and values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "646c97be",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6e572e4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = []\n",
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                l1.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if type(k) == int or type(v) == int:\n",
    "                l1.append(k)\n",
    "                l1.append(v)\n",
    "l1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e1e4b4e",
   "metadata": {},
   "source": [
    "### q7: Try to give summation of all the numeric data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1728888",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "96eb99e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2 = []\n",
    "\n",
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                l2.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if type(k) == int or type(v) == int:\n",
    "                l2.append(k)\n",
    "                l2.append(v)\n",
    "l2    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d569895f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5f7d10f",
   "metadata": {},
   "source": [
    "### q8: Try to filter out all the odd values out all numeric data which is a part of a list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "352ccefb",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "08992042",
   "metadata": {},
   "outputs": [],
   "source": [
    "l3 = []\n",
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                l3.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if type(k) == int or type(v) == int:\n",
    "                l3.append(k)\n",
    "                l3.append(v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4f8e0241",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "97c48503",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "3\n",
      "5\n",
      "3\n",
      "5\n",
      "7\n",
      "45\n",
      "5\n",
      "23\n",
      "3\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for i in l3:\n",
    "    if i%2 == 1:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "512b1f35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to filter out all the odd values out all numeric data which is a part of only the lists that are pesent inside the list\n",
    "l5 = []\n",
    "for i in l:\n",
    "    if type(i) == list:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                l5.append(j)\n",
    "l5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c28d1d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ca7eff60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in l5:\n",
    "    if i%2 == 1:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394ea375",
   "metadata": {},
   "source": [
    "### q9: Try to extract \"ineuron\" out of this data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f46f937",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bec99b4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ineuron', 'ineuron']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l4 = []\n",
    "\n",
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            if j == \"ineuron\":\n",
    "                l4.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if k == \"ineuron\" or v == \"ineuron\":\n",
    "                l4.append(v)\n",
    "l4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f783491",
   "metadata": {},
   "source": [
    "### q10: Try to find out the number of occurances of all the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46bb14cd",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d4cd4af9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'ineuron', 'data science']\n",
      "[45, 4, 5, 23]\n",
      "[2, 3, 4, 5, 6, 3, 4, 5, 6, 7]\n",
      "['k1', 'sudh', 'k2', 'ineuron', 'k3', 'kumar', 3, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "t1 = []\n",
    "t2 = []\n",
    "t3 = []\n",
    "t4 = []\n",
    "\n",
    "for i in l:\n",
    "    if type(i) == list:\n",
    "        for j in i:\n",
    "            t1.append(j)\n",
    "    if type(i) == set:\n",
    "        for j in i:\n",
    "            t2.append(j)\n",
    "    if type(i) == tuple:\n",
    "        for j in i:\n",
    "            t3.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            t4.append(k)\n",
    "            t4.append(v)\n",
    "print(t1)\n",
    "print(t2)\n",
    "print(t3)\n",
    "print(t4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6afe10a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 'data science', 'ineuron'}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f9610350",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5, 23, 45}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a97e5bee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(t3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "034f0fc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 6, 7, 8, 'ineuron', 'k1', 'k2', 'k3', 'kumar', 'sudh'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(t4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "044e50dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 'ineuron', 'data science', 45, 4, 5, 23, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 'k1', 'sudh', 'k2', 'ineuron', 'k3', 'kumar', 3, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "t5 = t1 + t2 + t3 + t4\n",
    "print(t5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c35a0ee8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 : 1\n",
      "2 : 2\n",
      "3 : 4\n",
      "4 : 4\n",
      "5 : 3\n",
      "6 : 3\n",
      "7 : 2\n",
      "k2 : 1\n",
      "8 : 1\n",
      "kumar : 1\n",
      "45 : 1\n",
      "ineuron : 2\n",
      "23 : 1\n",
      "data science : 1\n",
      "k1 : 1\n",
      "k3 : 1\n",
      "sudh : 1\n"
     ]
    }
   ],
   "source": [
    "for i in set(t5):\n",
    "    print(i, \":\", t5.count(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90d582b0",
   "metadata": {},
   "source": [
    "### q11: Try to find out the number of keys in dict element."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4adc73ab",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "67c95ce5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i) == dict:\n",
    "        print(len(i.keys()))           "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9b5af26",
   "metadata": {},
   "source": [
    "### q12: Try to filter out all the string data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1884252",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1b847dae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "sudh\n",
      "k2\n",
      "ineuron\n",
      "k3\n",
      "kumar\n",
      "ineuron\n",
      "data science\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            if type(j) == str:\n",
    "                print(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if type(k) == str or type(v) == str:\n",
    "                print(k)\n",
    "                print(v)               "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cdbf110",
   "metadata": {},
   "source": [
    "### q13: Try to find out alphanum in data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad0dfd88",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "635b218b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 'ineuron',\n",
       " 'data science',\n",
       " 45,\n",
       " 4,\n",
       " 5,\n",
       " 23,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 'k1',\n",
       " 'sudh',\n",
       " 'k2',\n",
       " 'ineuron',\n",
       " 'k3',\n",
       " 'kumar',\n",
       " 3,\n",
       " 6,\n",
       " 7,\n",
       " 8]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "221984bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ineuron\n",
      "k1\n",
      "sudh\n",
      "k2\n",
      "ineuron\n",
      "k3\n",
      "kumar\n"
     ]
    }
   ],
   "source": [
    "for i in t5:\n",
    "    if type(i) == str:\n",
    "        if i.isalnum():\n",
    "            print(i) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93dc2e5",
   "metadata": {},
   "source": [
    "### q14: Try to find out multiplication of all numeric value in individual collection inside dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f1597e9",
   "metadata": {},
   "source": [
    "##### ANSWER:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "d9c844ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[45, 4, 5, 23]\n",
      "[2, 3, 4, 5, 6, 3, 4, 5, 6, 7]\n",
      "[3, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "l6 = []\n",
    "l7 = []\n",
    "l8 = []\n",
    "l9 = []\n",
    "\n",
    "for i in l:\n",
    "    if type(i) == list:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                l6.append(j)\n",
    "    if type(i) == set:\n",
    "        for m in i:\n",
    "            if type(m) == int:\n",
    "                l7.append(m)\n",
    "    if type(i) == tuple:\n",
    "        for n in i:\n",
    "            if type(n) == int:\n",
    "                l8.append(n)          \n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            if type(k) == int or type(v) == int:\n",
    "                l9.append(k)\n",
    "                l9.append(v)\n",
    "print(l6)\n",
    "print(l7)\n",
    "print(l8)\n",
    "print(l9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "1c562240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "mul_l6 = np.prod(l6)\n",
    "mul_l6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "67870f04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20700"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mul_l7 = np.prod(l7)\n",
    "mul_l7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "efd3f086",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1814400"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mul_l8 = np.prod(l8)\n",
    "mul_l8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "52750b34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1008"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mul_l9 = np.prod(l9)\n",
    "mul_l9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fd687dbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> 24\n",
      "<class 'tuple'> 720\n",
      "<class 'tuple'> 2520\n",
      "<class 'set'> 20700\n",
      "<class 'dict'> 1008\n",
      "<class 'list'> 1\n"
     ]
    }
   ],
   "source": [
    "# alternate solution without using numpy \n",
    "for i in l:\n",
    "    m = 1\n",
    "    if type(i) == list or type(i) == tuple or type(i) == set:\n",
    "        for j in i:\n",
    "            if type(j) == int:\n",
    "                m = m*j\n",
    "        print(type(i), m)\n",
    "    if type(i) == dict:\n",
    "        for k in i.items():\n",
    "            for n in k:\n",
    "                if type(n) == int:\n",
    "                    m = m*n\n",
    "        print(type(i), m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cbd2517c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "908605071360000\n"
     ]
    }
   ],
   "source": [
    "# for multiplying all the numeric values inside the list altogther\n",
    "j = 1\n",
    "for i in l1:\n",
    "    if type(i) == int:\n",
    "        j = j*i\n",
    "print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dfad695",
   "metadata": {},
   "source": [
    "### q15: Try to unwarpe all the collection inside collection and create a flat list."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9d7cc98",
   "metadata": {},
   "source": [
    "##### ANSWER: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "0da2fe57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 'k1', 'sudh', 'k2', 'ineuron', 'k3', 'kumar', 3, 6, 7, 8, 'ineuron', 'data science']\n"
     ]
    }
   ],
   "source": [
    "flat_list = []\n",
    "for i in l:\n",
    "    if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "        for j in i:\n",
    "            flat_list.append(j)\n",
    "    if type(i) == dict:\n",
    "        for k, v in i.items():\n",
    "            flat_list.append(k)\n",
    "            flat_list.append(v)\n",
    "            \n",
    "print(flat_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c2f6729f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 'ineuron',\n",
       " 'data science',\n",
       " 45,\n",
       " 4,\n",
       " 5,\n",
       " 23,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 'k1',\n",
       " 'sudh',\n",
       " 'k2',\n",
       " 'ineuron',\n",
       " 'k3',\n",
       " 'kumar',\n",
       " 3,\n",
       " 6,\n",
       " 7,\n",
       " 8]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t5  #the output of l1 is the flat list in itself"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}