30_july.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class bishnu:\n",
    "    def sum(a,b,c):\n",
    "        return a*b+b*c\n",
    "    def subtraction(x,y):\n",
    "        return x-y\n",
    "    def multiplication(a):\n",
    "        return a*a*a\n",
    "p1 = bishnu\n",
    "p2 = bishnu\n",
    "p3 =bishnu\n",
    "print(p1.sum(10,20,30))\n",
    "print(p1.subtraction(10,5))\n",
    "print(p3.multiplication(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "%lsmagic\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-8cefb5831dd6>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-8cefb5831dd6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    $# hello\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# The following is the class for a vehicle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# vehicle class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "honda is a red car worth $10000.00.\n"
     ]
    }
   ],
   "source": [
    "class vehicle:\n",
    "    name  = \"honda\"\n",
    "    kind = \"car\"\n",
    "    color = 'red'\n",
    "    value = 10000.0\n",
    "    def description(self):\n",
    "        price =\"%s is a %s %s worth $%.2f.\"%(self.name,self.color,self.kind,self.value)\n",
    "        return price\n",
    "car1 = vehicle()\n",
    "print(car1.description())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# scopes and namespaces example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after local assignment: test spam\n",
      "after nonlocal assignment: nonlocal spam\n",
      "after global assignment: nonlocal spam\n",
      "In global scope: global spam \n"
     ]
    }
   ],
   "source": [
    "def scope_test():\n",
    "    def do_local():\n",
    "        spam = \"local spam\"\n",
    "    def do_nonlocal():\n",
    "        nonlocal spam\n",
    "        spam = \"nonlocal spam\"\n",
    "    def do_global():\n",
    "        global spam\n",
    "        spam =\"global spam \"\n",
    "    spam = \"test spam\"\n",
    "    do_local()\n",
    "    print(\"after local assignment:\",spam)\n",
    "    do_nonlocal()\n",
    "    print(\"after nonlocal assignment:\",spam)\n",
    "    do_global()\n",
    "    print(\"after global assignment:\",spam)\n",
    "scope_test()\n",
    "print(\"In global scope:\",spam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# constrcuctors in python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 0 10\n"
     ]
    }
   ],
   "source": [
    "class complex_number:\n",
    "    def __init__(self,r=0,i=0):\n",
    "        self.real =r\n",
    "        self.image=i        \n",
    "    def getData(self):\n",
    "        print(\"{0}+{1}\".format(self.real,self.image))\n",
    "c1 =complex_number(2,3)\n",
    "c2= complex_number(5)\n",
    "c2.attr =10\n",
    "print(c2.real,c2.image,c2.attr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'pop' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-9ebd9f588b4b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnumbers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumbers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumbers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'pop' is not defined"
     ]
    }
   ],
   "source": [
    "numbers = list(range(1,10))\n",
    "print(numbers)\n",
    "print(pop.numbers())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# insert a list in to the function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8]\n",
    "def jlab(lab):\n",
    "    list =[]\n",
    "    for i in lab:\n",
    "        list.append(i*i)\n",
    "    return list\n",
    "print(jlab(list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81, 25, 1, 9, 49]\n"
     ]
    }
   ],
   "source": [
    "list2 =[1,3,5,7,9]\n",
    "def reverse(abc):\n",
    "    list3 =[]\n",
    "    for i in abc:\n",
    "        list3.append(i**2)\n",
    "        list3 = list3[::-1]\n",
    "    return list3\n",
    "print(reverse(list2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 7, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "list4 = [1,4,7,10]\n",
    "def reverse1(l):\n",
    "    lis = []\n",
    "    for i in range(len(l)):\n",
    "        pooped = l.pop()\n",
    "        lis.append(pooped)\n",
    "    return lis\n",
    "print(reverse1(list4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['unhsib', 'yednap', 'niwras', 'dis', 'itoyj']\n"
     ]
    }
   ],
   "source": [
    "list5 = ['bishnu','pandey','sarwin','sid','jyoti']\n",
    "def rever(l):\n",
    "    lisc= []\n",
    "    for i in l:\n",
    "        lisc.append(i[::-1])\n",
    "    return lisc\n",
    "print(rever(list5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# class for a dog\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "philo is 5 and mikey is 6.\n"
     ]
    }
   ],
   "source": [
    "class Dog:\n",
    "    species= 'animal'\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "#make the objects for the class\n",
    "philo = Dog(\"philo\",5)\n",
    "mikey = Dog(\"mikey\",6)\n",
    "print(\"{} is {} and {} is {}.\".format(philo.name,philo.age,mikey.name,mikey.age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# define a function which take a list as an argumenta and then return two list separated by even and odd numbers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 4, 6, 8], [1, 3, 5, 7]]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3,4,5,6,7,8]\n",
    "def func1(list):\n",
    "    list2 =[]\n",
    "    list3 = []\n",
    "    for i in list1:\n",
    "        if i%2==0:\n",
    "            list2.append(i)\n",
    "        else:\n",
    "            list3.append(i)\n",
    "    return [list2,list3]\n",
    "print(func1(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# define a function, take 2 list as an output and finaly return only one list with common numbers in each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 40, 'mango']\n"
     ]
    }
   ],
   "source": [
    "list1 = [10,20,30,40,'mango', 'apple','banana']\n",
    "list2 = [10,300,40, 'mango']\n",
    "def common(l1,l2):\n",
    "    list3 =[]\n",
    "    for i in l1:\n",
    "        if i in l2:\n",
    "            list3.append(i)\n",
    "    return list3\n",
    "print(common(list1,list2))            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# define a function that will return the larhest difference between the elemnts of the list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "497\n"
     ]
    }
   ],
   "source": [
    "lis = [111,20,3,36,5,6,7,89,10,100,500]\n",
    "def max_dif(l):\n",
    "    return max(l) - min(l)\n",
    "print(max_dif(lis))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# define a function that will tell you how many list are inside the main list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,34,[1,2,3],[10,20,30],[100,200,500]]\n",
    "def inside1(l):\n",
    "    count =0\n",
    "    for i in l:\n",
    "        if type(i) ==list:\n",
    "            count = count +1\n",
    "    return count\n",
    "print(inside1(l1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "list = [1,2,3,4,5,6,7,8]\n",
    "list.pop(0)\n",
    "print(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "mixed = (1,2,3,4,9.0)\n",
    "for i in mixed:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple with one element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "name =(1,)\n",
    "print(type(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bishnu Pandey\n"
     ]
    }
   ],
   "source": [
    "name = (\"bishnu Pandey\", \"Sarwin Pandey\", \"siddartha Pandey\")\n",
    "name1, name2, name3 = name\n",
    "print(name1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# list inside tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, [5, 6, 7, 'grapes'])\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3,[5,6,7])\n",
    "tup[3].append(\"grapes\")\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8, 15)\n"
     ]
    }
   ],
   "source": [
    "def tupl(a,b):\n",
    "    add = a+b\n",
    "    multiply = a*b\n",
    "    return add, multiply\n",
    "print(tupl(3,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# in the above example it is returning a tuple\n",
    "# The way to not to return a tuple is the following\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def sum_mult(a,b):\n",
    "    add = a+b\n",
    "    multiply  = a*b\n",
    "    return add, multiply\n",
    "add,multiply = sum_mult(3,5)\n",
    "print(add)\n",
    "print(multiply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "nums = tuple(range(1,10))\n",
    "print(nums)\n",
    "nums1 = list(range(1,10))\n",
    "print(nums1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# dictionary is the un ordered collection of date with a key with corresponding value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 = {\"name\":\"bishnu\", 'age' :30}\n",
    "type(dict1) # simple way to make the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'bishnu', 'age': 25}\n"
     ]
    }
   ],
   "source": [
    "user1 = dict(name = 'bishnu',age = 25)\n",
    "print(user1)  #how to make a dictionary  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36\n"
     ]
    }
   ],
   "source": [
    "x = dict(name = \"John\", age = 36, country = \"Norway\")\n",
    "print(x['age'])\n",
    "# how to acccess the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# anything can be stored in a dictionary, inte, float, string are dict inside dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "present\n"
     ]
    }
   ],
   "source": [
    "y = dict(name = \"John\", age = 36, country = \"Norway\")\n",
    "if 'Norway' in y.values():\n",
    "    print('present')\n",
    "else:\n",
    "    print(\"not present\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prsesnt\n"
     ]
    }
   ],
   "source": [
    "y = dict(name = \"John\", age = 36, country = \"Norway\",lis =[1,3,5,7,9])\n",
    "if [1,3,5,7,9] in y.values():\n",
    "    print(\"prsesnt\")\n",
    "else:\n",
    "    print(\"not present\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# loopsin a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bishnu\n",
      "35\n",
      "Hampton\n",
      "jlab\n"
     ]
    }
   ],
   "source": [
    "dic = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab'\n",
    "}\n",
    "#for i in dic.values():\n",
    " #   print(i)\n",
    "#user_val = dic.values()\n",
    "#print(user_val)\n",
    "#user_keys = dic.keys()\n",
    "#print(user_keys)\n",
    "#type(user_keys)\n",
    "for i in dic:\n",
    "    print(dic[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # items Metghod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Add and Delete Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Bishnu', 'age': 35, 'University': 'Hampton', 'lab': 'jlab', 'favourite_songs': ['aaja tujh ko pukare mera pyar', 'yeh dil toh']}\n"
     ]
    }
   ],
   "source": [
    "dict3 = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab'\n",
    "}\n",
    "dict3['favourite_songs']=['aaja tujh ko pukare mera pyar','yeh dil toh']\n",
    "print(dict3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# pop method in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jlab\n",
      "{'name': 'Bishnu', 'age': 35, 'University': 'Hampton', 'favourite_movie': '3 idiot'}\n"
     ]
    }
   ],
   "source": [
    "dic5 = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab',\n",
    "    'favourite_movie': '3 idiot'\n",
    "}\n",
    "poped_item = dic5.pop('lab')\n",
    "print(poped_item)\n",
    "print(dic5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# update dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'sid', 'age': 35, 'University': 'Hampton', 'lab': 'jlab', 'favourite_movie': '3 idiot', 'son2': 'sarwin'}\n"
     ]
    }
   ],
   "source": [
    "dic5 = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab',\n",
    "    'favourite_movie': '3 idiot'\n",
    "}\n",
    "dic6 = {'name': 'sid', 'son2':'sarwin'}\n",
    "dic5.update(dic6)\n",
    "print(dic5)\n",
    "# if upadte with the existed key, the existed key will be re[placed, it won't create a new one]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not found!\n"
     ]
    }
   ],
   "source": [
    "dic7 = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab',\n",
    "    'favourite_movie': '3 idiot'\n",
    "}\n",
    "print(dic7.get('age1','not found!'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'sid', 'age': 35, 'University': 'Hampton', 'lab': 'jlab', 'favourite_movie': '3 idiot'}\n"
     ]
    }
   ],
   "source": [
    "dic8 = {\n",
    "    'name':'Bishnu',\n",
    "    'age' :35,\n",
    "    'University': 'Hampton',\n",
    "    'lab':'jlab',\n",
    "    'favourite_movie': '3 idiot',\n",
    "    'name' : 'sid'\n",
    "}\n",
    "print(dic8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# define a function with one argement and  will return a dictionary which contains the cube of the  argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729, 10: 1000}\n"
     ]
    }
   ],
   "source": [
    "def cube_dic(a):\n",
    "    cube ={}\n",
    "    for i in range (1,a+1):\n",
    "        cube[i]=i**3\n",
    "    return cube\n",
    "print(cube_dic(10))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b': 1, 'i': 1, 's': 1, 'h': 1, 'n': 2, 'u': 1, ' ': 1, 'p': 1, 'a': 1, 'd': 1, 'e': 1, 'y': 1}\n"
     ]
    }
   ],
   "source": [
    "def word_counter(s):\n",
    "    count={}\n",
    "    for i in s:\n",
    "        count[i]=s.count(i)\n",
    "    return count\n",
    "print(word_counter('bishnu pandey'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# class Definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bishnu\n"
     ]
    }
   ],
   "source": [
    "class person:\n",
    "    def __init__(self,first_name,last_name,age):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.age = age\n",
    "p1 =person('bishnu','pandey',35)\n",
    "p2=person('salman','khan',55)\n",
    "print(p1.first_name)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$1000\n",
      "Dell_i5\n"
     ]
    }
   ],
   "source": [
    "class Laptop:\n",
    "    def __init__(self,model_name,color,price):\n",
    "        self.model = model_name\n",
    "        self.color = color\n",
    "        self.price = price\n",
    "l1 = Laptop(\"Dell_i5\",'silver','$1000')\n",
    "print(l1.price)\n",
    "print(l1.model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "sar pandey\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,first_name,last_name,age):\n",
    "        self.first_name=first_name\n",
    "        self.last_name =last_name\n",
    "        self.age = age\n",
    "    def full_name(self):\n",
    "        return f\"{self.first_name} {self.last_name}\"\n",
    "    def is_greater(self):\n",
    "        return self.age>18\n",
    "           \n",
    "p1 = Person('Bishnu','Pandey',34)\n",
    "p2= Person('sar','pandey',20)\n",
    "print(p1.age)\n",
    "print(p2.full_name())\n",
    "print(p2.is_greater())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Discount "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59850.0\n"
     ]
    }
   ],
   "source": [
    "class Discount:\n",
    "    def __init__(self,a):\n",
    "        self.a =a\n",
    "       # self.b=b\n",
    "    def total_discount(self):\n",
    "        b = self.a -5*self.a/100\n",
    "        return b\n",
    "dis1 = Discount(63000)\n",
    "print(dis1.total_discount())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# circle class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.53975\n",
      "31.4159\n",
      "{'radius': 5, 'pi': 3.14159}\n"
     ]
    }
   ],
   "source": [
    "class Circle:\n",
    "    def __init__(self,radius, pi):\n",
    "        self.radius = radius\n",
    "        self.pi = pi\n",
    "    def area(self):\n",
    "        a = self.pi*self.radius**2\n",
    "        return a\n",
    "    def circumference(self):\n",
    "        b = 2*self.pi*self.radius\n",
    "        return b\n",
    "A = Circle(5,3.14159)\n",
    "print(A.area())\n",
    "print(A.circumference())\n",
    "print(A.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# class variables ( in above example no need to write 3.14 many time), can be written as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.5\n",
      "31.400000000000002\n"
     ]
    }
   ],
   "source": [
    "class Circle:\n",
    "    pi = 3.14\n",
    "    def __init__(self,radius):\n",
    "        self.radius = radius\n",
    "    def area(self):\n",
    "        a = Circle.pi*self.radius**2\n",
    "        return a\n",
    "    def circumference(self):\n",
    "        b = 2*Circle.pi*self.radius\n",
    "        return b\n",
    "A = Circle(5)\n",
    "print(A.area())\n",
    "print(A.circumference())"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}