Python 3 for Cmput 455 Bootcamp/Refresher

Since Python is currently a popular teaching language, and this is a fourth year course, I expect most students to be familiar with many of the concepts discussed here. Please review this page as needed for coursework, and catch up on any concepts that do not look familiar.

Basics

Documentation on python.org
Install Python 3.
Run a program:
```
python3 filename.py
```
Run in interactive mode:
```
python3
```
or interactive mode with file loaded first:
```
python3 -i filename.py
```
Evaluate an expr and print the result:
```
print(expr)
```

Variables do not need to be declared, just used. They do have a type, which is automatically set from their use.

x=3
y='hi'
print(x+y)
    TypeError: unsupported operand type(s) for +: 'int' and 'str'
type(y)
    class 'str'
y=5   % type of y changes here.
type(y)
    class 'int'
print(x+y)
    8

Boolean values True and False. Notice the uppercase!

type(True)
    class 'bool'
type(true)
    NameError: name 'true' is not defined

Indentation is significant. Indentation errors are syntax errors.
# is used for comments.
```
# A comment.
```

Difference between equality test == and assignment =.

a=3
a==3
    True
b==3
    NameError: name 'b' is not defined

Assert statement. Use liberally to catch mistakes and unexpected code execution as early as possible. Express pre= and postconditions of your functions.
```
assert j == len(L) - 1.
```
def defines a function with name and argument(s).
```
def f(n):
  ...implementation of f...
```
Python passes function arguments by "object-reference". If this makes no sense to you, read stupidpythonideas or effbot.org or Rob Heaton. Slightly tricky question (from the first linked page): what does this code print?
```
def spam(eggs):
        eggs.append(1)
        eggs = [2, 3]

    ham = [0]
    spam(ham)
    print(ham)
```

Math, bit-fiddling

In Python3, for integer division (with truncation) use //. Example: 29//2 = 14, while 29/2 = 14.5 .
x << n, x left-shifted by n.
x >> n, x right-shifted by n.
n.bit_length() number of bits needed to represent integer n.

Sequences and Ranges

sequence data types
Slicing to efficiently access a range of elements in a sequence. E.g. a[2:5], a[:3], a[7:], a[:]
range statement:
```
range(100) 
```
generates all numbers 0, 1, ..., 99, and
```
range(10,20) 
```
generates 10, 11, ..., 19
Text strings are a type of sequence.

Lists

Lists are one popular type of sequence.

Create a list:
```
L = [10,2,3,2,1]
```
Lists are 0-indexed. L[i] gives element at index i.
```
print(L[0])
10
```
Built-in function len(L) computes length of list L. The indices of list elements range from 0 to len(L) - 1. Trying to access L[len(L)] is an error.
List can contain elements with different types:
```
L = [3,'a',5]
```
Python lists are really dynamically sized arrays. So indexing is O(1). But adding to front is slow.

List comprehensions for easy initialization:

squares = [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

List comprehension example, list-of-lists:
```
E = [[0 for j in range(n)] for i in range(m)] 
```
sets all E[i][j] = 0

Python Libraries

Standard library tutorial part 1, part 2 and reference.
NumPy library for scientific computing and NumPy array basics

deque, double-ended queue, used as first in - first out (FIFO) queue.

from collections import deque
q = deque()
q.append('A')
element = q.popleft()

Dictionary data structure for key-value pairs with O(1) access through hashing.

westernCanadaAdjList =  {  'BC': ['AB'],
                           'AB': ['BC', 'SK'],
                           'SK': ['AB', 'MB'],
                           'MB': ['SK']
                        }

OrderedDict when you need to iterate through dictionary in order. Normal dictionary is based on hashing, so order looks random.
Tuples. Useful when we deal with a fixed number of objects. For example, to return more than one thing from a function: return a, b, c returns a tuple (a, b, c).
Time complexity of Python dictionary operations (and many other algorithms).
NetworkX Powerful open source graph library for Python.

Measuring Time

To measure how much time some piece of code has used, time.process_time() is a simple way which is available in Python 3.3 and up. See the Python Documentation of the time module and an example of the use in the Tic Tac Toe solver code.

A different, more complex but also more convenient approach is to use the signal module. Example: initialize with

signal.signal(signal.SIGALRM, handler)

Then use it to throw an exception at timeout within a try - except block:

signal.alarm(timelimit)

See the documentation for details on signal, and which parts of that library are supported in which python versions. As always, if it is part of coursework, then make sure it works on the undergrad machines before using it.

Classes and Objects in Python

Tutorial on classes and objects in Python.
Object: state (member variables) plus methods (functions that operate on an object).
Class: defines how objects look like.

Initialization: set all member variables to well-defined initial state.

def __init__(self, ...optional arguments here...):
    ... initialization code here...

Example - defining a GoBoard class.

class GoBoard:
    def __init__(self, size):
        self.size = size
        self.moveNumber = 0

bd = GoBoard(19)
print(bd.size, bd.moveNumber)

Member variables are defined by their first use. Convention: In our code, we document all member variables at the beginning of the class.

class GoBoard:
    # size: the size of the board. An integer in range 2 %lt;= size %lt;= 19.
    # moveNumber: the number of moves (including pass moves) which 
    #     have been played

Encapsulation and data hiding: Full visibility by default. No clear separation of interface vs implementation, as e.g. in C++ with header files. Double underscore member variables and methods for hidden implementation.

Python Specialties

simultaneous assignment: uses old value of a on the right side:
```
a, b = b, a+b 
```
Anonymous variable: _ if not needed otherwise, e.g. for simple counting loops:
```
for _ in range(5)
```

Contents