Introduction

On Monday, we were learning about Python, the language we are going to code our AI projects in this semester.
So far, we've talked about using interactive mode, running Python from files, expressions, assignments, conditionals, looping, I/O, File I/O, strings, lists, tuples, sets, dictionaries, and functions.
Today, we are going to start by talking some specialized kinds of ways to return from functions, and then talk about objects and classes in Python and finish up the rest of our brief introduction to Python.

Generators

We can generate sequences one element at a time using the yield construct:

def countdown(n):
    while n > 0:
       yield n
       n -=1
c = countdown(5)
print c.next() #prints 5
print c.next() #prints 4
print c.next() #prints 3

The next() method runs to the next yield statement

Here's how we could get a function which monitors a log file and returns lines as they appear:

import time
def tail_log(f):
    f.seek(0, 2) # 2nd arg: 0 means start of file, 1 means current pos, 2 means end of file
    while True:
        line = f.readline()
        if not line:
            time.sleep(0.1) # sleep 1/10 of a second
            continue
        yield line

Coroutines

Generators are functions which output a sequence of values when their next() method is called
One can imagine the opposite situation where a function receives a sequence of values one at a time and computes something.

Such a function is called a coroutine and can also be defined using yield:

def print_matches(text):
    print "Trying to find", text
    while True:
        line = (yield)
        if text in line:
            print line
p = print_matches("hello")
p. next()  #prints 'Trying to find hello'
p.send("lalalala la") #doesn't print anything
p.send("hello world") #prints hello world

Objects and Classes

We have already seen that lists, dicts, etc are objects and we can invoke methods on them much as we do in other languages. For instance, my_list.append("hello")

Given an object we can see its methods by calling dir(my_obj). For example, a=[]; dir(a); gives:

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', 
'__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
'__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', 
'__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', 
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', 
'__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', 
'__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 
'remove', 'reverse', 'sort']

You can see append in the list. Special methods such as operator overloads have '__' around them. For example, __add__ in the above corresponds to the + operator. We can actually use the + operator in a cumbersome way as: a.__add__([1, 2]).
If you were writing your own class overriding __add__ would give you operator overloading of "+" for operations of the form my_obj + something_else. To override something_else + my_obj you would need to implement __radd__. To override += use overrider __iadd__, etc.
__init__ represents the constructor.

To define new classes we using the keyword class. For example,

class Stack(object): #this says stack inherits from object
    a_class_variable = 5 # this var behaves like a Java static var
    def __init__(self): #self = this in Java
        self.stack = [] #now stack is a field variable of Stack
        #in general using self.field_var is how we declare and 
        #instantiate a instance variable
    def push(self, object): #the first argument of any method 
        self.stack.append(object) # is the object itself
    def pop(self):
        return self.stack.pop()
    @property #properties are attributes that computes its value when accessed
    def length(self):
        return len(self.stack)

To instantiate an instance of this class and use it one could do:

my_instance = Stack()
my_instance.push("hello")
print my_instance.length
print isinstance(my_instance, object) #returns True
print issubclass(Stack, object) #returns True
print type(my_instance) # returns <class '__main__.Stack'>
...
#etc

Inheritance, static methods, abstract classes.

Stack above is almost identical to the built-in list object except for the push method. We could have instead inherited from list using:

class Stack(list):
    def push(self, object):
        #could refer to parent by using syntax list.some_method_of_list
        #or use super(list, self).some_method_of_list
        self.append(object)

Python supports multiple inheritance: class MyClass(A, B, ...):
We can use the super mechanism to distinguish between parent members. Python also uses name mangling on methods beginning with "__". The method __foo in class A would be mangled to _A__foo and so would be different from a __foo in class B.

Static methods of classes can be created and used using the syntax:

class MyClass:
   @staticmethod
   def my_method():
      #some code

MyClass.my_method() #similar to Java

Similarly, abstract methods and properties can be declared as:

#load in abstract class module
from abc import ABCMeta, abstractmethod, abstractproperty
class MyClass:
    __metaclass__ = ABCMeta # a metaclass is a class object that knows how to
                            # create other class objects. The default metaclass
                            # is type (Python 3, types.ClassType in Python 2). 
                            # Here we are assigning ABCMeta
                            # to be used rather than type
                            # In Python 3, write MyClass(metaclass=ABCmeta)
    @abstractmethod
    def my_abstract_method(self):
       pass
    @abstractproperty
    def my_abstract_property(self):
       pass

Tic-tac-toe Board Example

Here is another example of creating and using a class:

class Board:
    def __init__(self):
        self.board = ["...", "...", "..."]
    def add(self, player_piece, x, y):
        if player_piece != "x" and player_piece != "o":
            raise RuntimeError("Piece must be x or o")
        row = ""
        for i in range(3):
            if i == y:
                row += player_piece
            else:
                row += self.board[x][i]
        self.board[x] = row
    def draw(self):
        for i in range(3):
            print self.board[i]

b = Board()
b.add("x", 1, 1)
b.draw()
print
b.add("o", 0, 1)
b.draw()

In-Class Exercise

Create a subclass of the Board class of the previous slide with a new method movePiece(self, x1, y1, x2, y2) which takes whatever the square is at location `(x1, y1)` and replaces the square at `(x2, y2)` with that value, then write a '.' at location `(x1, y1)` on the board. After your class definition, writes a few lines to test out your code.

Post your solutions to the Sep 13 In-Class Exercise Thread.

Exceptions

Like Java, Python has a syntax for exception handling, try-except-finally statements, which have the following syntax:

    try:
        statement_block_0
    except SomeError1 as error_name1:
        statement_block_1 #executed if a SomeError1 occurs
    except SomeError2 as error_name2:
        statement_block_2
    ...
    finally:
        statement_block_n # always gets executed

For example,

    try:
      f = open("file.txt", "r")
    except IOError as e:
      print e

To signal an exception you use the raise keyword:

    raise RuntimeError("Something bad just happened")

You define new exceptions by extending exception:

class MyException(exception): pass

#now could use as:
raise MyException("Whoa! A MyException occurred!")

#more control can be had by overriding __init__
#here we define an exception taking two arguments
class MyException2(exception):
    def __init__(self, errno, msg):
        self.args = (errno, msg)
        self.errno = errno
        self.errmsg = msg

raise MyException2(403, "Access Forbidden")

An exception block for FooError will also respond to any subclasses of FooError

Modules

Typically, when you code larger projects you split them into several files.
If you want to use code in one file in another file in Python you use import.
For example, in one file div.py you might have a collection of functions about division. This would be your module.

To use this module in another file, you could put:

import div #notice not div.py
a, b = div.divide(198, 15) #notice function in div.py have to be prefixed with div.

What if we want to use a different prefix then div? We could do:
```
import div as foo #now foo is the prefix
```

What if we don't want to keep writing div.some_function ?

from div import divide #from div import *; would import all functions
print divide(198, 15)

Modules can be bundled together in so-called packages. Basically, if you put all the files of a module bob in a directory, foo. Then foo would act as a package name and we'd refer to the module bob as foo.bob. To work as a package, foo has to have a special file __init__.py, which may be empty, used to mark the folder as a package. I won't say more about packages unless we really need it.

Documentation Strings and Help

The first statement of a module, class or function definition can be a string called a documentation string.