Lecture Overview

Continuing from last time, we are designing a program to simulate the planets and the movement of a space probe. To do so, we need to compute the gravitational field from each body which gives us the acceleration and from the acceleration use the equations of motion to compute the change in position and velocity. We decided to separate the design into objects: one object for each planet, one object for the probe, one object for the sun, and one object for the solar system to control everything. Each of these objects will be built from a template/class. Last time we wrote a method to compute the gravitational field and stuck it inside the Planet class. But that same method needs to be on the Sun object but we don't want to copy and paste the method into the Sun class, we want to reuse it.

Inheritance

Python inheritance is a way of doing so. First a simple example:

class Foo:
    def say_hello(self, name):
        print("Hello", name)

class Bar(Foo):
    def say_goodbye(self, name):
        print("Goodbye", name)


x = Foo()
x.say_hello("John")
y = Bar()
y.say_hello("Bob")
y.say_goodbye("Ann")

What happens is we say that Bar inherits from Foo. This means that all the methods and properties in the Foo class appear in the Bar class. Remember that classes are templates for creating objects. An object like y created from the Bar class will have as its initial methods and properties all the methods and properties from Foo and all the methods and properties from Bar. In this example there are just two methods. Note that calling x.say_goodbye("Dan") will produce an error, since x has no method named say_goodbye.

We use quite a bit of terminology to refer to this. All of the following mean the same thing and are used interchangeably: for some reason we can't decide on a single terminology.

• Bar inherits from Foo
• Bar is a derived class of Foo
• Bar is a child class of Foo
• Foo is the parent of Bar.
• Foo is the base class of Bar.

If two methods have the same name, the method in the child class wins out and will be the method that is used in the newly created object. (The other method is still around and there is a way to get at it, just not by calling it like a method.)

Solar System

The primary use of inheritance is to share methods. In our example, we will create a Body class that will have methods for computing the gravitational field and moving the body. The Planet, Sun, and Probe classes will all derive from Body. This way all objects created from these classes will have methods.

The code is day26-solarsystem.py. The locations and velocities are from NASA and the probe I use is Juno. The code contains the locations and velocities of these objects on October 26, 2015. The design is as follows.

• Body class:
  • Property mass for the mass in kilograms
  • Properties x, y, z, for position in kilometers
  • Properties vx, vy, vz for velocity in kilometers/second
  • Methods for computing gravitational field and moving the body
• Planet class:
  • inherits from Body
  • has a method to draw itself
  • Properties of name and color, for the color to draw
• Sun class:
  • inherits from Body
  • has no extra properties
  • has a method to draw itself
• Probe class:
  • inherits from Body
  • Property of name
  • has a method to draw itself
• SolarSystem class:
  • Property bodies which contains a list of all the objects in the solar system: the sun, planets, and probe
  • Has a method draw which draws the solar system by calling draw on each body
  • Has a method to compute the net gravitational field at a location
  • Has a method to update the position and velocity of all bodies by one timestep

One thing to point out is that once the objects are created they live by themselves with their properties and methods. For example, consider the list of bodies in the bodies property in the SolarSystem class. The objects in this list come from different classes, but they all have a draw method and all have the methods from the Body class, so when SolarSystem makes these calls, they will call whatever method is attached to the object. For example, the draw calls will go to different methods depending on which class the object came from.

Exercises

• Write a new class called Sentence with the following methods:
  • An __init__ method which takes a single parameter for a sentence as a string and stores this string in a property. Assume the sentence has no punctuation.
  • A get_sentence method which just returns the sentence as a string
  • A get_num_words method which returns the number of words in the sentence. Hint: split.
  • A capitalize method which modifies the property to make sure the first letter is capitalized. Nothing is returned. Hint: upper but only to the first character.
• Write a few tests of your Sentence class to show that it is working properly. Call each method a few times on a couple different sentences.