objectoriented.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no fuel is avialable\n"
     ]
    }
   ],
   "source": [
    "class Truck:\n",
    "    seat = 2\n",
    "    tyre = 6\n",
    "    fuel = 'diesel'\n",
    "    carier = \"goods\"\n",
    "    fuel_state = True\n",
    "    def drive(vinayak):\n",
    "        if vinayak.fuel_state ==True:\n",
    "            print(\"ready to drive\")\n",
    "        else:\n",
    "            print(\"no fuel is avialable\")\n",
    "    def __init__(self) -> None:\n",
    "        self.seat=5\n",
    "        self.tyre=7\n",
    "        self.fuel_state=False\n",
    "\n",
    "obj=Truck()\n",
    "obj.drive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "no fuel is avialable\n"
     ]
    }
   ],
   "source": [
    "class Truck:\n",
    "    seat = 2\n",
    "    tyre = 6\n",
    "    fuel = 'diesel'\n",
    "    carier = \"goods\"\n",
    "    fuel_state = True\n",
    "    def drive(self,a,b):\n",
    "        print(a,b)\n",
    "        if self.fuel_state ==True:\n",
    "            print(\"ready to drive\")\n",
    "        else:\n",
    "            print(\"no fuel is avialable\")\n",
    "    def __init__(self) -> None:\n",
    "        self.seat=5\n",
    "        self.tyre=7\n",
    "        self.fuel_state=False\n",
    "\n",
    "obj=Truck()\n",
    "obj.drive(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "no fuel is avialable\n"
     ]
    }
   ],
   "source": [
    "class Truck:\n",
    "    seat = 2\n",
    "    tyre = 6\n",
    "    fuel = 'diesel'\n",
    "    carier = \"goods\"\n",
    "    fuel_state = True\n",
    "    def drive(self,a,b):\n",
    "        print(a,b)\n",
    "        print(\"convertd value are \",sel)\n",
    "        if self.fuel_state ==True:\n",
    "            print(\"ready to drive\")\n",
    "        else:\n",
    "            print(\"no fuel is avialable\")\n",
    "    def __init__(self,seat,tyre) -> None:\n",
    "        self.seat=seat\n",
    "        self.tyre=tyre\n",
    "        self.fuel_state=False\n",
    "\n",
    "obj=Truck(9,7)\n",
    "obj.drive(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "studen is pass\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    physics=90\n",
    "    math=85\n",
    "    biology = 76\n",
    "    pass_mark = 150\n",
    "    result=0\n",
    "    def calculate(self):\n",
    "        self.result=(self.physics+self.biology+self.math)\n",
    "    \n",
    "    def marks(self):\n",
    "        if self.result>=self.pass_mark:\n",
    "            print(\"studen is pass\")\n",
    "\n",
    "    def __init__(self) -> None:\n",
    "        pass\n",
    "\n",
    "obj=student()\n",
    "obj.calculate()\n",
    "obj.marks()\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student is fail\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    physics=90\n",
    "    math=85\n",
    "    biology = 76\n",
    "    pass_mark = 150\n",
    "    result=0\n",
    "    def calculate(self):\n",
    "        self.result=(self.physics+self.biology+self.math)\n",
    "    \n",
    "    def marks(self):\n",
    "        if self.result>=self.pass_mark:\n",
    "            print(\"studen is pass\")\n",
    "\n",
    "        else:\n",
    "            print(\"student is fail\")\n",
    "\n",
    "    def __init__(self) -> None:\n",
    "        self.biology=98\n",
    "        self.math=5\n",
    "        self.physics=5\n",
    "        \n",
    "\n",
    "obj=student()\n",
    "obj.calculate()\n",
    "obj.marks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ajay student is fail\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    student_name=\"ajay\"\n",
    "    physics=90\n",
    "    math=85\n",
    "    biology = 76\n",
    "    pass_mark = 150\n",
    "    result=0\n",
    "    def calculate(self):\n",
    "        self.result=(self.physics+self.biology+self.math)\n",
    "    \n",
    "    def marks(self):\n",
    "        if self.result>=self.pass_mark:\n",
    "            print(self.student_name,\"studen is\", \"pass\")\n",
    "\n",
    "        else:\n",
    "            print(self.student_name,\"student is\", \"fail\")\n",
    "\n",
    "    def __init__(self,biology,math,pysics) -> None:\n",
    "        self.biology=biology\n",
    "        self.math=math\n",
    "        self.physics=pysics\n",
    "        \n",
    "\n",
    "obj=student(98,5,6)\n",
    "obj.calculate()\n",
    "obj.marks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "programming\n"
     ]
    }
   ],
   "source": [
    "class parent():\n",
    "    __c=\"\"\n",
    "    def __init__(self):\n",
    "        self.a=\"python\"\n",
    "        self.__c=\"programming\"\n",
    "    def show(self):\n",
    "        print(self.__c)\n",
    "        \n",
    "class child(parent):\n",
    "        def __init__(self):\n",
    "            parent.__init__(self)\n",
    "            # print(\"__C:\",self.__c)\n",
    "\n",
    "obj1=parent()\n",
    "obj1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dont worry i am implimented\n"
     ]
    }
   ],
   "source": [
    "class parent():\n",
    "    def abstracrt_function(self):\n",
    "        pass\n",
    "\n",
    "class child(parent):\n",
    "    def abstract_function(self):\n",
    "        print(\"dont worry i am implimented\")\n",
    "\n",
    "obj=child()\n",
    "obj.abstract_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: vinayak designation: cs engineer sallary: 50000\n",
      "name: vijay designation: mechanical engineer sallary: 35000\n",
      "name: chandrakant designation:  civil engineer sallary: 25000\n",
      "name: shankar designation: electronics engineer sallary: 40000\n",
      "name: sanjay designation: electrical  engineer sallary: 45000\n"
     ]
    }
   ],
   "source": [
    "class cs_engineer:\n",
    "    name=\"\"\n",
    "    designatioin=\"\"\n",
    "    salary=\"\"\n",
    "    def prin(self):\n",
    "        print(\"name:\",self.name, \"designation:\",self.designatioin, \"sallary:\", self.salary)\n",
    "        \n",
    "    def __init__(self,name, designation,salary):\n",
    "        self.name=name \n",
    "        self.designatioin=designation\n",
    "        self.salary=salary\n",
    "\n",
    "\n",
    "class mechanical_engineer:\n",
    "    name=\"\"\n",
    "    designatioin=\"\"\n",
    "    salary=\"\"\n",
    "    def prin(self):\n",
    "      print(\"name:\",self.name, \"designation:\",self.designatioin, \"sallary:\", self.salary)\n",
    "    \n",
    "    def __init__(self,name, designation,salary):\n",
    "        self.name=name \n",
    "        self.designatioin=designation\n",
    "        self.salary=salary\n",
    "\n",
    "    \n",
    "class civil_engineer:\n",
    "    name=\"\"\n",
    "    designatioin=\"\"\n",
    "    salary=\"\"\n",
    "    def prin(self):\n",
    "       print(\"name:\",self.name, \"designation:\",self.designatioin, \"sallary:\", self.salary)\n",
    "\n",
    "    def __init__(self,name, designation,salary):\n",
    "        self.name=name \n",
    "        self.designatioin=designation\n",
    "        self.salary=salary\n",
    "\n",
    "\n",
    "class electronics_engineer:\n",
    "    name=\"\"\n",
    "    designatioin=\"\"\n",
    "    salary=\"\"\n",
    "    def prin(self):\n",
    "        print(\"name:\",self.name, \"designation:\",self.designatioin, \"sallary:\", self.salary)\n",
    "    \n",
    "    def __init__(self,name, designation,salary):\n",
    "        self.name=name \n",
    "        self.designatioin=designation\n",
    "        self.salary=salary\n",
    "\n",
    "\n",
    "class electrical_engineer:\n",
    "    name=\"\"\n",
    "    designatioin=\"\"\n",
    "    salary=\"\"\n",
    "    def prin(self):\n",
    "        print(\"name:\",self.name, \"designation:\",self.designatioin, \"sallary:\", self.salary)\n",
    "\n",
    "\n",
    "\n",
    "    def __init__(self,name, designation,salary):\n",
    "        self.name=name \n",
    "        self.designatioin=designation\n",
    "        self.salary=salary\n",
    "\n",
    "\n",
    "\n",
    "obj=cs_engineer('vinayak','cs engineer',\"50000\")\n",
    "obj.prin()\n",
    "obj=mechanical_engineer('vijay','mechanical engineer',\"35000\")\n",
    "obj.prin()\n",
    "obj=civil_engineer('chandrakant',' civil engineer',\"25000\")\n",
    "obj.prin()\n",
    "obj=electronics_engineer('shankar','electronics engineer',\"40000\")\n",
    "obj.prin()\n",
    "\n",
    "obj=electrical_engineer('sanjay','electrical  engineer',\"45000\")\n",
    "obj.prin()\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "statastics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.833333333333334\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import statistics as st\n",
    "li=[1,2,3,4,5,56]\n",
    "print(st.mean(li))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import statistics as st\n",
    "# li=[1,2,3,4,5,56]\n",
    "# print(st.median(li))# ading midle value divided by 2 when it is even count\n",
    "\n",
    "li1=[1,4,7,4,98]\n",
    "print(st.median(li1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "import statistics as st\n",
    "# li=[1,2,3,4,5,56]\n",
    "# print(st.median(li))# ading midle value divided by 2 when it is even count\n",
    "\n",
    "li1=[1,4,4,7,12,7,4,98,1,1,4]\n",
    "print(st.mode(li1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "from tkinter import Tk, Label, Entry, Button\n",
    "\n",
    "def save_employee_data():\n",
    "    name = name_entry.\n",
    "    age = age_entry.get()\n",
    "    department = department_entry.get()\n",
    "\n",
    "    with open('employee_data.csv', mode='a', newline='') as file:\n",
    "        writer = csv.writer(file)\n",
    "        writer.writerow([name, age, department])\n",
    "\n",
    "    name_entry.delete(0, 'end')\n",
    "    age_entry.delete(0, 'end')\n",
    "    department_entry.delete(0, 'end')\n",
    "\n",
    "root = Tk()\n",
    "\n",
    "name_label = Label(root, text=\"Name:\")\n",
    "name_label.pack()\n",
    "name_entry = Entry(root)\n",
    "name_entry.pack()\n",
    "\n",
    "age_label = Label(root, text=\"Age:\")\n",
    "age_label.pack()\n",
    "age_entry = Entry(root)\n",
    "age_entry.pack()\n",
    "\n",
    "department_label = Label(root, text=\"Department:\")\n",
    "department_label.pack()\n",
    "department_entry = Entry(root)\n",
    "department_entry.pack()\n",
    "\n",
    "save_button = Button(root, text=\"Save\", command=save_employee_data)\n",
    "save_button.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "  \n",
    "# create 2D array of table given above\n",
    "data = [['E001', 'M', 34, 123, 'Normal', 350],\n",
    "        ['E002', 'F', 40, 114, 'Overweight', 450],\n",
    "        ['E003', 'F', 37, 135, 'Obesity', 169],\n",
    "        ['E004', 'M', 30, 139, 'Underweight', 189],\n",
    "        ['E005', 'F', 44, 117, 'Underweight', 183],\n",
    "        ['E006', 'M', 36, 121, 'Normal', 80],\n",
    "        ['E007', 'M', 32, 133, 'Obesity', 166],\n",
    "        ['E008', 'F', 26, 140, 'Normal', 120],\n",
    "        ['E009', 'M', 32, 133, 'Normal', 75],\n",
    "        ['E010', 'M', 36, 133, 'Underweight', 40] ]\n",
    "# dataframe created with\n",
    "# the above data array\n",
    "df = pd.DataFrame(data, columns = ['EMPID', 'Gender', 'Age', 'Sales', 'BMI', 'Income'] )\n",
    "  \n",
    "# create histogram for numeric data\n",
    "df.hist()\n",
    "  \n",
    "# show plot\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no error\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib as plt\n",
    "\n",
    "def fun():\n",
    "      data=[[\"vimala\",1,\"bsc\",\"40%\"]\n",
    "            ,[\"gorav\",2,\"be\",\"50%\"]\n",
    "            ,[\"shankar\",3,\"diploma\",\"80%\"]\n",
    "            ,[\"aravind\",4,\"puc\",\"70%\"]\n",
    "\n",
    "             ]\n",
    "      df=pd.DataFrame(data,columns=[\"name\",\"roll number\",\"branch\",\"percentage\"])\n",
    "# print(df)\n",
    "      try:\n",
    "            df.hist()\n",
    "            plt.show()\n",
    "\n",
    "      except:\n",
    "            print(\"no error\")\n",
    "\n",
    "fun()\n",
    "\n",
    "\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "data = [['vinayak',  34, 123, ],\n",
    "        ['arun',  40, 114, ],\n",
    "        ['varun',  37, 135, ],\n",
    "        ['kiran',  30, 139, ],\n",
    "        ['gourav',  44, 117, ],\n",
    "        ['varsha',  36, 121, ],\n",
    "         ]\n",
    "# dataframe created with\n",
    "df=pd.DataFrame(data,columns=[\"name\",\"aze\",\"roll_number\"])\n",
    "df.plot.bar()\n",
    "plt.bar(df[\"name\"],df[\"aze\"],df[\"roll_number\"])\n",
    "plt.xlabel(\"name\")\n",
    "plt.ylabel(\"roll number\")\n",
    "# plt.xlabel(\"roll number\")\n",
    "# plt.xlabel('aze')\n",
    "plt.show()"
   ]
  }
 ],
 "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}