Assignment 19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f2559a7c",
   "metadata": {},
   "source": [
    "# 1. Make a class called Thing with no contents and print it. Then, create an object called example from this class and also print it. Are the printed values the same or different?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9fdfd91c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Thing'>\n"
     ]
    }
   ],
   "source": [
    "class Thing:\n",
    "    pass\n",
    "\n",
    "print(Thing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5fe4feb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Thing object at 0x0000022CE4B7E250>\n"
     ]
    }
   ],
   "source": [
    "example = Thing()\n",
    "print(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbfb4dc2",
   "metadata": {},
   "source": [
    "# 2. Create a new class called Thing2 and add the value &#39;abc&#39; to the letters class attribute. Letters should be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0170b758",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "class Thing2:\n",
    "    letters = 'abc'\n",
    "    \n",
    "print(Thing2.letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cb9bf76",
   "metadata": {},
   "source": [
    "# 3. Make yet another class called, of course, Thing3. This time, assign the value &#39;xyz&#39; to an instance (object) attribute called letters. Print letters. Do you need to make an object from the class to do this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4497bb90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xyz\n"
     ]
    }
   ],
   "source": [
    "class Thing3:\n",
    "    def __init__(self,letter):\n",
    "        self.letter = letter\n",
    "    def letters(self):\n",
    "        print(self.letter)\n",
    "Thing3('xyz').letters()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de7ff274",
   "metadata": {},
   "source": [
    "# 4. Create an Element class with the instance attributes name, symbol, and number. Create a class object with the values &#39;Hydrogen,&#39; &#39;H,&#39; and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "64fd96f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Element:   \n",
    "    def __init__(self, name, symbol, number):\n",
    "        self.name = name\n",
    "        self.symbol = symbol\n",
    "        self.number = number\n",
    "\n",
    "my_elements = Element('Hydrogen','H',1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f36d6ae",
   "metadata": {},
   "source": [
    "# 5. Make a dictionary with these keys and values: &#39;name&#39;: &#39;Hydrogen&#39;, &#39;symbol&#39;: &#39;H&#39;, &#39;number&#39;: 1. Then, create an object called hydrogen from class Element using this dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6380ee47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Hydrogen', 'symbol': 'H', 'number': 1}\n",
      "Hydrogen\tH\t1\n"
     ]
    }
   ],
   "source": [
    "custom_dict = {'name':'Hydrogen','symbol':'H','number':1}\n",
    "print(custom_dict)\n",
    "\n",
    "hydrogen = Element(*custom_dict.values())\n",
    "print(hydrogen.name,hydrogen.symbol,hydrogen.number, sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b169994",
   "metadata": {},
   "source": [
    "# 6. For the Element class, define a method called dump() that prints the values of the object’s attributes (name, symbol, and number). Create the hydrogen object from this new definition and use dump() to print its attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "713174cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hydrogen H 1\n"
     ]
    }
   ],
   "source": [
    "class Element:\n",
    "    def __init__(self, name, symbol, number):\n",
    "        self.name = name\n",
    "        self.symbol = symbol\n",
    "        self.number = number      \n",
    "    def dump(self):\n",
    "        print(self.name, self.symbol, self.number)\n",
    "        \n",
    "hydrogen = Element('Hydrogen','H',1)\n",
    "hydrogen.dump()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccf765a0",
   "metadata": {},
   "source": [
    "# 7. Call print(hydrogen). In the definition of Element, change the name of method dump to __str__, create a new hydrogen object, and call print(hydrogen) again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "548ddd5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Element object at 0x0000022CE4BC8130>\n",
      "Hydrogen H 1\n"
     ]
    }
   ],
   "source": [
    "print(hydrogen)\n",
    "\n",
    "class Element:\n",
    "    def __init__(self, name, symbol, number):\n",
    "        self.name = name\n",
    "        self.symbol = symbol\n",
    "        self.number = number      \n",
    "    def __str__(self):\n",
    "        return f'{self.name} {self.symbol} {self.number}'\n",
    "        \n",
    "Hydrogen = Element('Hydrogen','H',1)\n",
    "print(Hydrogen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0578ee13",
   "metadata": {},
   "source": [
    "# 8. Modify Element to make the attributes name, symbol, and number private. Define a getter property for each to return its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "26c200af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hydrogen\n",
      "H\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class Element:\n",
    "    def __init__(self,name,symbol,number):\n",
    "        self.__name = name\n",
    "        self.__symbol = symbol\n",
    "        self.__number = number\n",
    "    \n",
    "    @property\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    @property\n",
    "    def get_symbol(self):\n",
    "        return self.__symbol\n",
    "    \n",
    "    @property\n",
    "    def get_number(self):\n",
    "        return self.__number\n",
    "    \n",
    "hydrogen = Element('Hydrogen','H',1)\n",
    "print(hydrogen.get_name)\n",
    "print(hydrogen.get_symbol)\n",
    "print(hydrogen.get_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb3a44b6",
   "metadata": {},
   "source": [
    "# 9. Define three classes: Bear, Rabbit, and Octothorpe. For each, define only one method: eats(). This should return &#39;berries&#39; (Bear), &#39;clover&#39; (Rabbit), or &#39;campers&#39; (Octothorpe). Create one object from each and print what it eats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4ff3d99c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "berries\n",
      "clover\n",
      "campers\n"
     ]
    }
   ],
   "source": [
    "class Bear:\n",
    "    def eats(self):\n",
    "        print('berries')\n",
    "class Rabbit:\n",
    "    def eats(self):\n",
    "        print('clover')\n",
    "class Octothorpe:\n",
    "    def eats(self):\n",
    "        print('campers')\n",
    "        \n",
    "bear = Bear()\n",
    "rabbit = Rabbit()\n",
    "octothrope = Octothorpe()\n",
    "\n",
    "bear.eats()\n",
    "rabbit.eats()\n",
    "octothrope.eats()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbde5930",
   "metadata": {},
   "source": [
    "# 10. Define these classes: Laser, Claw, and SmartPhone. Each has only one method: does(). This returns &#39;disintegrate&#39; (Laser), &#39;crush&#39; (Claw), or &#39;ring&#39; (SmartPhone). Then, define the class Robot that has one instance (object) of each of these. Define a does() method for the Robot that prints what its component objects do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "102841bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "disintegrate crush ring\n"
     ]
    }
   ],
   "source": [
    "class Laser:\n",
    "    def does(self):\n",
    "        return 'disintegrate'\n",
    "class Claw:\n",
    "    def does(self):\n",
    "        return 'crush'\n",
    "class Smartphone:\n",
    "    def does(self):\n",
    "        return 'ring'\n",
    "class Robot:\n",
    "    def __init__(self):\n",
    "        self.laser = Laser()\n",
    "        self.claw = Claw()\n",
    "        self.smartphone = Smartphone()\n",
    "    def does(self):\n",
    "        print(self.laser.does(),self.claw.does(),self.smartphone.does())\n",
    "        \n",
    "r2d2 = Robot()\n",
    "r2d2.does()"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}