Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5be8123b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bob\n",
      "(1, 2, 3, 4, 5)\n",
      "3.0\n",
      "30.0\n"
     ]
    }
   ],
   "source": [
    "#lecture 24 object oriented programming\n",
    "class Student:\n",
    "    def __init__(self,name,grades):\n",
    "        self.name=name\n",
    "        self.grades=grades\n",
    "    def average_grades(self):\n",
    "        return sum(self.grades)/len(self.grades)\n",
    "st1=Student(\"bob\",(1,2,3,4,5))\n",
    "st2=Student(\"rolf\",(10,20,30,40,50))\n",
    "\n",
    "print(st1.name)\n",
    "print(st1.grades)\n",
    "print(st1.average_grades())\n",
    "print(Student.average_grades(st2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a8a77c79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__init__function called by default\n",
      "name : bob age : 45\n"
     ]
    }
   ],
   "source": [
    "#lecture 25 __str__ and __repr__ methods\n",
    "# this is about represeting the class object as a string\n",
    "class Person:\n",
    "    def __init__(self,name,age):\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "        print(\"__init__function called by default\")\n",
    "    #without str function, print(person) will print something like <__main__.Person object at 0x000001B9AABE60D0>\n",
    "    def __str__(self):\n",
    "        return f\"name : {self.name} age : {self.age}\"\n",
    "    #if there are both str and repr functions defined, calling print(person) will call str function. If str is not defined\n",
    "    #and repr is defined, print(person) will call repr function\n",
    "    def __repr__(self):\n",
    "        return f\"{self.name}'s age is {self.age}\"\n",
    "person=Person(\"bob\",45)\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2f4d6a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is instance method of <__main__.Testmethod object at 0x000001B9AB057F40>\n",
      "this is instance method of <__main__.Testmethod object at 0x000001B9AB057F40>\n",
      "this is class method of <class '__main__.Testmethod'>\n",
      "this is static method\n",
      "book's \n",
      " name=asamardhuni jeevayatra,type=pdf,weight=20g\n",
      "book's \n",
      " name=pandita parameshwara sastry veelunama,type=Hard cover,weight=300g\n"
     ]
    }
   ],
   "source": [
    "#lecture 26 instnce,class and static methods\n",
    "class Testmethod:\n",
    "    def instance_method(self): #instance need the object to call them\n",
    "        #mostly used to produce actions using the data of objects.also used to modify any data of an object\n",
    "        print(f\"this is instance method of {self}\")\n",
    "        \n",
    "    @classmethod\n",
    "    def class_method(cls):#class method doesn't need an object to call them.can be called directly called using class name\n",
    "        #used often as factories\n",
    "        print(f\"this is class method of {cls}\")\n",
    "    \n",
    "    @staticmethod\n",
    "    def static_method(): # just a function placed inside a class. it won't have any info regarding class.\n",
    "        #don't need an object to call\n",
    "        print(f\"this is static method\")\n",
    "\n",
    "test1=Testmethod()\n",
    "test1.instance_method() #prints this is instance method of <__main__.Testmethod object at 0x000001B9AB05F940>\n",
    "Testmethod.instance_method(test1) # this is instance method of <__main__.Testmethod object at 0x000001B9AB05F940>\n",
    "Testmethod.class_method() #prints this is class method of <class '__main__.Testmethod'>\n",
    "Testmethod.static_method() #prints this is static method\n",
    " \n",
    "class Book:\n",
    "    Types=(\"Hard cover\",\"pdf\") # class variable. accessible all over the class. \n",
    "    def __init__(self,name : str,book_type : str ,weight : int):\n",
    "        self.name=name\n",
    "        self.book_type=book_type\n",
    "        self.weight=weight\n",
    "    \n",
    "    def __repr__(self) -> str:\n",
    "        return (f\"book's \\n name={self.name},type={self.book_type},weight={self.weight}g\")\n",
    "    @classmethod\n",
    "    def hard_cover(cls,name : str,weight: int) -> \"Book\": #  If this is a same class, class name should be in quotes. if fun returns other class object(let's say Bookshelf),  Then we can keep it without quotes\"\n",
    "        return cls(name,cls.Types[0],weight) # this is also same as return Book(name,Book.Types[0],weight)\n",
    "    \n",
    "    @classmethod\n",
    "    def pdf(cls,name,weight):\n",
    "        return Book(name,Book.Types[1],weight)\n",
    "a_j=Book.pdf(\"asamardhuni jeevayatra\",20)\n",
    "ppsv=Book.hard_cover(\"pandita parameshwara sastry veelunama\",300)\n",
    "print(a_j)\n",
    "print(ppsv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b4da06c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name is 'printer' and is connected by (USB)\n",
      "printer is disconnected\n",
      "name is 'printer2' and is connected by (type c)\n",
      "printer2 is disconnected\n",
      "printer not connected\n"
     ]
    }
   ],
   "source": [
    "#lecture 27 class inheritance\n",
    "class Device:  # Device inherits from pythons default class Object\n",
    "    def __init__(self,name,connected_by):\n",
    "        self.name=name\n",
    "        self.connected_by=connected_by\n",
    "        self.connected=True\n",
    "    def __str__(self):\n",
    "        return f\"name is {self.name!r} and is connected by ({self.connected_by})\" \n",
    "    def disconnect(self):\n",
    "        self.connected=False\n",
    "        print(f\"{self.name} is disconnected\")\n",
    "printer=Device(\"printer\",\"USB\")\n",
    "print(printer)\n",
    "printer.disconnect()\n",
    "\n",
    "class Printer(Device):\n",
    "    def __init__(self,name,connected_by,capacity):\n",
    "        super().__init__(name,connected_by)\n",
    "        self.capacity=capacity\n",
    "        self.remaining_pages=capacity\n",
    "    def print(self,pages):\n",
    "        if(self.connected == False):\n",
    "            return \"printer not connected\"\n",
    "        self.remaining_pages-=pages\n",
    "        return (f\"{self.name} has {pages} pages written to it and the remaining pages are {self.remaining_pages}\")\n",
    "\n",
    "printer2=Printer(\"printer2\",\"type c\",400)\n",
    "print(printer2)\n",
    "printer2.disconnect()\n",
    "print(printer2.print(40))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "cdb3a293",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "books name is number 1\n",
      "books name is number 2\n",
      "there are 2 books in shelf\n",
      "books name is number 1\n",
      "books name is number 2\n"
     ]
    }
   ],
   "source": [
    "#lecture 28 class composition\n",
    "class Book:\n",
    "    def __init__(self,name : str):\n",
    "        self.name=name\n",
    "    def __str__(self) -> str:\n",
    "        return f\"books name is {self.name}\"\n",
    "\n",
    "class BookShelf:   # a class is composed of other classes\n",
    "    def __init__(self,*books):\n",
    "        self.books=books\n",
    "    def __str__(self):\n",
    "        return f\"there are {len(self.books)} books in shelf\"\n",
    "    def printbooksinshelf(self):\n",
    "        for i in self.books:\n",
    "            print(i)\n",
    "\n",
    "book1=Book(\"number 1\")\n",
    "book2=Book(\"number 2\")\n",
    "print(book1)\n",
    "print(book2)\n",
    "shelf1=BookShelf(book1,book2)\n",
    "print(shelf1)\n",
    "shelf1.printbooksinshelf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "32b289e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#lecture 29 type hinting \n",
    "from typing import List  # Tuple,set.... etc\n",
    "\n",
    "class Book:\n",
    "    def __init__(self,name: str):\n",
    "        self.name=name\n",
    "    def __str__(self) -> str:\n",
    "        return f\"books name is {self.name}\"\n",
    "\n",
    "class BookShelf:   # a class is composed of other classes\n",
    "    def __init__(self,*books : List[Book]):\n",
    "        self.books=books\n",
    "    def __str__(self) -> str:\n",
    "        return f\"there are {len(self.books)} books in shelf\"\n",
    "    def printbooksinshelf(self):\n",
    "        for i in self.books:\n",
    "            print(i)\n",
    "\n",
    "def fun(arg1 : List) -> float:\n",
    "    return sum(arg1)/len(arg1)\n",
    "\n",
    "fun([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4ab7d12b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C:\\\\Users\\\\gundar9t\\\\Learning\\\\python\\\\Udemy_GUI_Development_with_Python_and_Tkinter_2021-9.part1_Downloadly.ir\\\\Practice', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\python39.zip', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\DLLs', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3', '', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\site-packages', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin', 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions', 'C:\\\\Users\\\\gundar9t\\\\.ipython']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\n# this is not working in jupyter notebook but working in spyder. don't know why. Hence keeping it in comment : \\nfrom sample_for_imports2 import fun,fun2\\n\\nprint(fun())\\nprint(fun2())\\n\\nout put of above program : \\nReloaded modules: sample_for_imports2\\nthis content is from function fun\\nprogram is running in other module\\nthe value of __name__ is  sample_for_imports2\\nthis content is from function fun2\\n\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#lecture 30 imports in python\n",
    "#from sample_for_imports import fun2\n",
    "#print(fun2())\n",
    "#print(fun(20,30),__name__)\n",
    "import os\n",
    "#s=os.path()\n",
    "#print(os.environ[\"TMP\"])\n",
    "\n",
    "#os.chdir(r\"C:\\Users\\gundar9t\\Documents\")\n",
    "#for i,j,k in os.walk(os.getcwd()):\n",
    "#    #print(i)\n",
    "#    #print(k)\n",
    "#    print(type(k))\n",
    "#    for p in k:\n",
    "#        if \"pdf\" in p:\n",
    "#            print(str(i)+\"\\\\\"+p)\n",
    "#            os.startfile(\"r\"+str(i)+\"\\\\\"+p)\n",
    "import sys\n",
    "#print(sys.modules)\n",
    "print(sys.path)\n",
    "\"\"\"\n",
    "# this is not working in jupyter notebook but working in spyder. don't know why. Hence keeping it in comment : \n",
    "from sample_for_imports2 import fun,fun2\n",
    "\n",
    "print(fun())\n",
    "print(fun2())\n",
    "\n",
    "out put of above program : \n",
    "Reloaded modules: sample_for_imports2\n",
    "this content is from function fun\n",
    "program is running in other module\n",
    "the value of __name__ is  sample_for_imports2\n",
    "this content is from function fun2\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a3cc48df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "welcome to calculation of grades\n",
      "raised zero division error\n",
      "error message is  can't divide with 0\n",
      "average of Bob is 34.0\n",
      "0 div error occurred  can't divide with 0\n",
      "this is the end of report irrespective of all students reports got calculated\n"
     ]
    }
   ],
   "source": [
    "#lecture 32 exceptions in python\n",
    "def divide(dividend ,divisor): \n",
    "    if dividend == 0 : \n",
    "        raise ZeroDivisionError(\"can't divide with 0\")\n",
    "    return dividend/divisor\n",
    "\n",
    "grades=[]\n",
    "print(\"welcome to calculation of grades\")\n",
    "try: \n",
    "    \n",
    "    average=divide(sum(grades),len(grades))\n",
    "    print(\"average is \",average)\n",
    "except ZeroDivisionError as e:\n",
    "    print(\"raised zero division error\")\n",
    "    print(\"error message is \",e)\n",
    "\n",
    "students=[\n",
    "    {\"name\": \"Bob\",\"grades\":[12,34,56]},\n",
    "    {\"name\": \"Coby\",\"grades\":[]},\n",
    "    {\"name\": \"danny\",\"grades\":[129,38,56]}\n",
    "]\n",
    "try: \n",
    "    for i in students:\n",
    "        average=divide(sum(i[\"grades\"]),len(i[\"grades\"]))\n",
    "        name=i[\"name\"]\n",
    "        print(f\"average of {name} is {average}\")\n",
    "except ZeroDivisionError as e:\n",
    "    print(\"0 div error occurred \",e)\n",
    "else:\n",
    "    print(\"averages of all students got calculated\")\n",
    "finally:\n",
    "    print(\"this is the end of report irrespective of all students reports got calculated\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5fe7597f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "successfully read 20 pages \n",
      "successfully read 70 pages \n",
      "not possible to read 110 pages in a book with 100 pages\n"
     ]
    }
   ],
   "source": [
    "#class 33 custom error classes\n",
    "class TooManyPagesReadError(ValueError):\n",
    "    pass\n",
    "class Book:\n",
    "    def __init__(self,name,page_count):\n",
    "        self.name=name\n",
    "        self.page_count=page_count\n",
    "        self.pages_read=0\n",
    "    def read(self,pages):\n",
    "        if(self.pages_read+pages>self.page_count):\n",
    "            raise TooManyPagesReadError(f\"not possible to read {self.pages_read+pages} pages in a book with {self.page_count} pages\")\n",
    "        else:\n",
    "            self.pages_read+=pages\n",
    "            print(f\"successfully read {self.pages_read} pages \")\n",
    "try :\n",
    "    python101=Book(\"python 101\",100)\n",
    "    python101.read(20)\n",
    "    python101.read(50)\n",
    "    python101.read(40)\n",
    "except TooManyPagesReadError as e:\n",
    "    print(e) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "fb2b1bcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "arianagrande couldn't be found in [{'name': 'bob smith', 'age': 24, 'gender': 'male'}, {'name': 'calvin clain', 'age': 42, 'gender': 'male'}, {'name': 'ariana grande', 'age': 28, 'gender': 'female'}]\n"
     ]
    }
   ],
   "source": [
    "#lecture 34 first class functions\n",
    "def calculate(*values,operator):\n",
    "    return operator(*values)\n",
    "result=calculate(10,5,operator=divide)\n",
    "print(result)\n",
    "def search(given,expected,finder):\n",
    "    for i in given:\n",
    "        if finder(i) == expected:\n",
    "            return i\n",
    "    return RuntimeError(f\"{expected} couldn't be found in {given}\")\n",
    "\n",
    "names=[\n",
    "    {\"name\":\"bob smith\",\"age\":24,\"gender\":\"male\"},\n",
    "    {\"name\":\"calvin clain\",\"age\":42,\"gender\":\"male\"},\n",
    "    {\"name\":\"ariana grande\",\"age\":28,\"gender\":\"female\"},\n",
    "]\n",
    "def get_friend(i):\n",
    "    return i[\"name\"]\n",
    "\n",
    "result=search(names,\"arianagrande\",finder=get_friend)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "0be50dd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'username': 'guna', 'access level': 'admin'}\n",
      "1234\n",
      "1234\n"
     ]
    }
   ],
   "source": [
    "#lecture 35 decorators \n",
    "def get_admin_password():\n",
    "    return \"1234\"\n",
    "\n",
    "get_admin_password()\n",
    "\n",
    "def secure_function(func):\n",
    "    def wrapper_function():\n",
    "        if user[\"access level\"] == \"admin\" : \n",
    "            print(user)\n",
    "            return func()\n",
    "    return wrapper_function\n",
    "abc=secure_function(get_admin_password)\n",
    "\n",
    "get_admin_pasword = secure_function(get_admin_password)\n",
    "print(abc())\n",
    "print(get_admin_password())\n",
    "user={\"username\":\"guna\",\"access level\":\"admin\"}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "6f9e713b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function get_admin_password at 0x000002217D10ED30>\n",
      "{'username': 'guna', 'access level': 'admin'}\n",
      "secure super password\n"
     ]
    }
   ],
   "source": [
    "#lecture 36,37 using @ for decorators, using parameters in decorators\n",
    "from functools import wraps\n",
    "def secure_function(func):\n",
    "    @wraps(func)\n",
    "    def wrapper_function(*args,**kwargs):\n",
    "        if user[\"access level\"] == \"admin\" : \n",
    "            print(user)\n",
    "            return func(*args,**kwargs)\n",
    "    return wrapper_function\n",
    "\n",
    "@secure_function\n",
    "def get_admin_password(panel):\n",
    "    if panel == \"admin\":\n",
    "        return \"1234\"\n",
    "    else:\n",
    "        return \"secure super password\"\n",
    "\n",
    "print(get_admin_password)\n",
    "#print(get_admin_password())\n",
    "print(get_admin_password(\"admsdfin\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "714364bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "admin : 1234\n",
      "no admission for \n",
      "no admission for \n",
      "user : user_password\n"
     ]
    }
   ],
   "source": [
    "#lecture 38 decorator with parameters.\n",
    "from functools import wraps\n",
    "\n",
    "user={\"username\":\"guna\",\"access level\":\"admin\"}\n",
    "def secure_function(access_level):\n",
    "    def decorator(func):\n",
    "        @wraps(func)\n",
    "        def wrapper_function(*args,**kwargs):\n",
    "            if user[\"access level\"] == access_level : \n",
    "                #print(user)\n",
    "                return func(*args,**kwargs)\n",
    "            else:\n",
    "                return f\"no admission for \"\n",
    "        return wrapper_function\n",
    "    return decorator\n",
    "\n",
    "@secure_function(\"admin\")\n",
    "def get_admin_password():\n",
    "    return \"admin : 1234\"\n",
    "\n",
    "@secure_function(\"guest\")\n",
    "def get_dashboard_password():\n",
    "    return \"user : user_password\"\n",
    "#print(get_admin_password)\n",
    "#print(get_admin_password())\n",
    "print(get_admin_password()) \n",
    "print(get_dashboard_password())\n",
    "user={\"username\":\"guna\",\"access level\":\"guest\"}\n",
    "print(get_admin_password()) \n",
    "print(get_dashboard_password())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "d5aa7d6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[90]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "#lecture 40 \n",
    "# do not use mutable objects as default parameters of any class or function\n",
    "from typing import List,Optional\n",
    "class Student:\n",
    "    def __init__(self,name : str, grades : Optional[List[int]] = None):\n",
    "        self.name=name\n",
    "        self.grades=grades or []\n",
    "    def take_exam(self,marks):\n",
    "        self.grades.append(marks)\n",
    "\n",
    "bob=Student(\"bob\")\n",
    "rolf=Student(\"rolf\")\n",
    "bob.take_exam(90)\n",
    "print(bob.grades) \n",
    "print(rolf.grades) #  both above grades prints [90] if the default argument of class is set as empty list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9fa2bcd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nroot=tk.Tk()\\nmain=ttk.Frame(root)\\nmain.pack(fill=\"both\")\\nmain2=ttk.Frame(root)\\nmain2.pack(fill=\"both\")\\ndef fun():\\n    print(f\"the name entered in UI is {user_name.get() or \\'world\\'} \")\\n#ttk.Label(root,text=\"Hello world\",padding=(20,40)).pack()\\nuser_name=tk.StringVar()\\n\\nroot.title(\"Greeting App\")\\n#label saying Name:\\nlabel=ttk.Label(main,text=\"Name: \")\\nlabel.pack(side=\"left\",padx=(0,20))\\n\\n#user input entry field\\nentry=ttk.Entry(main,width=12,textvariable=user_name)\\nentry.pack(side=\"left\")\\nentry.focus()\\n\\n#greet button which makes the name entered in UI to print in console and quit button destroys the window\\ngreet_button=ttk.Button(main2,text=\"Greet Button\",command=fun)\\nquit_button=ttk.Button(main2,text=\"quit Button\",command=root.destroy)\\ngreet_button.pack(side=\"left\",fill=\"x\",expand=True)\\nquit_button.pack(side=\"right\",fill=\"x\",expand=True)\\nroot.mainloop()'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tkinter pack example\n",
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "tk._test()\n",
    "\"\"\"\n",
    "root=tk.Tk()\n",
    "main=ttk.Frame(root)\n",
    "main.pack(fill=\"both\")\n",
    "main2=ttk.Frame(root)\n",
    "main2.pack(fill=\"both\")\n",
    "def fun():\n",
    "    print(f\"the name entered in UI is {user_name.get() or 'world'} \")\n",
    "#ttk.Label(root,text=\"Hello world\",padding=(20,40)).pack()\n",
    "user_name=tk.StringVar()\n",
    "\n",
    "root.title(\"Greeting App\")\n",
    "#label saying Name:\n",
    "label=ttk.Label(main,text=\"Name: \")\n",
    "label.pack(side=\"left\",padx=(0,20))\n",
    "\n",
    "#user input entry field\n",
    "entry=ttk.Entry(main,width=12,textvariable=user_name)\n",
    "entry.pack(side=\"left\")\n",
    "entry.focus()\n",
    "\n",
    "#greet button which makes the name entered in UI to print in console and quit button destroys the window\n",
    "greet_button=ttk.Button(main2,text=\"Greet Button\",command=fun)\n",
    "quit_button=ttk.Button(main2,text=\"quit Button\",command=root.destroy)\n",
    "greet_button.pack(side=\"left\",fill=\"x\",expand=True)\n",
    "quit_button.pack(side=\"right\",fill=\"x\",expand=True)\n",
    "root.mainloop()\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "1bdd1cd7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'import tkinter as tk\\nfrom tkinter import ttk\\n\\nroot=tk.Tk()\\nroot.geometry(\\'600x400\\')\\nmain=ttk.Frame(root)\\nmain.pack(side=\"left\",expand=True,fill=\"both\")\\n\\nlabel1=tk.Label(main, text=\"label 1\", bg=\"blue\", fg=\"white\")\\nlabel1.pack(side=\"left\",ipadx=10,ipady=10,fill=\"both\",expand=True)\\n\\nlabel2=tk.Label(main, text=\"label 2\", bg=\"green\", fg=\"white\")\\nlabel2.pack(side=\"top\",ipadx=10,ipady=10,fill=\"both\",expand=True)\\n\\nlabel2=tk.Label(root, text=\"label 3\", bg=\"red\", fg=\"white\")\\nlabel2.pack(side=\"right\",ipadx=10,ipady=10,fill=\"both\",expand=True)\\n\\nroot.mainloop()'"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "root=tk.Tk()\n",
    "root.geometry('600x400')\n",
    "main=ttk.Frame(root)\n",
    "main.pack(side=\"left\",expand=True,fill=\"both\")\n",
    "\n",
    "label1=tk.Label(main, text=\"label 1\", bg=\"blue\", fg=\"white\")\n",
    "label1.pack(side=\"left\",ipadx=10,ipady=10,fill=\"both\",expand=True)\n",
    "\n",
    "label2=tk.Label(main, text=\"label 2\", bg=\"green\", fg=\"white\")\n",
    "label2.pack(side=\"top\",ipadx=10,ipady=10,fill=\"both\",expand=True)\n",
    "\n",
    "label2=tk.Label(root, text=\"label 3\", bg=\"red\", fg=\"white\")\n",
    "label2.pack(side=\"right\",ipadx=10,ipady=10,fill=\"both\",expand=True)\n",
    "\n",
    "root.mainloop()\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "37c26a9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#tkinter grid example\n",
    "\n",
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "\"\"\"\n",
    "try:\n",
    "    from ctypes import windll\n",
    "    windll.shcore.SetProcessDpiAwareness(1)\n",
    "except:\n",
    "    pass\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "root=tk.Tk()\n",
    "root.title(\"Grid Example\")\n",
    "frame1=ttk.Frame(root)\n",
    "frame2=ttk.Frame(root)\n",
    "\n",
    "frame1.grid(row=0,column=0,sticky=\"EW\" )\n",
    "\n",
    "root.columnconfigure(0,weight=1)\n",
    "frame2.columnconfigure(0,weight=1)\n",
    "frame2.columnconfigure(1,weight=1)\n",
    "\n",
    "def function():\n",
    "    print(f\"name entered in label is {user_name.get()}\")\n",
    "\n",
    "user_name=tk.StringVar()\n",
    "\n",
    "name_label=ttk.Label(frame1,text=\"Name : \")\n",
    "name_label.grid(row=0,column=0)\n",
    "\n",
    "name_entry=ttk.Entry(frame1,textvariable=user_name)\n",
    "name_entry.grid(row=0,column=1)\n",
    "name_entry.focus()\n",
    "\n",
    "greet_button=ttk.Button(frame2,text=\"Greet\",command=function)\n",
    "greet_button.grid(row=1,column=0,sticky=\"EW\")\n",
    "\n",
    "quit_button=ttk.Button(frame2,text=\"Quit\",command=root.destroy)\n",
    "quit_button.grid(row=1,column=1,sticky=\"EW\")\n",
    "\n",
    "frame2.grid(row=1,column=0,sticky=\"EW\")\n",
    "\n",
    "root.mainloop()\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "fd1ea6b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating the default ui which added content to button text when button is clicked\n",
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "root=tk.Tk()\n",
    "root.title(\"default\")\n",
    "\n",
    "button=tk.Button(root,text=\"Click Me\",command=lambda root=root: root.button.configure(text=\"[%s]\" % root.button['text']))\n",
    "button.pack()\n",
    "root.button=button\n",
    "\n",
    "quit=tk.Button(root,text=\"quit\",command=root.destroy)\n",
    "quit.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9f9fb563",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'ntpath' from 'C:\\\\Users\\\\gundar9t\\\\Anaconda3\\\\lib\\\\ntpath.py'>\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "print(os.path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56e8ec25",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}