Basics/Set data structures, anonymous functions and File handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SET DATA Structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "st = set()\n",
    "print(type(st))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# creating a simple set\n",
    "st= {'pumar','kris','krish','bara','bara'}\n",
    "print(type(st))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'krish', 'kris', 'pumar', 'bara'}\n"
     ]
    }
   ],
   "source": [
    "print(st)    # eliminated the duplicate values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'krish', 'Gommu', 'pumar', 'bara', 'kris'}\n"
     ]
    }
   ],
   "source": [
    "# add elemets to the set\n",
    "st.add('Gommu')\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'krish', 'bara', 'kris'}\n"
     ]
    }
   ],
   "source": [
    "# remove element from the set\n",
    "st.remove('Gommu')\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'krish', 'gommu', 'lol', 'danda', 'bara', 'kris'}\n"
     ]
    }
   ],
   "source": [
    "# Adding more than one or more values in the set simultanously\n",
    "\n",
    "st.update(['gommu','danda','lol'])   # given within list\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'kris', 'bench', 'gomu'}\n"
     ]
    }
   ],
   "source": [
    "# Set will not allow duplicate entries\n",
    "\n",
    "st1={'kris','gomu','gomu','bench'}\n",
    "print(st1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{11, 12, 13, 14, 15, 16}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[11, 12, 13, 14, 15, 16]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a program to eliminate the repeated entries from the given list and keep single copy of each element in list\n",
    "\n",
    "ls =[11,12,13,14,15,16,11,12,13]\n",
    "s =set(ls)\n",
    "print(s)                       # returns set of non repeated integers\n",
    "ls1 =list(s)\n",
    "ls1                            # returns list of non repeated integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3.14, 14, -14, 'hello', 23}\n"
     ]
    }
   ],
   "source": [
    "# mixed type\n",
    "s = {'hello',23,3.14,-14,14,14}    # set allows mixed data type values too\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda Functions\n",
    "- Functions without names\n",
    "- Simple functions where the task to be carried out is small\n",
    "- can take arguemens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "# simple example of Lamba function\n",
    "\n",
    "x = lambda a : a+10\n",
    "print(x(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "20\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# lamba functions with two arguements\n",
    "# a and b are the arguements for lambda function\n",
    "# a*b is the body of lambda function (expression)\n",
    "\n",
    "x = lambda a,b : a*b\n",
    "print(x(10,20))\n",
    "print(x(4,5))\n",
    "print(x(1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "filered list:  [1, 3, 5, 7, 9]\n",
      "boolean list:  [2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Fliter () --> filter function filters the unwanted list elements form the list\n",
    "ls =[1,2,3,4,5,6,7,8,9,10]\n",
    "filtered_list = list(filter(lambda x : (x%2 !=0) ,ls))\n",
    "print('filered list: ',filtered_list)\n",
    "print('boolean list: ',['True' if x%2 ==0 else x+1 for x in filtered_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extract the words from astring(line) those having length as 3 \n",
    "\n",
    "st= input()\n",
    "ls = st.split(' ')\n",
    "ls1 = list(filter(lambda x : (len(x)==3),ls))\n",
    "print(ls1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello how are you\n",
      "['hello', 'how']\n"
     ]
    }
   ],
   "source": [
    "# extract the words from a string (line) whihc are starting with 'h'\n",
    "st1 = input()\n",
    "ls = st1.split(' ')\n",
    "ls2 = list(filter(lambda a :(a[0:1]=='h'),ls))\n",
    "print(ls2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello how are you\n",
      "['hello', 'how']\n"
     ]
    }
   ],
   "source": [
    "#Alternate method\n",
    "st1 = input()\n",
    "ls = st1.split(' ')\n",
    "ls2 = list(filter(lambda a :(a.startswith('h')),ls))\n",
    "print(ls2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MAP function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "# Lambda function with map() -->  match one list with another list\n",
    "# to call lambda function , instead of for loop, map() is used\n",
    "\n",
    "ls = [1,2,3,4,5,6,7,8,9,10]\n",
    "ls1 = list(map(lambda x: x*2,ls))   # old list is modified using map() --> now realtionship between ls and ls1 were defined inside the lambda function\n",
    "print(ls1)                         # new list is created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no.of list elements :5\n",
      "list elemets: 1\n",
      "list elemets: 2\n",
      "list elemets: 3\n",
      "list elemets: 4\n",
      "list elemets: 5\n",
      "[1, 2, 3, 4, 5]\n",
      "mean 3.0\n",
      "Variance 2.0\n"
     ]
    }
   ],
   "source": [
    "# Compute variance of list of elemets\n",
    "\n",
    "a = int(input('no.of list elements :'))\n",
    "ls=[]\n",
    "for i in range (a):\n",
    "    n= int(input('list elemets: '))\n",
    "    ls.append(n)\n",
    "print(ls)\n",
    "l = len(ls)\n",
    "q=sum(ls)/l\n",
    "print('mean' ,q)\n",
    "ls1 = list(map(lambda x : (x*x)-(q*q),ls))\n",
    "s=sum(ls1)/l\n",
    "print('Variance' , s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "178.91358024691354"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Alteranate method\n",
    "ls = [5,7,8,9,22,34,35,36,37]\n",
    "avg =sum(ls)/len(ls)\n",
    "dev =list(map(lambda x : (x-avg)**2,ls))\n",
    "var =sum(dev)/len(ls)\n",
    "var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "178.91358024691354"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "n = np.array(ls)\n",
    "np.var(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce Function\n",
    "- from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "41\n"
     ]
    }
   ],
   "source": [
    "ld = [5,3,6,7,8,12]\n",
    "ld1 = reduce((lambda x,y :x+y) , ld)\n",
    "print(ld1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hihowareyou \n",
      " "
     ]
    }
   ],
   "source": [
    "ls = ['hi','how','are','you']\n",
    "ls1 =reduce((lambda x,y :x+y), ls)\n",
    "print(ls1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['karnataka', 'country.', 'states', 'India', 'great', 'one', 'the', 'is', 'is', 'of', 'a']\n"
     ]
    }
   ],
   "source": [
    "txt = 'India is a great country. karnataka is one of the states'\n",
    "words =txt.split(' ')\n",
    "words.sort(key=len, reverse =True)\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 1 2 3\n",
      "{(4, 2), (3, 2), (1, 1), (2, 2)}\n"
     ]
    }
   ],
   "source": [
    "# Assignment\n",
    "n = input()\n",
    "ls=[int(x) for x in (n.split())]\n",
    "ct = 0\n",
    "ls1=[]\n",
    "for ct in ls:\n",
    "      ls1.append((ls[ct],ls.count(ct)))\n",
    "      ct+=1\n",
    "      st = set((ls1))\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exception handling\n",
    "- Sematic error\n",
    "- syntatic error\n",
    "- runtime error ( exception)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "division by zero is not possible\n",
      "2\n",
      "division : 0.5\n"
     ]
    }
   ],
   "source": [
    "# example of exception handling\n",
    "\n",
    "a = int(input())\n",
    "while True:\n",
    "    b =int(input())\n",
    "    try:\n",
    "        c= a/b\n",
    "        break\n",
    "    except:\n",
    "        print('division by zero is not possible')\n",
    "print('division :',c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file opened succesfully\n",
      "hi how are you\n",
      "hi krishna \n"
     ]
    }
   ],
   "source": [
    "# Example of file handling \n",
    "\n",
    "try:\n",
    "    f=open('C:/Users/Administrator/Desktop/python/Python/myfile','r')\n",
    "    print('file opened succesfully')\n",
    "except:\n",
    "    print('file cannot be opened')\n",
    "    exit()\n",
    "\n",
    "for i in f:\n",
    "    print(i, end ='')\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "krishna is good\n",
      "kumar is stupid\n",
      "total no.of words:  6\n",
      "line count: 2\n",
      "no.of characters in string: 32\n"
     ]
    }
   ],
   "source": [
    "# Assignment \n",
    "\n",
    "try : \n",
    "    f=open('myfile','r')\n",
    "    l_c=0\n",
    "    c_c=0\n",
    "    w_c=0\n",
    "except:\n",
    "    print('error')\n",
    "      \n",
    "for i in f:\n",
    "    print(i,end=\"\")\n",
    "    # 1  count number of lines in a file\n",
    "    l_c+=1\n",
    "    # 2 count number of words in a file\n",
    "    ls=i.split(' ')\n",
    "    w_c+=len(ls)\n",
    "\n",
    "    # 3. count number of characters in afile\n",
    "    c_c+=len(i)\n",
    "   \n",
    "\n",
    "\n",
    "print('total no.of words: ',w_c)\n",
    "print('line count:',l_c)\n",
    "print('no.of characters in string:',c_c)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter file name: myfile\n",
      "krishna\n",
      "krishna is good\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 4 . print only the lines which are statring with a specified word, taken thorugh keyboard\n",
    "\n",
    "file = input('enter file name: ')\n",
    "word = input()\n",
    "try : \n",
    "    f=open(file)\n",
    "    \n",
    "except:\n",
    "    print('error')\n",
    "\n",
    "for line in f:\n",
    "    if line.startswith(word):\n",
    "        print(line)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file opened\n",
      "enter a line: krishna is good\n",
      "enter a line: krishna is stupid\n",
      "file writed successfully\n"
     ]
    }
   ],
   "source": [
    "# Example to write and overwrite the data into a file\n",
    "\n",
    "try:\n",
    "    fout=open('myfile1','w')\n",
    "    print('file opened')\n",
    "except:\n",
    "    print('file cannot open')\n",
    "    exit()\n",
    "for i in range(2):\n",
    "    line = input('enter a line: ')\n",
    "    fout.write(line + '\\n')\n",
    "print('file writed successfully')\n",
    "fout.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usage of read() function. this will read whole file as a single string and \n",
    "# stroe it into a variable of the program\n",
    "\n",
    "try:\n",
    "    f = open('myfile','r')\n",
    "except:\n",
    "    print('file cannot be opened')\n",
    "    exit()\n",
    "s = f.read()     # this method is avoided in real-life cause it consume lot of RAM\n",
    "print(len(s))\n",
    "print('the file contents are:',s)\n",
    "print('the first 20 characters of file are:',s[:20])\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a program to copy contents of one file into another file\n",
    "\n",
    "try : \n",
    "    f =open('myfile','r') \n",
    "except:\n",
    "    print('file cannot open')\n",
    "    \n",
    "f1 =open('new.txt','w')\n",
    "for line in f:\n",
    "    f1.write(line)\n",
    "f.close()\n",
    "f1.close()\n"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}