lecture_19_intro_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "In a very simplicistic view, `Classes` are just pre-defined storage containers with additional functionality that knows how to access the currently stored data. (=`methods`).\n",
    "\n",
    "So, for example, the simplest class possible is actually an empty container you can just use to store stuff in, very similar to dictionaries, or structures in other languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Mammal:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is sometimes useful to just quickly store things together in the same object for logical separations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal = Mammal()    # now I have an \"object\" or \"instance\" of a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Mammal at 0x1155f13c8>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal.n_of_legs = 4   # this is a new data attribute.\n",
    "# as usual, Python doesn't need it to be defined before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal.noise = 'blarg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'n_of_legs': 4, 'noise': 'blarg'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammal.__dict__     # this is a useful internal attribute listing all data attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(mammal.n_of_legs)  # note this attribute becomes <tab>-complete-able"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for a mid-size to bigger project, we don't want to define things only on the go.\n",
    "\n",
    "Creating a class with some structure and functionality will increase our efficiency when working\n",
    "with a lot of data that has a lot of sub-structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Mammal:\n",
    "    # these are data attributes of the class\n",
    "    name = 'Mammal'\n",
    "    n_of_legs = 0\n",
    "    noise = None   # indicating non-functionality\n",
    "    nutrition_status = 0\n",
    "    \n",
    "    # this is a method of the class\n",
    "    # methods are just like functions, but they always refer back to the\n",
    "    # current object with the first argument being 'self', and after that\n",
    "    # can take other arguments for functionality.\n",
    "    def make_noise(self):\n",
    "        if self.noise is not None:\n",
    "            print(self.noise)\n",
    "        else:\n",
    "            print(\"Not implemented yet.\")\n",
    "            \n",
    "    def feed(self, units):\n",
    "        \"This is a minimalist docstring.\"\n",
    "        \n",
    "        self.nutrition_status += units\n",
    "        print(\"Was fed {} units of nutrition.\".format(units))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(Mammal.n_of_legs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create an object of this class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal = Mammal()  # this is called \"instantiation of an object\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Coding standards** The usual applied coding style is that classes are defined with capital letters, and the instantiated object is often called the same name but with small letters. (Unless the object becomes more specific, see later).\n",
    "\n",
    "Now, let's use a method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not implemented yet.\n"
     ]
    }
   ],
   "source": [
    "mammal.make_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `noise` attribute isn't set yet, so that's what we get."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal.noise = 'snort'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal.noise = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not implemented yet.\n"
     ]
    }
   ],
   "source": [
    "mammal.make_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Under the hood\" we have changed an attribute of the method being used. In other words, how a method works can be highly status dependent.\n",
    "\n",
    "This status-like programming style is both hard to follow at times, but also creates great opportunities, for example, to write methods that just automatically do the right thing, because they would read-out its own status from class attributes that have been set when a status changed.\n",
    "\n",
    "Note: \n",
    "1. **instances** are independent of each other\n",
    "2. You do not **HAVE TO** create an object to use things inside a class\n",
    "\n",
    "First, # 1: Independence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not implemented yet.\n"
     ]
    }
   ],
   "source": [
    "mammal2 = Mammal()\n",
    "mammal2.make_noise()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mammal2.noise = 'burp'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not implemented yet.\n",
      "burp\n"
     ]
    }
   ],
   "source": [
    "for m in [mammal, mammal2]:\n",
    "    m.make_noise()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Was fed 5 units of nutrition.\n"
     ]
    }
   ],
   "source": [
    "mammal.feed(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for m in [mammal, mammal2]:\n",
    "    print(m.nutrition_status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now #2: \n",
    "\n",
    "Classes can be used for accessing class-based data, that are **NOT** supposed to change between instances, like the name 'mammal' for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mammal'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mammal.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mammal.n_of_legs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using `__init__` to initalize a class\n",
    "\n",
    "It's a bit inconvenient to set up things after instantiating a new object,\n",
    "so here's how to do it in one go, using the special `__init__` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import datetime as dt\n",
    "\n",
    "class Mammal:\n",
    "    # these are data attributes of the class\n",
    "    name = 'Mammal'\n",
    "    n_of_legs = 0\n",
    "    noise = None\n",
    "    nutrition_status = 0\n",
    "    \n",
    "    # Always refer to self first in class methods!\n",
    "    # This 'self' is used to attach data to itself when being \n",
    "    # 'alive' as an instance later on!\n",
    "    def __init__(self, noise, legs):\n",
    "        \"\"\"The initialization method. Always called __init__ ! \"\"\"\n",
    "        self.noise = noise     \n",
    "        self.n_of_legs = legs  \n",
    "        self.creation_time = dt.datetime.now().isoformat()\n",
    "        \n",
    "    # this is a method of the class\n",
    "    # methods are just like functions, but they always refer back to the\n",
    "    # current object with the first argument being 'self', and after that\n",
    "    # can take other arguments for functionality.\n",
    "    def make_noise(self):\n",
    "        if self.noise is not None:\n",
    "            print(self.noise)\n",
    "        else:\n",
    "            print(\"Not implemented yet.\")\n",
    "            \n",
    "    def feed(self, units):\n",
    "        \"This is a minimalist docstring.\"\n",
    "        \n",
    "        self.nutrition_status += units\n",
    "        print(\"Was fed {} units of nutrition.\".format(units))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mammal = Mammal('bark', 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "mammal.make_noise()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammal.n_of_legs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the difference between class attributes and instance attributes.\n",
    "\n",
    "Instance attributes only exist after instantiation of an object (an 'alive' version of the mere theoretical class).\n",
    "\n",
    "While class attributes always exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "type object 'Mammal' has no attribute 'creation_time'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-c8f2aed491c5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mMammal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreation_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: type object 'Mammal' has no attribute 'creation_time'"
     ]
    }
   ],
   "source": [
    "Mammal.creation_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2016-06-24T13:44:29.945707'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammal.creation_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mammal'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Mammal.name\n",
    "# i did not create this attribute with the __init__ method, yet it exists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `__init__` function is often used to execute something that takes a bit more time than standard operation, maybe like connecting to a remote database and read out some data.\n",
    "\n",
    "By generating an instance of that class, the data that was read out then stays alive within that object and can be accessed whenever required later on.\n",
    "\n",
    "For more applicability, let's leave the Mammals alone for now and talk about how to apply classes to Planets, but keep them in mind for later when we discuss inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  Define the class.  Planet is the name of the class.\n",
    "class Planet:\n",
    "    # note how i can make an argument optional, just like for functions\n",
    "    def __init__(self, name, diameter=5000):\n",
    "        \"\"\"The initialization of my class.\n",
    "        This is a special method (function) that gets called every time you\n",
    "        create a new class.  Every method in a class has \"self\" as the first\n",
    "        parameter.  The additional parameters to __init__ are the class's\n",
    "        input parameters (in this case name and diameter).  You can set a\n",
    "        default value to each parameter (diameter has a default of 5000).\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.diameter = diameter\n",
    "        \n",
    "    def __str__(self):\n",
    "        s = \"This is {} with a diameter of {}\".format(self.name, self.diameter)\n",
    "        return s\n",
    "    \n",
    "#     def __repr__(self):\n",
    "#         return self.__str__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and Using a Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To recap:\n",
    "\n",
    "To use a class you've written, you first need to create an \"instance\" of the class. Very much like with lists or dictionaries (in fact, dictionaries and lists are classes!). Some classes have required input parameters. Some classes have optional input parameters. Some classes have no input parameters at all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  Create 2 planets.  The first by passing in as input the name and diameter.\n",
    "#  With the second planet we just pass in the name so the diameter takes on\n",
    "#  the default value (5000 in this case).\n",
    "planet1 = Planet(\"Crypton\", 13000)\n",
    "planet2 = Planet(\"Eternia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Crypton with a diameter of 13000\n"
     ]
    }
   ],
   "source": [
    "print(planet1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Planet at 0x115b0b3c8>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  Define the class.  Planet is the name of the class.\n",
    "class Planet:\n",
    "    # note how i can make an argument optional, just like for functions\n",
    "    def __init__(self, name, diameter = 5000):\n",
    "        \"\"\"The initialization of my class.\n",
    "        This is a special method (function) that gets called every time you\n",
    "        create a new class.  Every method in a class has \"self\" as the first\n",
    "        parameter.  The additional parameters to __init__ are the class's\n",
    "        input parameters (in this case name and diameter).  You can set a\n",
    "        default value to each parameter (diameter has a default of 5000).\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.diameter = diameter\n",
    "        \n",
    "    def __str__(self):\n",
    "        s = \"This is {} with a diameter of {}\".format(self.name, self.diameter)\n",
    "        return s\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "This is Rubycon with a diameter of 10000"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Planet('Rubycon', 10000)\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "One of the most powerful features of OO-programming is inheritance.\n",
    "\n",
    "This means I can inherit features of class definitions in a so called `sub-class`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Mammal:\n",
    "    n_of_legs = 0\n",
    "    noise = None\n",
    "    \n",
    "    def make_noise(self):\n",
    "        print(self.noise)\n",
    "        \n",
    "class Dog(Mammal):\n",
    "    n_of_legs=4\n",
    "    noise = 'bark'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dog = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "dog.make_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Dog` class has inherited the method `make_noise` from the Mammal class, because we assume all mammals make some kind of noise.\n",
    "\n",
    "The Dog classes fixes the noise to the pre-defined noise and from now on, we would not have to deal with setting the noise anymore, because the Dog class `specizalized` it for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create and Use a Class Based on Planet (`derived from the Planet class`)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Now we want to create a class based on a Planet.  Our new class, Earth, will have all the data and methods of a planet plus any new data/methods for the Earth class.  Notice that \"Planet\" is in parenthesis.\n",
    "\n",
    "Also notice we've added new data to the class, self.oceanList and self.continentList. We have also added \"getter\" methods so we can retrieve the ocean and continent lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Earth(Planet):\n",
    "    def __init__(self):\n",
    "        \"\"\"  This is the initialization method for Earth.  This will run every time\n",
    "        an Earth is created.  Notice there are no input parameters.\n",
    "        \"\"\"\n",
    "        #  This is the initialization method for the mother class Planet. \n",
    "        # Notice we pass in \"Earth\" and \"12700\".\n",
    "        # Now every Earth will have the name \"Earth\" and a diameter of \"12700\".\n",
    "        super().__init__(\"Earth\", 12700)\n",
    "        print(\"THIS IS EARTH!\")\n",
    "        #  Here we are adding more variables (data).  These belong to Earth and\n",
    "        #  not Planet.  Again, the \"self\" in front of the variable allows us to\n",
    "        #  use these variables anywhere in this class.\n",
    "        self.oceans = [\"Pacific\", \"Atlantic\", \"Indian\", \"Southern\", \"Artic\"]\n",
    "        self.continents = [\"North America\", \"South America\", \"Antarctica\", \\\n",
    "                           \"Africa\", \"Europe\", \"Asia\", \"Australia\"]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Let's create Earth!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "THIS IS EARTH!\n"
     ]
    }
   ],
   "source": [
    "#  Create a new Earth\n",
    "earth = Earth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12700"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "earth.diameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "This is Earth with a diameter of 12700"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "earth"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Earth has more data and methods than just the basic Planet. We can get info about its oceans and continents!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ocean List:     ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Artic']\n",
      "Continent List: ['North America', 'South America', 'Antarctica', 'Africa', 'Europe', 'Asia', 'Australia']\n"
     ]
    }
   ],
   "source": [
    "#  Print the Earth's oceans list and continents list.  Note that calling the\n",
    "#  methods found in the Earth class look the same as calling methods found in\n",
    "#  the Planet class.\n",
    "print(\"Ocean List:    \", earth.oceans)\n",
    "print(\"Continent List:\", earth.continents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "earth.mass = 6e24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'continents': ['North America',\n",
       "  'South America',\n",
       "  'Antarctica',\n",
       "  'Africa',\n",
       "  'Europe',\n",
       "  'Asia',\n",
       "  'Australia'],\n",
       " 'diameter': 12700,\n",
       " 'mass': 6e+24,\n",
       " 'name': 'Earth',\n",
       " 'oceans': ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Artic']}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "earth.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [stable]",
   "language": "python",
   "name": "Python [stable]"
  },
  "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.5.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}