Commit Paul Ross's training examples to github

Author: burrowsa

Advanced/CoRoutine/CoRoutine.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+"""Write a co-routine that is sent words and maintains a sorted list of them.
+
+This generator can be used in the following way:
+
+g = keep_sorted()
+# Start the generator
+g.next()
+# Send stuff
+g.send('zzz')
+g.send('Hi there')
+# Use next to retrieve the list
+print 'Sorted list is {0:s}'.format(g.next())    
+g.close()
+
+Created on Sep 12, 2011
+
+@author: paulross
+"""
+
+__author__  = 'Paul Ross'
+__date__    = '2011-09-12'
+__version__ = '0.1.0'
+__rights__  = 'Copyright (c) 2011 Paul Ross. Copyright (c) 2015 AHL.'
+
+def keep_sorted():
+    """A co-routine that receives words and maintains a sorted list of them.
+    """ 
+    l = []
+    while True:
+        v = yield l
+        if v is not None:
+            # This is a simple but not very efficient way of maintaining the
+            # sort. A more efficient way would be to use bisect to insert the
+            # word in the place that maintains the sort
+            l.append(v)
+            l.sort()
+
+
+if __name__ == '__main__':
+    g = keep_sorted()
+    # Start the generator
+    g.next()
+    # Send stuff
+    print g.send('zzz')
+    print g.send('Hi there')
+    print 'Sorted list is {0:s}'.format(g.next())    
+    g.close()

Advanced/CoRoutine/__init__.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+"""Write a co-routine that is sent words and maintains a sorted list of them.
+
+This generator can be used in the following way:
+
+g = keep_sorted()
+# Start the generator
+g.next()
+# Send stuff
+g.send('zzz')
+g.send('Hi there')
+# Use next to retrieve the list
+print 'Sorted list is {0:s}'.format(g.next())    
+g.close()
+
+Created on Sep 12, 2011
+
+@author: paulross
+"""
+
+__author__  = 'Paul Ross'
+__date__    = '2011-09-12'
+__version__ = '0.1.0'
+__rights__  = 'Copyright (c) 2011 Paul Ross. Copyright (c) 2015 AHL.'
+
+def keep_sorted():
+    """A co-routine that receives words and maintains a sorted list of them.
+    """ 
+    l = []
+    while True:
+        v = yield l
+        if v is not None:
+            # This is a simple but not very efficient way of maintaining the
+            # sort. A more efficient way would be to use bisect to insert the
+            # word in the place that maintains the sort
+            l.append(v)
+            l.sort()
+
+
+if __name__ == '__main__':
+    g = keep_sorted()
+    # Start the generator
+    g.next()
+    # Send stuff
+    print g.send('zzz')
+    print g.send('Hi there')
+    print 'Sorted list is {0:s}'.format(g.next())    
+    g.close()

Advanced/CoRoutine/solution/CoRoutine.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+"""Write a decorator that makes sure that only a particular type of exception is
+raised by the function.
+The trick here is to catch all exceptions then if any exception is raised
+convert it to the type of exception that we want to raise.
+
+Complete the decorator raises() below.
+
+Created on Sep 21, 2011
+
+@author: paulross
+"""
+
+__author__  = 'Paul Ross'
+__date__    = '2011-08-03'
+__version__ = '0.1.0'
+__rights__  = 'Copyright (c) 2011 Paul Ross. Copyright (c) 2015 AHL.'
+
+import functools
+
+def raises(exception_cls):
+    """Wraps a function ensuring only one type of exception is raises."""
+    def wrap(fnIN, *args,**kwargs):
+        @functools.wraps(fnIN)
+        def wrap_func(*args, **kwargs):
+            """Wrapping function with exception translation."""
+            # Save and delete the following line and use it in your own code
+            fnIN(*args,**kwargs)
+        return wrap_func 
+    return wrap
+
+# Right and wrong exceptions
+class RightException(Exception): pass
+class WrongException(Exception): pass
+
+
+@raises(RightException)
+def functionOne():
+    """Documentation for functionOne, this may raise an WrongException."""
+    raise WrongException('Raising an WrongException (originally)')
+
+
+def main():
+    try:
+        functionOne()
+    except RightException as err:
+        print('Success! caught an RightException exception: "{0:s}"'.format(str(err)))
+    except WrongException as err:
+        print('FAILURE! caught an WrongException exception: "{0:s}"'.format(str(err)))
+
+if __name__ == '__main__':
+    main()

Advanced/CoRoutine/solution/__init__.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+"""Write a decorator that makes sure that only a particular type of exception is
+raised by the function.
+The trick here is to catch all exceptions then if any exception is raised
+convert it to the type of exception that we want to raise.
+
+Complete the decorator raises() below.
+
+Created on Sep 21, 2011
+
+@author: paulross
+"""
+
+__author__  = 'Paul Ross'
+__date__    = '2011-08-03'
+__version__ = '0.1.0'
+__rights__  = 'Copyright (c) 2011 Paul Ross. Copyright (c) 2015 AHL.'
+
+import functools
+
+def raises(exception_cls):
+    """Wraps a function ensuring only one type of exception is raises."""
+    def wrap(fnIN, *args,**kwargs):
+        @functools.wraps(fnIN)
+        def wrap_func(*args, **kwargs):
+            """Wrapping function with exception translation."""
+            # Save and delete the following line and use it in your own code
+            # fnIN(*args,**kwargs)
+            try:
+                return fnIN(*args,**kwargs)
+            except Exception as err:
+                raise exception_cls(str(err))
+        return wrap_func 
+    return wrap
+
+# Right and wrong exceptions
+class RightException(Exception): pass
+class WrongException(Exception): pass
+
+
+@raises(RightException)
+def functionOne():
+    """Documentation for functionOne, this may raise an WrongException."""
+    raise WrongException('Raising an WrongException (originally)')
+
+
+def main():
+    try:
+        functionOne()
+    except RightException as err:
+        print('Success! caught an RightException exception: "{0:s}"'.format(str(err)))
+    except WrongException as err:
+        print('FAILURE! caught an WrongException exception: "{0:s}"'.format(str(err)))
+
+if __name__ == '__main__':
+    main()

Advanced/ExceptionDecorator/Decorators.py

@@ -0,0 +1,146 @@
+"""Given the text for Romeo and Juliet can you predict which actor is next to speak?
+
+There is a fair amount of code here that I have prepared for you:
+play.py is the play text itself.
+result.py keeps track of how well your strategy works.
+parser.py reads this into Python data structures.
+romeo_and_juliet.py (this file) that you can modify.
+
+Creating a strategy:
+---------------------
+main() will pass you a Play() object that contains the play contents. Your job
+is to create a result.Result() object then iterate throught the acts and scenes.
+For each scene, given the information that you have available pass your best
+guess to the result.Result() object by calling guess(actor).
+That will check and record whether your guess was a good one and returns the
+actual actor who will speak next at this stage of the scene (None at the end
+of the scene). You are free to use this information, but remember the scene
+has moved on!
+
+At the end of the play return your result and it will be printed out to see
+how accurate you were:
+ 
+Here is an example where we always guess 'ROMEO':
+
+def strat_empty(play):
+    ret_val = result.Result()
+    for act in play.gen_acts():
+        for scene in act.gen_scenes():
+            ret_val.set_act_scene(act, scene)
+            while True:
+                #--------- Your code starts here ------
+                # What are you going to choose?
+                my_choice = 'ROMEO'
+                #--------- Your code ends here ------
+                actual_actor = ret_val.guess(my_choice)
+                if actual_actor is None:
+                    break
+    return ret_val
+
+This produces the following score:
+
+Empty strategy (always ROMEO):
+ Act Scene     Good      Bad Accuracy
+   1     1     16.0     79.0     16.8%
+   1     2     11.0     18.0     37.9%
+   1     3      0.0     29.0      0.0%
+   1     4     13.0     15.0     46.4%
+   1     5     10.0     44.0     18.5%
+   2     1      1.0      9.0     10.0%
+   2     2     26.0     29.0     47.3%
+   2     3      9.0     10.0     47.4%
+   2     4     27.0     65.0     29.3%
+   2     5      0.0     19.0      0.0%
+   2     6      2.0      7.0     22.2%
+   3     1     11.0     49.0     18.3%
+   3     2      0.0     23.0      0.0%
+   3     3     16.0     22.0     42.1%
+   3     4      0.0      8.0      0.0%
+   3     5      7.0     61.0     10.3%
+   4     1      0.0     33.0      0.0%
+   4     2      0.0     18.0      0.0%
+   4     3      0.0      5.0      0.0%
+   4     4      0.0     11.0      0.0%
+   4     5      0.0     48.0      0.0%
+   5     1      8.0      7.0     53.3%
+   5     2      0.0      8.0      0.0%
+   5     3      6.0     59.0      9.2%
+              163.0    676.0     19.4%
+              
+Hmmm 19.4 %, can you do better?
+
+There is one other example here which just guesses at random with predictably
+poor results.
+
+Maybe a strategy that guesses the last but one actor betting that the scene is
+ROMEO/JULIET/ROMEO/JULIET/ROMEO/JULIET/ etc. Code it up!
+
+Create your strategy by copying strat_empty(), rename it and add the call from
+main(). Then add your strategy code where you see fit but don't alter the flow
+of act/scene/actor or alter the lines that create result, initialise the result
+for a new scene and passes your guess to the result.
+
+Created on 18 Mar 2015
+
+@author: paulross
+"""
+import random
+
+from Exercises.RomeoAndJuliet.util import parser
+from Exercises.RomeoAndJuliet.util import result
+
+
+#----------------- Strategies ----------------
+
+def strat_empty(play):
+    """You can copy and modify this strategy."""
+    ret_val = result.Result()
+    for act in play.gen_acts():
+        for scene in act.gen_scenes():
+            ret_val.set_act_scene(act, scene)
+            while True:
+                #--------- Your code starts here ------
+                # What are you going to choose?
+                my_choice = 'ROMEO'
+                #--------- Your code ends here ------
+                actual_actor = ret_val.guess(my_choice)
+                if actual_actor is None:
+                    break
+    return ret_val
+
+
+def strat_random_all(play):
+    """Just guess a random actor."""
+    ret_val = result.Result()
+    # Get all the actors, we are going to guess one randomly
+    all_actors = play.dramatis_personae.keys()
+    # Iterate through the acts
+    for act in play.gen_acts():
+        # Iterate through the scenes
+        for scene in act.gen_scenes():
+            # Prepare the results object for this act/scene
+            ret_val.set_act_scene(act, scene)
+            # Iterate through the actors in the scene
+            while True:
+                my_choice = random.choice(all_actors)
+                actual_actor = ret_val.guess(my_choice)
+                # If the actual actor is None it is the end of the scene
+                if actual_actor is None:
+                    break
+    return ret_val
+
+
+def main():
+    play = parser.get_play()
+    print 'Empty strategy (always ROMEO):'
+    result = strat_empty(play)
+    print result
+    print
+    print 'Random in play:'
+    result = strat_random_all(play)
+    print result
+    print
+
+if __name__ == '__main__':
+    main()
+    print 'Bye, bye!'