Task assigned in Full Stack Data Science Class -- 02-07-2022.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "551eb1ba",
   "metadata": {},
   "source": [
    "# Task assigned in Full Stack Data Science Class -- 02-07-2022"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "787a9125",
   "metadata": {},
   "source": [
    "### Task - In a past whatever questions i have given to your with respect to list , tuple , dic , set , string. Try to create a seprate class for each and everyting and restructure your code for all the segment and submit . \n",
    "\n",
    "#### Instruction number 1 -  Always use exception handling. \n",
    "\n",
    "#### Instruction number 2 - Use loggging as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f0dade1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging \n",
    "logging.basicConfig(filename = \"string.log\", level = logging.INFO, format = '%(levelname)s %(name)s %(asctime)s %(message)s')\n",
    "\n",
    "class String:\n",
    "    \n",
    "    def upper_string(self):\n",
    "        logging.info(\"The is a function for turning the string into uppercase\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s2 = s.upper()\n",
    "            logging.info(s2)\n",
    "            return s2\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def lower_string(self):\n",
    "        logging.info(\"This is a function for turning the string into lowercase\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s4 = s.lower()\n",
    "            logging.info(s4)\n",
    "            return s4\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def capitalize_string(self):\n",
    "        logging.info(\"This is a function for capitalizing a string\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s5 = s.capitalize()\n",
    "            logging.info(s5)\n",
    "            return s5\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def strip_string(self):\n",
    "        logging.info(\"This is a function to strip spaces from both the front and end of a string\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s6 = s.strip()\n",
    "            logging.info(s6)\n",
    "            return s6\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def lstrip_string(self):\n",
    "        logging.info(\"This is a function to strip the space from the left side of the string\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s7 = s.lstrip()\n",
    "            logging.info(s7)\n",
    "            return s7\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def rstrip_string(self):\n",
    "        logging.info(\"This is a function to strip the space from the right side of the string\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s8 = s.rstrip()\n",
    "            logging.info(s8)\n",
    "            return s8\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def center_string(self):\n",
    "        logging.info(\"This is a function to align a string to a center position\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s10 = s.center(20)\n",
    "            logging.info(s10)\n",
    "            return s10\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "     \n",
    "    def split_upper_string(self):\n",
    "        logging.info(\"This is a function that turns a string into uppercase then splits it\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s3 = s.upper()\n",
    "            s11 = s3.split(' ')\n",
    "            logging.info(s11)\n",
    "            return s11\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def reverse_string(self):\n",
    "        logging.info(\"This is a function to reverse a string\")\n",
    "        logging.info(\"Asking for a string as an input from user\")\n",
    "        s = str(input(\"Please enter a string: \"))\n",
    "        logging.info(s)\n",
    "        try:\n",
    "            s1 = s[::-1]\n",
    "            logging.info(s1)\n",
    "            return s1\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "\n",
    "String_Var = String()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b4eb6d2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: this is My First Python programming class and i am learNING python string and its function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'THIS IS MY FIRST PYTHON PROGRAMMING CLASS AND I AM LEARNING PYTHON STRING AND ITS FUNCTION'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.upper_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "05cf92ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: this is My First Python programming class and i am learNING python string and its function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'this is my first python programming class and i am learning python string and its function'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.lower_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d93ddb31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: this is My First Python programming class and i am learNING python string and its function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'This is my first python programming class and i am learning python string and its function'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.capitalize_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f654a731",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string:      xyz     \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'xyz'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.strip_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e2cbdb95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string:      xyz     \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'xyz     '"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.lstrip_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a705d41d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string:      xyz     \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'     xyz'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.rstrip_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f7d88134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: abc\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'        abc         '"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.center_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fbec461d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: this is My First Python programming class and i am learNING python string and its function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['THIS',\n",
       " 'IS',\n",
       " 'MY',\n",
       " 'FIRST',\n",
       " 'PYTHON',\n",
       " 'PROGRAMMING',\n",
       " 'CLASS',\n",
       " 'AND',\n",
       " 'I',\n",
       " 'AM',\n",
       " 'LEARNING',\n",
       " 'PYTHON',\n",
       " 'STRING',\n",
       " 'AND',\n",
       " 'ITS',\n",
       " 'FUNCTION']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.split_upper_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b86f61ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a string: this is My First Python programming class and i am learNING python string and its function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'noitcnuf sti dna gnirts nohtyp GNINrael ma i dna ssalc gnimmargorp nohtyP tsriF yM si siht'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "String_Var.reverse_string()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1ef36a89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO root 2022-07-03 01:49:32,347 The is a function for turning the string into uppercase\n",
      "INFO root 2022-07-03 01:49:32,349 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:12,601 this is My First Python programming class and i am learNING python string and its function\n",
      "INFO root 2022-07-03 01:50:12,601 THIS IS MY FIRST PYTHON PROGRAMMING CLASS AND I AM LEARNING PYTHON STRING AND ITS FUNCTION\n",
      "INFO root 2022-07-03 01:50:15,467 This is a function for turning the string into lowercase\n",
      "INFO root 2022-07-03 01:50:15,468 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:18,301 this is My First Python programming class and i am learNING python string and its function\n",
      "INFO root 2022-07-03 01:50:18,302 this is my first python programming class and i am learning python string and its function\n",
      "INFO root 2022-07-03 01:50:20,980 This is a function for capitalizing a string\n",
      "INFO root 2022-07-03 01:50:20,981 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:23,601 this is My First Python programming class and i am learNING python string and its function\n",
      "INFO root 2022-07-03 01:50:23,601 This is my first python programming class and i am learning python string and its function\n",
      "INFO root 2022-07-03 01:50:41,816 This is a function to strip spaces from both the front and end of a string\n",
      "INFO root 2022-07-03 01:50:41,817 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:44,520      xyz     \n",
      "INFO root 2022-07-03 01:50:44,521 xyz\n",
      "INFO root 2022-07-03 01:50:45,614 This is a function to strip the space from the left side of the string\n",
      "INFO root 2022-07-03 01:50:45,616 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:47,810      xyz     \n",
      "INFO root 2022-07-03 01:50:47,810 xyz     \n",
      "INFO root 2022-07-03 01:50:49,126 This is a function to strip the space from the right side of the string\n",
      "INFO root 2022-07-03 01:50:49,126 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:50:51,238      xyz     \n",
      "INFO root 2022-07-03 01:50:51,238      xyz\n",
      "INFO root 2022-07-03 01:50:54,000 This is a function to align a string to a center position\n",
      "INFO root 2022-07-03 01:50:54,001 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:51:09,466 abc\n",
      "INFO root 2022-07-03 01:51:09,466         abc         \n",
      "INFO root 2022-07-03 01:51:13,561 This is a function that turns a string into uppercase then splits it\n",
      "INFO root 2022-07-03 01:51:13,562 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:51:28,839 this is My First Python programming class and i am learNING python string and its function\n",
      "INFO root 2022-07-03 01:51:28,840 ['THIS', 'IS', 'MY', 'FIRST', 'PYTHON', 'PROGRAMMING', 'CLASS', 'AND', 'I', 'AM', 'LEARNING', 'PYTHON', 'STRING', 'AND', 'ITS', 'FUNCTION']\n",
      "INFO root 2022-07-03 01:51:33,172 This is a function to reverse a string\n",
      "INFO root 2022-07-03 01:51:33,172 Asking for a string as an input from user\n",
      "INFO root 2022-07-03 01:51:35,809 this is My First Python programming class and i am learNING python string and its function\n",
      "INFO root 2022-07-03 01:51:35,809 noitcnuf sti dna gnirts nohtyp GNINrael ma i dna ssalc gnimmargorp nohtyP tsriF yM si siht\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"string.log\", 'r')\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c45ed3df",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logging.basicConfig(filename = \"lst.log\", level = logging.INFO, format = '%(levelname)s %(name)s %(asctime)s %(message)s')\n",
    "\n",
    "class List:\n",
    "    def __init__(self, list):\n",
    "        self.list = list\n",
    "    \n",
    "\n",
    "    def access_int_list(self):\n",
    "        logging.info(\"This is a function to access intergers in the list\")\n",
    "        l = self.list\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            l2 = []\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",
    "                            logging.info(l2)\n",
    "                            return l2\n",
    "        except Exception as e:\n",
    "            loggging.exception(e)\n",
    "\n",
    "    def extract_list_entity(self):\n",
    "        logging.info(\"This is a function to extract only list entities for the dataset\")\n",
    "        l = self.list\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == list:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "            \n",
    "    def extract_dict_elements(self):\n",
    "        logging.info(\"This is a function to extract only dictionary elements from the dataset\")\n",
    "        l = self.list\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == dict:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "                        \n",
    "                    \n",
    "list_var = List([3,4,5,6,7 , [23,456,67,8,78,78] , [345,56,87,8,98,9] , (234,6657,6) , {\"key1\" :\"sudh\" , 234:[23,45,656]}])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9b30d828",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23,\n",
       " 456,\n",
       " 67,\n",
       " 8,\n",
       " 78,\n",
       " 78,\n",
       " 345,\n",
       " 56,\n",
       " 87,\n",
       " 8,\n",
       " 98,\n",
       " 9,\n",
       " 234,\n",
       " 6657,\n",
       " 6,\n",
       " 234,\n",
       " [23, 45, 656]]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_var.access_int_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "912cd7bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 456, 67, 8, 78, 78]\n",
      "[345, 56, 87, 8, 98, 9]\n"
     ]
    }
   ],
   "source": [
    "list_var.extract_list_entity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f98d1190",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 'sudh', 234: [23, 45, 656]}\n"
     ]
    }
   ],
   "source": [
    "list_var.extract_dict_elements()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9ccc3563",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO root 2022-07-03 01:55:42,051 This is a function to access intergers in the list\n",
      "INFO root 2022-07-03 01:55:42,051 [3, 4, 5, 6, 7, [23, 456, 67, 8, 78, 78], [345, 56, 87, 8, 98, 9], (234, 6657, 6), {'key1': 'sudh', 234: [23, 45, 656]}]\n",
      "INFO root 2022-07-03 01:55:42,052 [23, 456, 67, 8, 78, 78, 345, 56, 87, 8, 98, 9, 234, 6657, 6, 234, [23, 45, 656]]\n",
      "INFO root 2022-07-03 01:55:42,944 This is a function to extract only list entities for the dataset\n",
      "INFO root 2022-07-03 01:55:42,944 [3, 4, 5, 6, 7, [23, 456, 67, 8, 78, 78], [345, 56, 87, 8, 98, 9], (234, 6657, 6), {'key1': 'sudh', 234: [23, 45, 656]}]\n",
      "INFO root 2022-07-03 01:55:42,945 [23, 456, 67, 8, 78, 78]\n",
      "INFO root 2022-07-03 01:55:42,946 [345, 56, 87, 8, 98, 9]\n",
      "INFO root 2022-07-03 01:55:44,159 This is a function to extract only dictionary elements from the dataset\n",
      "INFO root 2022-07-03 01:55:44,186 [3, 4, 5, 6, 7, [23, 456, 67, 8, 78, 78], [345, 56, 87, 8, 98, 9], (234, 6657, 6), {'key1': 'sudh', 234: [23, 45, 656]}]\n",
      "INFO root 2022-07-03 01:55:44,186 {'key1': 'sudh', 234: [23, 45, 656]}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f1 = open(\"lst.log\", 'r')\n",
    "print(f1.read())\n",
    "f1.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9420a7b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logging.basicConfig(filename = \"lst2.log\", level = logging.INFO, format = '%(levelname)s %(name)s %(asctime)s %(message)s')\n",
    "\n",
    "class List2:\n",
    "    def __init__(self, list2):\n",
    "        self.list2 = list2\n",
    "        \n",
    "    def extract_list_entity2(self):\n",
    "        logging.info(\"This is a function to extract list entities from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == list:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def extract_dict_elements2(self):\n",
    "        logging.info(\"This is a function to extract dictionary elements from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == dict:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def extract_tuple_entities(self):\n",
    "        logging.info(\"This is a function to extract tuple entities from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == tuple:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def access_numerical_data_in_list(self):\n",
    "        logging.info(\"This is a function to access numerical data in the list\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            l2 = []\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",
    "            logging.info(l2)\n",
    "            return l2\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "                        \n",
    "\n",
    "    def summation_of_numerical_data(self):\n",
    "        logging.info(\"This is a function that returns a summation of all the numerical data in the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            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",
    "            logging.info(l3)\n",
    "            return sum(l3)\n",
    "        except Exception as e:\n",
    "            logging.info(e)\n",
    "    \n",
    "   \n",
    "    def odd_values_in_numeric_data(self):\n",
    "        logging.info(\"This is a function to extract only odd values in numeric data from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            l4 = []\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",
    "                            l4.append(j)\n",
    "                if type(i) == dict:\n",
    "                    for k, v in i.items():\n",
    "                        if type(k) == int or type(v) == int:\n",
    "                            l4.append(k)\n",
    "                            l4.append(v)\n",
    "            logging.info(l4)\n",
    "            for i in l4:\n",
    "                if i%2 == 1:\n",
    "                    logging.info(i)\n",
    "                    print(i)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "        \n",
    "    def numerical_data_in_dict(self):\n",
    "        logging.info(\"This is a function to extract numerical data in dictionary from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            l5 = []\n",
    "            for i in l:\n",
    "                if type(i) == dict:\n",
    "                    for k, v in i.items():\n",
    "                        if type(k) == int or type(v) == int:\n",
    "                            l5.append(k)\n",
    "                            l5.append(v)\n",
    "            logging.info(l5)\n",
    "            print(l5)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def numeric_data_only_in_lists(self):\n",
    "        logging.info(\"This is a function to extract numerical data from the list present in the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            l6 = []\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",
    "            logging.info(l6)\n",
    "            return l6\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def number_of_keys_in_dict(self):\n",
    "        logging.info(\"This is a function that returns the number of keys in the dictionary of the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            for i in l:\n",
    "                if type(i) == dict:\n",
    "                    logging.info(len(i.keys()))\n",
    "                    return len(i.keys())\n",
    "        except Exception as e:\n",
    "            logging.info(e)\n",
    "                        \n",
    "   \n",
    "    def filter_out_string_data(self):\n",
    "        logging.info(\"This a function to filter out string type data from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\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) == str:\n",
    "                            logging.info(j)\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",
    "                            logging.info(k)\n",
    "                            logging.info(v)\n",
    "                            print(k)\n",
    "                            print(v)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "                        \n",
    "    def multiplication_of_numeric_data(self):\n",
    "        logging.info(\"This is a function to multiply all the numerical data present in the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\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",
    "                    logging.info(m)\n",
    "                    print(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",
    "                    logging.info(m)\n",
    "                    print(m)\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "                \n",
    "    def create_flat_list(self):\n",
    "        logging.info(\"This function unwraps the dataset into a flat list\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            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",
    "            logging.info(flat_list)\n",
    "            return flat_list\n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "    \n",
    "    def extract_alphanum_data(self):\n",
    "        logging.info(\"This is a function to extract alpha numerical data from the dataset\")\n",
    "        l = self.list2\n",
    "        logging.info(l)\n",
    "        try:\n",
    "            lst = []\n",
    "            for i in l:\n",
    "                if type(i) == list or type(i) == set or type(i) == tuple:\n",
    "                    for j in i:\n",
    "                        lst.append(j)\n",
    "                if type(i) == dict:\n",
    "                    for k, v in i.items():\n",
    "                        lst.append(k)\n",
    "                        lst.append(v)\n",
    "            logging.info(lst)\n",
    "            for i in lst:\n",
    "                if type(i) == str:\n",
    "                    if i.isalnum():\n",
    "                        logging.info(i)\n",
    "                        print(i) \n",
    "        except Exception as e:\n",
    "            logging.exception(e)\n",
    "\n",
    "list2_var = List2([[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]), \n",
    "                   {'k1': \"sudh\", \"k2\" : \"ineuron\", \"k3\" : \"kumar\", 3:6, 7:8}, [\"ineuron\", \"data science\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "61bd5265",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['ineuron', 'data science']\n"
     ]
    }
   ],
   "source": [
    "list2_var.extract_list_entity2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b80411b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'k1': 'sudh', 'k2': 'ineuron', 'k3': 'kumar', 3: 6, 7: 8}\n"
     ]
    }
   ],
   "source": [
    "list2_var.extract_dict_elements2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5d3bd223",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4, 5, 6)\n",
      "(3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "list2_var.extract_tuple_entities()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bee5332b",
   "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": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2_var.access_numerical_data_in_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7c00e750",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2_var.summation_of_numerical_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b5f3584b",
   "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": [
    "list2_var.odd_values_in_numeric_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "eacb78ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "list2_var.numerical_data_in_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4bd33954",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2_var.numeric_data_only_in_lists()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d5762b53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2_var.number_of_keys_in_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "15881e30",
   "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": [
    "list2_var.filter_out_string_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "88d880b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "720\n",
      "2520\n",
      "20700\n",
      "1008\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "list2_var.multiplication_of_numeric_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bc6e4379",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 45,\n",
       " 4,\n",
       " 5,\n",
       " 23,\n",
       " 'k1',\n",
       " 'sudh',\n",
       " 'k2',\n",
       " 'ineuron',\n",
       " 'k3',\n",
       " 'kumar',\n",
       " 3,\n",
       " 6,\n",
       " 7,\n",
       " 8,\n",
       " 'ineuron',\n",
       " 'data science']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2_var.create_flat_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "99df7aec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k1\n",
      "sudh\n",
      "k2\n",
      "ineuron\n",
      "k3\n",
      "kumar\n",
      "ineuron\n"
     ]
    }
   ],
   "source": [
    "list2_var.extract_alphanum_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d83f96ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO root 2022-07-03 01:58:15,483 This is a function to extract list entities from the dataset\n",
      "INFO root 2022-07-03 01:58:15,484 [[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",
      "INFO root 2022-07-03 01:58:15,485 [1, 2, 3, 4]\n",
      "INFO root 2022-07-03 01:58:15,486 ['ineuron', 'data science']\n",
      "INFO root 2022-07-03 01:58:16,096 This is a function to extract dictionary elements from the dataset\n",
      "INFO root 2022-07-03 01:58:16,096 [[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",
      "INFO root 2022-07-03 01:58:16,097 {'k1': 'sudh', 'k2': 'ineuron', 'k3': 'kumar', 3: 6, 7: 8}\n",
      "INFO root 2022-07-03 01:58:16,944 This is a function to extract tuple entities from the dataset\n",
      "INFO root 2022-07-03 01:58:16,944 [[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",
      "INFO root 2022-07-03 01:58:16,945 (2, 3, 4, 5, 6)\n",
      "INFO root 2022-07-03 01:58:16,945 (3, 4, 5, 6, 7)\n",
      "INFO root 2022-07-03 01:58:17,532 This is a function to access numerical data in the list\n",
      "INFO root 2022-07-03 01:58:17,532 [[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",
      "INFO root 2022-07-03 01:58:17,533 [1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]\n",
      "INFO root 2022-07-03 01:58:18,262 This is a function that returns a summation of all the numerical data in the dataset\n",
      "INFO root 2022-07-03 01:58:18,263 [[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",
      "INFO root 2022-07-03 01:58:18,264 [1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]\n",
      "INFO root 2022-07-03 01:58:18,876 This is a function to extract only odd values in numeric data from the dataset\n",
      "INFO root 2022-07-03 01:58:18,877 [[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",
      "INFO root 2022-07-03 01:58:18,878 [1, 2, 3, 4, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 45, 4, 5, 23, 3, 6, 7, 8]\n",
      "INFO root 2022-07-03 01:58:18,878 1\n",
      "INFO root 2022-07-03 01:58:18,878 3\n",
      "INFO root 2022-07-03 01:58:18,879 3\n",
      "INFO root 2022-07-03 01:58:18,879 5\n",
      "INFO root 2022-07-03 01:58:18,879 3\n",
      "INFO root 2022-07-03 01:58:18,880 5\n",
      "INFO root 2022-07-03 01:58:18,881 7\n",
      "INFO root 2022-07-03 01:58:18,882 45\n",
      "INFO root 2022-07-03 01:58:18,882 5\n",
      "INFO root 2022-07-03 01:58:18,882 23\n",
      "INFO root 2022-07-03 01:58:18,882 3\n",
      "INFO root 2022-07-03 01:58:18,883 7\n",
      "INFO root 2022-07-03 01:58:20,077 This is a function to extract numerical data in dictionary from the dataset\n",
      "INFO root 2022-07-03 01:58:20,078 [[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",
      "INFO root 2022-07-03 01:58:20,078 [3, 6, 7, 8]\n",
      "INFO root 2022-07-03 01:58:20,611 This is a function to extract numerical data from the list present in the dataset\n",
      "INFO root 2022-07-03 01:58:20,611 [[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",
      "INFO root 2022-07-03 01:58:20,612 [1, 2, 3, 4]\n",
      "INFO root 2022-07-03 01:58:21,207 This is a function that returns the number of keys in the dictionary of the dataset\n",
      "INFO root 2022-07-03 01:58:21,207 [[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",
      "INFO root 2022-07-03 01:58:21,208 5\n",
      "INFO root 2022-07-03 01:58:22,123 This a function to filter out string type data from the dataset\n",
      "INFO root 2022-07-03 01:58:22,124 [[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",
      "INFO root 2022-07-03 01:58:22,125 k1\n",
      "INFO root 2022-07-03 01:58:22,125 sudh\n",
      "INFO root 2022-07-03 01:58:22,126 k2\n",
      "INFO root 2022-07-03 01:58:22,126 ineuron\n",
      "INFO root 2022-07-03 01:58:22,126 k3\n",
      "INFO root 2022-07-03 01:58:22,126 kumar\n",
      "INFO root 2022-07-03 01:58:22,127 ineuron\n",
      "INFO root 2022-07-03 01:58:22,127 data science\n",
      "INFO root 2022-07-03 01:58:22,744 This is a function to multiply all the numerical data present in the dataset\n",
      "INFO root 2022-07-03 01:58:22,744 [[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",
      "INFO root 2022-07-03 01:58:22,745 24\n",
      "INFO root 2022-07-03 01:58:22,745 720\n",
      "INFO root 2022-07-03 01:58:22,746 2520\n",
      "INFO root 2022-07-03 01:58:22,746 20700\n",
      "INFO root 2022-07-03 01:58:22,747 1008\n",
      "INFO root 2022-07-03 01:58:22,747 1\n",
      "INFO root 2022-07-03 01:58:23,773 This function unwraps the dataset into a flat list\n",
      "INFO root 2022-07-03 01:58:23,773 [[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",
      "INFO root 2022-07-03 01:58:23,774 [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",
      "INFO root 2022-07-03 01:58:25,002 This is a function to extract alpha numerical data from the dataset\n",
      "INFO root 2022-07-03 01:58:25,003 [[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",
      "INFO root 2022-07-03 01:58:25,003 [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",
      "INFO root 2022-07-03 01:58:25,003 k1\n",
      "INFO root 2022-07-03 01:58:25,003 sudh\n",
      "INFO root 2022-07-03 01:58:25,004 k2\n",
      "INFO root 2022-07-03 01:58:25,004 ineuron\n",
      "INFO root 2022-07-03 01:58:25,006 k3\n",
      "INFO root 2022-07-03 01:58:25,007 kumar\n",
      "INFO root 2022-07-03 01:58:25,007 ineuron\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f2 = open(\"lst2.log\", 'r')\n",
    "print(f2.read())\n",
    "f2.close()"
   ]
  }
 ],
 "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
}