title: Why does the print statement at the bottom of my main method not print anything?
body: <p>I'm working on the MIT open courseware for CS-600 and I can't figure out why the last print statement isn't printing anything. Here's the code I wrote:</p>
  
  <pre><code>#!/usr/bin/env python
  # encoding: utf-8
  # 6.00 Problem Set 9
  #
  # Name:
  # Collaborators:
  # Time:
  
  from string import *
  
  class Shape(object):
      def area(self):
          raise AttributeException("Subclasses should override this method.")
  
  class Square(Shape):
      def __init__(self, h):
          """
          h: length of side of the square
          """
          self.side = float(h)
      def area(self):
          """
          Returns area of the square
          """
          return self.side**2
      def __str__(self):
          return 'Square with side ' + str(self.side)
      def __eq__(self, other):
          """
          Two squares are equal if they have the same dimension.
          other: object to check for equality
          """
          return type(other) == Square and self.side == other.side
  
  class Circle(Shape):
      def __init__(self, radius):
          """
          radius: radius of the circle
          """
          self.radius = float(radius)
      def area(self):
          """
          Returns approximate area of the circle
          """
          return 3.14159*(self.radius**2)
      def __str__(self):
          return 'Circle with radius ' + str(self.radius)
      def __eq__(self, other):
          """
          Two circles are equal if they have the same radius.
          other: object to check for equality
          """
          return type(other) == Circle and self.radius == other.radius
  
  #
  # Problem 1: Create the Triangle class
  #
  ## TO DO: Implement the `Triangle` class, which also extends `Shape`.
  
  class Triangle(Shape):
      def __init__(self, base, height):
          self.base = float(base)
          self.height = float(height)
      def area(self):
          return self.base*self.height/2
      def __str__(self):
          return 'Triangle with base ' + str(self.base) + 'and height ' + str(self.height)
      def __eq__(self, other):
          return type(other) == Triangle and self.base == other.base and self.height == other.height
  #
  # Problem 2: Create the ShapeSet class
  #
  ## TO DO: Fill in the following code skeleton according to the
  ##    specifications.
  
  class ShapeSet(object):
      def __init__(self):
          """
          Initialize any needed variables
          """
          self.allCircles = []
          self.allSquares = []
          self.allTriangles = []
          self.allShapes = self.allCircles + self.allSquares + self.allTriangles
          self.place = None 
      def addShape(self, sh):
          """
          Add shape sh to the set; no two shapes in the set may be
          identical
          sh: shape to be added
          """
          if not isinstance(sh, Shape): raise TypeError('not a shape')
          if isinstance(sh, Square):
              for sq in self.allSquares:
                  if sh == sq:
                      raise ValueError('shape already in the set')
              self.allSquares.append(sh)
          if isinstance(sh, Triangle):
              for tri in self.allTriangles:
                  if sh == tri:
                      raise ValueError('shape already in the set')
              self.allTriangles.append(sh)
          if isinstance(sh, Circle):
              for circ in self.allCircles:
                  if sh == circ:
                      raise ValueError('shape already in the set')
              self.allCircles.append(sh)
      def __iter__(self):
          """
          Return an iterator that allows you to iterate over the set of
          shapes, one shape at a time
          """
          self.place = 0
          return self
      def next(self):
          if self.place &gt;= len(self.allShapes):
              raise StopIteration
          self.place += 1
          return self.allShapes[self.place - 1]
  
      def __str__(self):
          """
          Return the string representation for a set, which consists of
          the string representation of each shape, categorized by type
          (circles, then squares, then triangles)
          """
          shapeList = ""
          for item in self.allShapes:
              shapeList += item.get__str__ + "br/"
          return shapeList
  
  #
  # Problem 3: Find the largest shapes in a ShapeSet
  #
  def findLargest(shapes):
      """
      Returns a tuple containing the elements of ShapeSet with the
         largest area.
      shapes: ShapeSet
      """
      ## TO DO
  
  #
  # Problem 4: Read shapes from a file into a ShapeSet
  #
  def readShapesFromFile(filename):
      """
      Retrieves shape information from the given file.
      Creates and returns a ShapeSet with the shapes found.
      filename: string
      """
      ## TO DO
  
  def main():
      sq1 = Square(4.0)
      sq2 = Square(5.0)
      sq3 = Square(3.0)
      circ1 = Circle(3.0)
      circ2 = Circle(3.2)
      tri1 = Triangle(3.0, 4.0)
      tri2 = Triangle(4.0, 3.0)
      tri3 = Triangle(1.0, 1.0)
      thisSet = ShapeSet()
      thisSet.addShape(sq1)
      thisSet.addShape(sq2)
      thisSet.addShape(sq3)
      thisSet.addShape(circ1)
      thisSet.addShape(circ2)
      thisSet.addShape(tri1)
      thisSet.addShape(tri2)
      thisSet.addShape(tri3)
      print thisSet
  
  
  
  if __name__ == '__main__':
      main()
  </code></pre>