04 Introduction to Python IV — Modules and Objects

We are continuing from the previous lesson in the "work directory" ~/PHY494/04_python. We will use ipython and your text editor.

Re-using code is key to writing maintainable and correct code. We already learnt how to package code into functions. Now we learn how to package functions into modules.

We will also briefly talk about objects because everything in Python is an "object". Objects are a more general approach to "packaging code into re-usable units".

Modules

Modules (and packages) are "libraries" for Python code.

Create a file constants.py:

# constants.py

pi = 3.14159
h = 6.62606957e-34

Importing modules

We can import the file in the python interpreter with the import statement (note: constants.py must be in the same directory, check with %pwd and %ls)

import constants

two_pi = 2 * constants.pi
h_bar = constants.h / two_pi

print('h_bar:', h_bar)

Contents of a module are accessed with the "dot" operator, e.g, constants.pi.

Other ways to import:

# direct import
from constants import h, pi
h_bar = h / (2*pi)

# aliasing
import constants as c
h_bar = c.h / (2*c.pi)

Activity: Import and use your myfuncs module

In the previous lesson you created myfuncs.py, which contains three different functions. Now treat it as a module and import it and use the functions in the module.

You should be able to do use your functions in the following manner

y = myfuncs.heaviside(1000)
print(y)

t_boil = myfuncs.kelvin2celsius(373.15)
print(t_boil)

and get output

1.0
100.0

Standard Library and the Python Eco System

The Python Standard Library contains many useful packages/modules. They are always available. For example

import math

math.sin(math.pi)

Other packages that we are going to use

• numpy
• matplotlib
• scipy

Objects

Using functions is the most important way to write scientific code. The basic approach is to have blocks of code that take in data and return results; this is called procedural programming. But there is also another way in which data and functions are combined into something called an object, which leads to object oriented programming (OOP). An object contains data (held in variables that are called attributes) and it also contains functions (called methods) that know how to operate on the data in the object.

Python is an object oriented (OO) language and objects are everywhere — in fact everything is an object in Python.

Some Python objects

Even if you don't use object-oriented programming, you still need to know how to work with Python objects. We look at a few examples.

Each built-in type (int, float, str, …) is an object with associated methods and attributes.

Strings

The text sequence — or "string" — type str has lots of string methods:¹

>>> sentence = "may the force be with you!"

>>> sentence.capitalize()
'May the force be with you!'

>>> sentence.upper()
'MAY THE FORCE BE WITH YOU!'

>>> sentence.count("o")
2

>>> sentence.isdigit()
False

>>> sentence.replace("you", "us")
'may the force be with us!'

>>> sentence.split()
['may', 'the', 'force', 'be', 'with', 'you!']

Note that the string object itself contains all these methods:

>>> "may the force be with you!".upper()
'MAY THE FORCE BE WITH YOU!'

The output of many of these methods is again a string so one can easily concatenate or "chain" methods:

>>> sentence.replace("you", "us").title()
'May The Force Be With Us!'

If you are curious about other methods of an object such as the string sentences, use the TAB-completion in ipython on the object with a following period .:

sentence.<TAB>

This will show you all methods and attributes.

Activity: string methods

Given the sentence "MAY THE FORCE BE WITH YOU!"

1. test if it is lower case
2. make it lower case

Lists

The list type contains a large number of useful methods that allow one to manipulate the list. Typically, all operations are done "in place", i.e., they change the list itself.

>>> rebels = ["Luke", "Leia", "Han", "Chewie"]
>>> print(rebels)
['Luke', 'Leia', 'Han', 'Chewie']

>>> rebels.append("Lando")
>>> print(rebels)
['Luke', 'Leia', 'Han', 'Chewie', 'Lando']

>>> rebels.pop()
'Lando'
>>> print(rebels)
['Luke', 'Leia', 'Han', 'Chewie']

>>> rebels.remove("Han")
>>> print(rebels)
['Luke', 'Leia', 'Chewie']

>>> rebels.extend(["R2D2", "C3PO"])
>>> print(rebels)
['Luke', 'Leia', 'Chewie', 'R2D2', 'C3PO']

>>> rebels.reverse()
>>> print(rebels)
['C3PO', 'R2D2', 'Chewie', 'Leia', 'Luke']

>>> rebels.sort()
>>> print(rebels)
['C3PO', 'Chewie', 'Leia', 'Luke', 'R2D2']

>>> rebels.insert(2, "Han")
>>> print(rebels)
['C3PO', 'Chewie', 'Han', 'Leia', 'Luke', 'R2D2']

>>> rebels.clear()
>>> print(rebels)
[]

Creating objects: classes (advanced topic)

In Python one creates an object by first defining a class:²

import math

class Sphere:
   """A simple sphere."""
 
   def __init__(self, pos, radius=1):
       self.pos = tuple(pos)
       self.radius = float(radius)

   def volume(self):
       return 4/3 * math.pi * self.radius**3

   def translate(self, t):
       self.pos = tuple(xi + ti for xi, ti in zip(self.pos, t))

and then instantiating the object (creating an instance of the class)

ball = Sphere((0, 0, 10), radius=2)

Notes on the class definition above:

• __init__() is a special method that is called when the class is instantiated: it is used to populate the object with user-defined values.
• The first argument of each method (including __init__()) is always called self and refers to the class itself.
• So-called instance attributes are created with self.ATTRIBUTE_NAME, e.g., self.pos.
• Methods are defined just like ordinary Python functions except that the first argument is self.

In this example we created an object named ball, which is of type Sphere:

In [3]: type(ball)
Out[3]: __main__.Sphere

Attributes and Methods

Objects contain attributes (variables that are associated with the object) and methods (functions that are associated with the object). Attributes and methods are accessed with the "dot" operator. (Within the class definition, attributes and methods are also accessed with the dot-operator but the class itself is referred to as self — this is just the first argument in each method and you should always, always name it "self".)

In the example, pos and radius are attributes, and can be accessed as ball.pos and ball.radius. For instance, the Sphere object named ball has position

In [4]: ball.pos
Out[4]: (0, 0, 10)

In [5]: ball.radius
Out[5]: 2.0

because we provided the pos argument (0, 0, 10) on instantiation. Similarly, we created a ball with radius 2.

One can assign to these attributes as usual, e.g., directly change the position

In [6]: ball.pos = (-5, 0, 0)

In [7]: ball.pos
Out[7]: (-5, 0, 0)

The Sphere.volume() method computes the volume of the sphere:

In [8]: ball.volume()
Out[8]: 33.510321638291124

The Sphere.translate() method changes the position of the object by adding a translation vector t to Sphere.pos:

In [9]: ball.translate((5, 0, 0))

In [10]: ball.pos
Out[10]: (0, 0, 0)

Note that this method did not return any values but it changed the data in Sphere.pos.

Independence of instances

Each instance of a class is independent from the other instances. For example, ball and a new balloon can be moved independently even though we start them at the same position:

In [11]: ball = Sphere((0, 0, 10), radius=2)

In [12]: balloon = Sphere((0, 0, 10), radius=6)

In [13]: ball.pos = (-1, -1, 0)

In [14]: print(ball.pos, balloon.pos)
(-1, -1, 0) (0, 0, 10)

Inheritance

New classes can be built on existing classes in such a way that the new class contains the functionality of the existing class. This is called inheritance and is a very powerful way to organize large code bases.

Only a small example is given to illustrate the basic idea: We use our Sphere class to create planets. A planet is (almost) a sphere but it also has a name and a mass: The new Planet class inherits from Sphere by supplying Sphere as an argument to Planet:

class Planet(Sphere):
   def __init__(self, name, pos, mass, radius):
       self.name = str(name)
       self.pos = tuple(pos)
       self.mass = float(mass)
       self.radius = float(radius)

   def density(self):
       """Compute density of the planet"""
       return self.mass / self.volume()

# quantities from http://www.wolframalpha.com
# lengths in m and mass in kg
earth = Planet("Earth", (1.4959802296e11 , 0, 0), 5.9721986e24, 6371e3)
print(earth.density())

gives 5513 kg/m³ because the Planet class inherited the volume() method from Sphere.

Final comments on objects

For most of the class you will not need to work with classes, i.e., you do not have to design your programs in an object-oriented manner. However, everything is an object and we will constantly create objects and work with their methods and attributes. For example list.append() is a method of a list object. Even modules are objects and therefore you are using the dot operator to access its contents.

Tip: In ipython you can list all the attributes and methods of an object by typing the object's name, a dot, and then hitting the TAB key twice. TAB-completion together with the question mark (help) operator is how most programmers quickly learn about Python classes and objects.

Footnotes