Volume Number: 25
Issue Number: 05
Column Tag: Mac in the Shell

Mac in the Shell: Learning Python on the Mac: Classes

Building a Basic Class

by Edward Marczak

Last month, we covered conceptually what classes are, why they're useful and when you may use them. This was all done with no (real) code. None of the nitty-gritty. That's where we're headed this month. So, without further ado, let's get into some Python code!

Traditionally, defining a class is the mechanism that allows the code author to create a "factory" for churning out (instantiating) objects. Python is a little different in that everything is treated as an object whether you are aware of that fact or not. As we discussed last month, you use a class when you have a model in the real world that you'd like to follow. In his Road to Code column, Dave Dribin has been using shapes as objects. A single shape class can be used to model shapes from the real world: a square, a rectangle, etc. We're going to use a different example that's just as grounded in the real world: a bank account.

Before getting into the code, it's wise to plan out a class: what is it's structure? A class can hold instance variables and methods. An instance variable is simply a variable that is specific to a given class. Similarly, a method is a function that resides internal to a class, and can act on instance variables stored in a class.

What do we need to plan out our bank account class? Well, the account should have some method of identifying it - a name or number, perhaps. Since this is a small example, and we're not worried about name conflicts, and we don't want to treat people like a number, let's just go with name. That's one, actually two, instance variables: First Name and Last Name. The account will also have a balance, our third instance variable.

What actions do we need to take these variables? Focusing on the balance, we certainly need to deposit money. That's our first method! We'll also want to withdraw this money at some point, which will be our second method. Let's start modeling the class from here.

First things first: create a directory for this project. I'm using "Bank_Class", but you're free to call it what you wish. Inside that directory, I'm creating a file named "Bank_Class.py". Use vi, BBEdit or whichever plain text editor makes you most comfortable.

First thing is first; the magic shebang line:

#!/usr/bin/env python

As shown last month, classes always begin with the class keyword to define them:

class account:

and we said we need three instance variables: balance, first name and last name. We can define them here (but please read on as we're going to refine this!):

class account:
  balance = 0
  fname = ''
  lname = ''

From here, we can actually use this class:

acct = Account()  # Instantiate a new Account
print 'Account balance is', acct.balance
print 'Depositing $50'
acct.balance = acct.balance + 50
print 'Balance is now', acct.balance

Which yields the output:

Account balance is 0
Depositing $50
Balance is now 50

Now, just because we can doesn't mean that we should! This code will work, but it has a few holes. One large issue being that we don't have to assign a name to this account, and this is what we hoped to be our identifier. If there are actions we want to take, including assignment, every time we create an instance, we can define a constructor. A constructor is just another function (or, method). What makes it special is that it will run every time the class is instantiated. Defining a method named "__init__" creates a constructor (that's two underscores and the word 'init' followed by two underscores. Instead of the small tangled mess shown above, we can define the following:

class Account:
  def __init__(self, fn, ln):
    self.balance=0
    self.fname=fn
    self.lname=ln

Now when we instantiate the class, we can call it like this:

acct1 = Account('Bill', 'Smith')

This will create the account with a zero balance and assign the first name as "Bill" and the last name as "Smith". If we forget one or both parameters, the class will raise an error.

Python requires that there be an additional first parameter to a class method. While you could technically name it anything you like, it's canonically called self. The Python runtime will automatically supply the value for this parameter at runtime. The self parameter is an object reference used to pass instance values to the method. While you can call it anything you like, all of the Python documentation uses "self," along with, well, every Python author that I know or have seen. So, stick with the convention of "self." It'll help you, or anyone that needs to look at your code in the future.

Now that we can instantiate a new bank account, we'll want to act on it. We've already decided that we need at least two methods: deposit and withdraw. Add the methods to the class (remember the right indentation!):

class Account:
  def __init__(self, fn, ln):
    self.balance = 0
    self.fname = fn
    self.lname = ln
    
  def Deposit(self,amount):
    self.balance += amount
  
  def Withdraw(self, amount):
    self.balance -= amount

Now we can create a new account, deposit and withdraw money. (Note the use of the += and -= operators. This is simple shorthand for repeating the left-hand variable. x = x + 1 can become x += 1). Unlike the first version of this code shown above, we don't have to set the variables ourselves, but rather we use a method to do it for us:

acct = Account('Joan', 'Smith')    # Create new account
print "Acct1 Balance = ", acct1.balance
print "Depositing $50 to acct1"
acct1.Deposit(50)       # Note use of class method here
print "Acct1 Balance =", acct1.balance

Naturally, there are some holes with this. There are no sanity checks to see if there's any money in the account before we withdraw it, for one. That is an improvement left to the reader.

Well, the examples given thus far haven't done much to improve on traditional procedural programming. However, now that we have the structure in place, it's easy to go beyond that. Creating multiple accounts, for instance is as simple as an assignment:

acct1 = Account('Joan', 'Smith')
acct2 = account('Bob', 'Smith')

And we can perform discreet actions on each:

acct1.Deposit(50)
acct2.Deposit(1000)
print "Acct1 Balance =", acct1.balance
print "Acct2 Balance =", acct2.balance

You should be able to visualize a dictionary structure filled with accounts. Or, the ability to find a record in a database and loading the found record(s) into an Account class.

Between last month and this month - please ensure that you also understand the material presented last month, too! - you should have a pretty good idea what classes are, how they work, and how to start building your own. Next month, we'll get into some OS X-specific functionality of Python and build some useful classes.

Media of the month: http://www.facebook.com. Seriously. OK, pick any social network, but Facebook seems to be the biggest. And then go say hello to someone you miss.

Hope to see everyone at WWDC next month! See you in San Francisco!

Ed Marczak is the Executive Editor of MacTech Magazine. He lives in New York with his wife, two daughters and various pets. He has been involved with technology since Atari sucked him in, and has followed Apple since the Apple I days. He spends his days on the Mac team at Google, and free time with his family and/or playing music. Ed is the author of the Apple Training Series book, "Advanced System Administration v10.5," and has written for MacTech since 2004.