renamed intro notebook

00 - Introduction to Python for Algorithms 202.ipynb → 00-Introduction.ipynb

 %% Cell type:markdown id: tags:
 
-# Introduction to Python for Algorithms 202
+# Introduction to Python (for Algorithms 2)
 
 %% Cell type:markdown id: tags:
 
 by *James Booth* and *Ghislain Antony Vaillant*
 
 %% Cell type:markdown id: tags:
 
 ### Disclaimer
 
 %% Cell type:markdown id: tags:
 
 This notebook is by no means a comprehensive introduction to the Python programming language. It covers the essential language features required to implement, test and validate the Algorithms 202 courseworks. It is strongly advised to complement this tutorial with additional reading such as the [official Python documentation](https://docs.python.org/3/), [Python 101](https://leanpub.com/python_101) or the excellent [Hitchhiker's guide to Python](http://docs.python-guide.org/en/latest/).
 
 %% Cell type:markdown id: tags:
 
-### Getting set up
-
-%% Cell type:markdown id: tags:
-
-To use this notebook, you'll first need to install miniconda. To get set up you can follow the start of the [instructions given here for Windows, OS X, and Linux](http://www.menpo.org/installation/). Only go as far as 'Setting Up A Fresh Environment' then jump back here to install the stuff we need (not menpo).
-
-- Create a Python environment with all the code we need in it
-
-```
-> conda create -n algo202 python=3 pip setuptools wheel matplotlib jupyter
-```
-- Activate the environment. On OS X/Linux, simply run:
-```
-> source activate algo202
-```
-on Windows:
-```
-> activate algo202
-```
-- Finally install the line_profiler tool (you can read more about that at our [blog post](http://www.menpo.org/blog/2014/05/line_profiler_ipython/))
-```
-(algo202) > pip install line_profiler
-```
-- Now we are all set up. In the future you only need to reactivate the environment to get to work. To run this notebook, launch a Jupyter notebook server, and browse to this downloaded file
-```
-(algo202) > jupyter notebook
-```
-- To navigate through the notebook, have a look at this [cheatsheet](https://www.cheatography.com/weidadeyue/cheat-sheets/jupyter-notebook/)
-
-%% Cell type:markdown id: tags:
-
 ## Language basics
 
 %% Cell type:markdown id: tags:
 
 ### Syntax and features
 
 %% Cell type:markdown id: tags:
 
 #### Hello world
 
 %% Cell type:code id: tags:
 
 ``` python
 print("Hello, world!")
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Built-in [functions](https://docs.python.org/3/library/functions.html)
 
 %% Cell type:code id: tags:
 
 ``` python
 print("Hello, world!")
 print("Hello,", "world!")
 print("{}, {}!".format("Hello", "world"))
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 help(print)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 type(1.0)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 assert(2 % 2 == 0)
 #assert(2 / 2 == 0)
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Built-in [types](https://docs.python.org/3/library/stdtypes.html)
 
 %% Cell type:code id: tags:
 
 ``` python
 # Booleans
 B = True
 print(type(B))
 
 # Numeric types
 N = 1
 print(type(N))
 
 N = 1.0
 print(type(N))
 
 N = 1j
 print(type(N))
 
 # Strings
 N = "Hello, word"
 print(type(N))
 
 # Lists
 L = [False, 1.0, "Hello"]
 print(type(L))
 
 # Ranges
 R = range(10)
 print(type(R))
 
 # None
 print(type(None))
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Dynamic typing
 
 %% Cell type:code id: tags:
 
 ``` python
 x = 3  # Defines a binding a variable named "x",
        # to an object of type integer with value 3.
 print('x is of type {} with value {}'.format(type(x), x))
 
 x = 2.0  # Redefine the binding between "x" and an
          # object of type float with value 2.0.
 print('x is of type {} with value {}'.format(type(x), x))
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Strong typing
 
 %% Cell type:code id: tags:
 
 ``` python
 print(1 + '2')  # What is the intent here?
                 # "Explicit is better than implicit."
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 print(str(1) + '2')  # String concatenation.
 print(1 + int('2'))  # Integer summation.
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Variables and scopes
 
 %% Cell type:code id: tags:
 
 ``` python
 a = 0
 
 if False:
     b = 1
 
 def my_function(c):
     d = 3
     print(a)  # a is global
     print(b)  # b is global
     print(c)  # c is local
     print(d)  # d is local
 
 my_function(2)
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Control flow
 
 %% Cell type:markdown id: tags:
 
 #### `if` statements
 
 %% Cell type:code id: tags:
 
 ``` python
 # simple branching
 if condition:
     do_something()
 
 # 2-way branching
 if condition:
     do_something()
 else:
     do_other_thing()
 
 # switch-case style
 if condition:
     do_something()
 elif other_condition:
     do_other_thing()
 else:
     do_default_thing()
 ```
 
 %% Cell type:markdown id: tags:
 
 #### `while` statements
 
 %% Cell type:code id: tags:
 
 ``` python
 # loop until
 while condition:
     do_something()
 
 # loop until with break clause
 while condition:
     do_something()
     if specific_condition:
         break  # exit while loop regardless
     do_other_thing()
 
 # loop until with break clause
 while condition:
     do_something()
     if specific_condition:
         continue  # loop-back regardless
     do_other_thing()
 ```
 
 %% Cell type:markdown id: tags:
 
 #### `for` statements
 
 %% Cell type:code id: tags:
 
 ``` python
 for n in range(10):
     print(n)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 numbers = [1, 2, 3]
 for number in numbers:
     print(number)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 ingredients = ['carrots', 'leeks', 'potatoes']
 for index, ingredient in enumerate(ingredients):
     print(index, ingredient)
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Data structures
 
 %% Cell type:markdown id: tags:
 
 #### Common concepts
 
 %% Cell type:code id: tags:
 
 ``` python
 # literals
 vowels = ['a', 'e', 'i', 'o', 'u', 'y']
 print('vowels: {}'.format(vowels))
 
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # indexing
 print('the first vowel is: ' + vowels[0])
 print('the last vowel is: ' + vowels[-1])
 print('the second-to-last vowel is: ' + vowels[-2])
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # slicing
 print('first three: {}'.format(vowels[:3]))
 print('last two: {}'.format(vowels[-2:]))
 print('middle ones: {}'.format(vowels[1:-1]))
 print('one each two: {}'.format(vowels[::2]))
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # iteration
 for vowel in vowels:
     print(vowel.upper())
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # enumeration
 for index, vowel in enumerate(vowels):
     print("vowel {} is {}".format(1+index, vowel))
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Immutable sequences
 
 %% Cell type:code id: tags:
 
 ``` python
 vowels = ('a', 'e', 'i', 'o', 'u', 'y')
 print(type(vowels))
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 vowels[1] = 'b'
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Mutable sequences
 
 %% Cell type:code id: tags:
 
 ``` python
 vowels = ['a', 'e', 'i', 'o', 'u', 'y']
 print(type(vowels))
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 vowels[1] = 'b'
 print(vowels)
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Dictionaries
 
 %% Cell type:code id: tags:
 
 ``` python
 # build using literal construct: {k1: v1, k2:v2}
 D = {"one": 1,
      "two": 2,
      "three": 3}
 
 print('D: {}'.format(D))
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # indexing
 print(D["one"])
 print(D["two"])
 print(D["three"])
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # iterating
 for item in D.items():
     print(item)
 
 for key in D.keys():
     print(key)
 
 for value in D.values():
     print(value)
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Functions
 
 %% Cell type:code id: tags:
 
 ``` python
 # Standard definiton
 def my_function(arg1, arg2):
     # Do something with arg1, arg2
     # ...
     return result
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 # Lambda definition
 x_power_x = lambda x: x**x
 print(x_power_x(2))
 ```
 
 %% Cell type:markdown id: tags:
 
 ## Application: Complexity analysis of bubble sort
 
 %% Cell type:markdown id: tags:
 
 ### Implementation
 
 %% Cell type:code id: tags:
 
 ``` python
 def bubble_sort(L):
     """
     Sorts the input list inplace using a deterministic version of the bubble sort algorithm [1].
 
     [1] https://en.wikipedia.org/wiki/Bubble_sort
     """
     max_pass = len(L) - 1
     for pass_num in range(max_pass):
         for i in range(max_pass-pass_num):
             if L[i+1] < L[i]:
                 L[i], L[i+1] = L[i+1], L[i]
     return L
 
 
 def my_sorted(iterable):
     """
     Returns the sorted elements of the iterable as a list.
     """
     return bubble_sort(list(iterable))
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Unit testing
 
 %% Cell type:code id: tags:
 
 ``` python
 test_cases = [
     [3, 2, 1, 6, 5, 4],
     [6, 5, 4, 3, 2, 1],  # Worst case
     [1, 3, 2, 4, 6, 5],  # One pass required
 ]
 
 for case in test_cases:
     # Validate against built-in sorted
     #print(my_sorted(case), sorted(case))
     assert(my_sorted(case) == sorted(case))
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Complexity analysis
 
 %% Cell type:markdown id: tags:
 
 #### Data generation
 
 %% Cell type:code id: tags:
 
 ``` python
 from random import randint
 help(randint)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 randlist = lambda n: [randint(1e1, 1e6) for i in range(n)]
 print(randlist(10))
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Timing method
 
 %% Cell type:code id: tags:
 
 ``` python
 def timed(f, *args, **kwargs):
     from time import clock
     before = clock()
     result = f(*args, **kwargs)
     after = clock()
     return after-before
 
 # Collect enough time samples
 timings = [timed(my_sorted, case) for case in [randlist(6) for n in range(1000)]]
 
 from statistics import mean
 print("min = {}, max = {}, mean = {}".format(
     min(timings), max(timings), mean(timings)))
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Experiment
 
 %% Cell type:code id: tags:
 
 ``` python
-sizes = list(range(1, 1000, 100)) + list(range(1000, 10000, 500))
+sizes = list(range(1, 1000, 100)) + list(range(1000, 10000, 1000))
 timings = [timed(my_sorted, case) for case in [randlist(size) for size in sizes]]
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Plotting
 
 %% Cell type:code id: tags:
 
 ``` python
 %matplotlib inline
 import matplotlib.pyplot as plt
 # Uncomment for details about the plot function
 #help(plt.plot)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 plt.plot(sizes, timings, linewidth=4)
 plt.xlabel('size')
 plt.ylabel('time (s)')
 plt.xlim(0)
 plt.ylim(0)
 ```
 
 %% Cell type:markdown id: tags:
 
 #### Fitting
 
 %% Cell type:code id: tags:
 
 ``` python
 from numpy import polyfit
 # Uncomment for details about polyfit
 #help(polyfit)
 
 poly = polyfit(sizes, timings, deg=2)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 from numpy import polyval
 # Uncomment for details about polyval
 #help(polyval)
 
 fitted = polyval(poly, sizes)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 plt.plot(sizes, timings, '-', linewidth=4)
 plt.plot(sizes, fitted, '--', linewidth=4)
 plt.xlabel('size')
 plt.ylabel('time (s)')
 plt.xlim(0)
 plt.ylim(0)
 ```
 
 %% Cell type:markdown id: tags:
 
 ### Going further
 
 %% Cell type:markdown id: tags:
 
 - Provide an alternative implementation of bubble sort with the optimization tricks explained in the Wikipedia article.
 - Modify the `my_sorted` function to allow users to choose between the deterministic and the optimized implementations. By default, `my_sorted` should still be using the determinisitic version.
 - Run the experiment above with the optimized bubble sort implementation.
 - Compare the deterministic and optimized implementations with a plot.
 - Draw some conclusions from this analysis.