Outline

• Python
• Quiz

Strings

• String literals can be enclosed in either single, double, or triple quotes:

  a = "Hello"
  b = 'Good "bye"'
  c = """ Triple quotes one can
  go over multiple lines
  """
  d = ''' this one
  works as well
  '''
  

• It is relatively easy to extract characters out of a string:

  a = "Hello World"
  b = a[4] # b is 'o'
  c = a[:5] # c is 'Hello'
  d = a[6:] # d is 'World'
  e = a[3:8] # e is "lo Wo" 
  

• Strings are concatenated using + .
• A string can be converted to a integer using int() and a float using float(). For example, int("79")
• The command str (for base types) and repr (for objects) can be used to convert other types into strings. For example, str(3.4).
• String's support a variety of useful methods such as split(sep) - split into list according to a separator, upper() - convert to upper case, lower() -- convert to lower case, isalpha - check if all the characters are alpha, isdigit -- check if all the characters are digits, etc.
• In addition, if you import the re module, you get several useful regular expression functions such as escape, match, search, split, sub.

Lists

• Lists can be declared using square brackets like:

  my_list = ['YO', 1.2, 7, "HI", ["scary nested list", "watch out!"]]
  my_empty_list = [] # or list()
  

• We can access parts of a list in a variety of ways:

  b = my_list[0] # b is now: 'YO'
  c = my_list[4][1] # c is now: 'watch out!'
  d = my_list[1:3] # d is [1.2, 7]
  e = my_list[2:] # e is [7, 'HI', ['scary nested list', 'watch out!']]
  

• Lists can also be easily manipulated to make new lists:

  my_list.append("an end") #my_list now 
      #['YO', 1.2, 7, 'HI', ['scary nested list', 'watch out!'], 'an end']
  my_list.insert(2, 3) # my_list now
      #['YO', 1.2, 3, 7, 'HI', ['scary nested list', 'watch out!'], 'an end']
  a = [1, 2, 3] + [4, 5] #a is [1, 2, 3, 4, 5]
  

Example Using Lists and Command Line

import sys
if(len(sys.argv)) != 2: 
   #notice sys.argv is a list of command-line args and we found its length
   print "Please supply a filename"
   raise SystemExit(1) # throw an error and exit
f = open(sys.argv[1]) #program name is argv[0]
lines = f.readlines() # reads all lines into list one go
f.close()

#convert inputs to list of ints
ivalues = [int(line) for line in lines]

# print min and max
print "The min is ", min(ivalues)
print "The max is", max(ivalues)

Example Files in a Folder as a List

import glob
path = './*'
files = glob.glob(path) 
for name in files:
   print name

Tuples

• You can pack a collection of objects into a single object in Python using a tuple

  a = ( 1, "hello", 3)
  b = ( some, where)
  c = "6 scared of 7", "as 7 8 9" #notice can omit paren's
  d = () # 0-tuple
  e = 'yo', #one tuple 
  f = ('yo',) #same one tuple
  g = (d,) # g is ((),)
  

• Can access parts of tuple with the same notation as lists a[1] gives 'hello' for instance. Or we can do things like:

  c = (4, 5)
  a, b = c
  

• Tuples cannot be appended or inserted to, but save memory. Tuples are immutable.

Sets

• A set is used to contain an unordered collection of objects.
• Sets can be created, viewed, and checked for membership using statements like:

  my_set = set([3, 9, 2, 6])
  another_set = set("goodness") # set of unique chars
  print another_set # set(['e', 'd', 'g', 'o', 'n', 's'])
  if 'e' in another_set:
      print "it's in there" 
  

• Sets support various operations:

  a = my_set; b = another_set;
  c = a | b # union of sets
  c = a & b # intersection of sets
  c = a - b # difference of sets
  c = a ^ b # symmetric difference of sets
  another_set.add('y') # adds a single element to set
  another_set.update([6,7,8]) # add multiple elements
  my_set.remove(3) # removes the number 3 from my_set 
  

• A frozenset is like a set but cannot be changed

Dictionaries

• Python's notion of an associative array (a table of key-value pairs) is called a dictionary.
• Dictionary literal make use of curly braces:

  person = {
      "name" : "bob",
      "age" : 27,
      "sex" : "Male"
  }
  empty_dict = {} #an empty dictionary # or use dict()
  

• We can access and modify elements of a dictionary with statements like:

  name= person["name"]
  person["age"] = 28
  person["address"] = "somewhere" #this would add a key-value pair
  del person["age"] # removes key value associated with 'age'
  

• Membership of a key in a dictionary can be tested with 'in':

  if "name" in person:
     name = person["name"]
  else:
     name = "no one"
  #the above conditional can be shortened to:
  name = person.get("name", "no one")
  

• Aside: Python has built in functions locals() and globals() and the syntax: x in locals() or x in globals() might be used to check if a variable is set.
• The list of keys in a dictionary can be gotten with:

  keys = list(person) #keys is ['address', 'name',  'sex'] 
  #could also do person.keys() 
  #person.values() would get list of values
  #person.len() gives the number of keys in dictionary
  

Iteration and Looping

• Python supports while loops like most languages:

  while condition:
      statement1
      statement2
      ...
  

• Python for loops always behave as a foreach over a sequence:

  for n in [1,2,3,4,5,6,7,8,9]:
      print "2 to the %d  is %d" % (n, 2**n)
  

• To make this less cumbersome, Python allows you to declare ranges such as range(1, 10):

  for n in range(1,10):
      print "2 to the %d  is %d" % (n, 2**n) # same as before
  

• The syntax for ranges is: range(start_inclusive, end_exclusive [, stride]):

  a = range(5) # can omit start to get a = 0, 1, 2, 3, 4
  b = range(1,8) # b = 1, 2, 3, 4, 5, 6, 7
  c = range(0, 13, 2) # c = 0, 2, 4, 6, 8, 10, 12
  d = range(7, 2, -1) # d = 7, 6, 5, 4, 3
  

• In Python 2, range actually creates a list which can be quite memory intensive for big ranges. If you didn't want a list but just something to iterate over you used xrange. In Python 3, xrange is no more and range() have the default behavior of xrange.

Examples of things can iterate over with for

• As we've seen in some of our earlier examples, for can be used with strings, lists, dictionaries, file objects, etc:

  a = "Get rich quick"
  for b in a:
      print b
  
  c = ["now", "I", "know"]
  for d in c:
      print c
  
  person = {
      "name" : "bob",
      "age" : 27,
      "sex" : "Male"
  }
  for key in person:
      print key, person[key]
  
  f = open("my_file.txt")
  for line in f
      print line
  

Quiz

Functions

• The keyword def is used to create functions in Python:

  def smaller_value( a, b):
     if a < b: return a # notice single line if can be same line
     else: return b
  

• Function invocation is similar to most languages:

  print smaller_value(8, 4)
  

• Functions can be recursive and are allowed to take as arguments and return tuples, lists, etc:

  def reverse_list(list):
      if list == []: return []
      return reverse_list(list[1:]) + [list[0]]
  print reverse_list([1, 2, 3, 4]) # prints [4, 3, 2, 1]
  
  def divide(a,b):
     q = a // b
     r = a - q*b
     return (q, r)
  quotient, remainder = divide(2373, 16)
  

• We can also supply default values to functions:

  def expify(a, b=2):
     return b**a #if don't give a second argument b will be 2
  

Function Scoping, Functions as Variables

• By default variables used in a function definition are local.

  i = 5
  def printi():
     i=4
     print i
  printi() # outputs 4
  print i #outputs 5
  #note without the i=4 assignment would get i=5
  

• To be able to modify a variable in global scope we must use the keyword global:

  def assign_i():
    global i
    i=3
  assign_i()
  print i #now get 3
  

• Function names can be treated as references to code in memory, so we can assign them to variables. i.e., We have function pointers and functions can be passed to other functions, etc:

  a = printi
  a() # prints 4
  

• Python also supports anonymous function definitions, functions as arguments, and functions returning functions:

  Consider:
  def f(x): return x**3
  f(10) #returns 1000
  
  g = lambda x: x**3 #notice don't use return with lambda
  g(10) #returns 1000 # lambda only works if  after : have an expression
  
  #we can supply a function as arguments to other functions
  def a(x):
      if x >= 0: return 1
      else: return 0;
  def threshold (w, x, activation) :
      l = len(x)
      inner = 0;
      for i in range(0, l):
         inner += w[i] * x[i]
      return activation(inner)
  w = [1, 2]
  x = [1, 0]
  threshold (w, x, a) # returns 1
  
  # we can also return functions from functions
  def make_adder (n): return lambda x: x + n
  f = make_adder(2)
  g = make_adder(6)
  print f(42), g(42)
  

• Anonymous function are often used to write "one-off" functions like callback handlers in GUI's and things.

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 computed attributes
      def length(self):
          return len(self.stack) 
      #(where an attribute is like a field) of a class
      # Can use dot notation with or without parentheses to invoke
      #@property is an example of a Python decorator which is a syntactic
      #which says this function object immediately after its definition should be
      #passed to the property() function to get additional features
  
  

• 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
  #type(my_instance) returns something containing the word 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. This is sometimes used to fake private members of classes.
• 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
  

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.
• For example,

  def fact(n):
      "This function computes a factorial" #can use triple quoted strings
      if(n <= 1): return 1
      else: return n * fact(n - 1)
  

• The documentation string of such an object is associated with its __doc__ property which can be printed, etc:

  print fact.__doc__
  

• Python has the built-in function help() which can be run from Python in interactive mode to get information about modules.
• For example, I could put the above fact code into a file test.py. Then in interpretative mode type:

  import test
  help(test.fact)
  

  This would go to a screen that prints the documentation string.
• Python also comes with a pydoc command that can also give documentation information. For example, at a Unix prompt (not in Python interpretative mode), I could type:

  pydoc test.fact
  

  and get the same result as help(test.fact) before