Python Foundation – A programmer's introduction to Python concepts & style

Python Foundation
A programmer's introduction to
Python concepts & style

course = {
'title':
'Python Foundation',
'chapters': [
'Introduction',
'History, Culture & Style',
'Multi-Paradigm Programming',
'Syntax & Mechanics',
'Logic & Flow',
'Strings',
'Functions',
'Built-in Containers',
'Iteration',
'Classes & Objects',
'Outroduction',
'Labs & Homework'
],
...
}

course = {
...
'licence':
('Creative Commons Attribution 4.0, '
'https://creativecommons.org/licenses/by/4.0/'),
'contributors': [
'Kevlin Henney, kevlin@curbralan.com',
'Olve Maudal, olvmauda@cisco.com'
],
'date': '2015-11-05'
}

Introduction
Begin at the beginning...

Course goals
 Introduce the Python 3 language
 Some existing experience of Python
assumed, but detailed knowledge is not
 Programming skill in at least one other
language is also assumed
 Explore the structures, mechanics and
common idioms of the language
 Through slides, discussion and hands-on
experiments and labs

Coding experiments
 Small interactive experiments to try out
and explore language features
 Use the IDLE environment, the default
python shell or any available interactive
Python environment of your choice!
 Some experiments are described in the
slides, but others may be suggested
 You can carry out experiments
individually or in pairs

Programming labs
 Labs implemented using Cyber-Dojo
 http://cyber-dojo.org/
 Labs involve writing both code and tests
 Labs are undertaken in pairs
 But pairing is not marriage — you will
move around
 Oh, and there's homework too
 Individual rather than paired, and not in
Cyber-Dojo

Questions, answers & intros
 The best way to have your questions
answered is to ask them
 Mindreading is not (yet) supported
 And now, please introduce yourself!
 Briefly...

History, Culture & Style
Versions, PEPs & Zen

Facts at a glance
 Python is a general-purpose, multi-
paradigm dynamic OO language
 Python was first publicly released by
Guido van Rossum in 1991
 It exists in a number of versions,
including CPython 2.7.x and 3.4.x
 Familiarity with Monty Python's Flying
Circus can help

Versions & implementations
 CPython is reference implementation
 Open source and managed by the Python
Software Foundation
 The Python Enhancement Proposal (PEP)
process guides development
 Alternative and platform-specific
implementations and subsets also exist
 E.g., PyPy, IronPython for .NET and Jython
for JVM

Python 2 versus Python 3
 Python 3 dates from 2008 and breaks
compatibility with Python 2
 Based on experience, it simplifies and
regularises many aspects of the language
 Python 2 dates from 2000 and
continues to evolve
 Large installed base of Python 2 means
transition to Python 3 is not always simple
 Incompatible changes will be marked 🐍

Time travel
 Use forward-compatible styles and
features when working with Python 2
 Unask Python 3 incompatibility questions
 It is also possible to import some
features "from the future"
 Some Python 3 features usable in Python 2
from __future__ import print_function
from __future__ import division
Python 2: print is a keyword
Python 3: print is a function
Python 2: / is operand dependent
Python 3: / is true division
// is integer division in both

Python's type system
 Python is dynamically typed
 All values and expressions have a type,
but there is no declared type system
 Polymorphism is based on duck typing
 Python is object oriented
 Everything, including functions and built-in
primitive values, is an object
 Encapsulation style is façade-like rather
than strict

Objects
Objects are Python’s abstraction for data. All data in a Python
program is represented by objects or by relations between
objects. (In a sense, and in conformance to Von Neumann’s
model of a “stored program computer,” code is also
represented by objects.)
Every object has an identity, a type and a value. An object’s
identity never changes once it has been created; you may
think of it as the object’s address in memory. The is operator
compares the identity of two objects; the id() function
returns an integer representing its identity.
The Python Language Reference: 3.1 Objects, values and types
https://docs.python.org/3/reference/datamodel.html#objects-values-and-types

Pythonic style
 Pythonic style is typically terse and
expressive
 But not necessarily cryptic
 Python programming style is multi-
paradigm in nature
 Encouraged style is idiomatically more
functional than procedural
 Ranges in use from its original role in
scripting to application programming

Libraries
 One of Python's greatest strengths is
size and scope of its standard library
 It takes a batteries included approach
 Another is the size and scope of other
open-source libraries written in Python
 See PyPI, the Python Package Index:
https://pypi.python.org
 pip is the de facto and (as of Python 3.4)
the default package manager

PEP 8
 PEP 8 is a style guide for Python
 Offers guidance on accepted convention,
and when to follow and when to break
with convention
 Focuses mostly on layout and naming
 But there is also programming guidance
 PEP 8 conformance can be checked
automatically
 E.g., http://pep8online.com/, pep8, flake8

PEP 8 highlights
A style guide is about consistency.
Consistency with this style guide
is important. Consistency within a
project is more important.
Consistency within one module or
function is most important.
Use 4 spaces per indentation level.
Limit all lines to a maximum
of 79 characters.
Class names should normally
use the CapWords convention.
Function names should be lowercase,
with words separated by underscores
as necessary to improve readability.
Use is not operator rather than not ... is.
Use string methods instead
of the string module.
https://www.python.org/dev/peps/pep-0008/

The Zen of Python (PEP 20)
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>>

Useful links
Python
https://www.python.org/
https://docs.python.org/3/
https://docs.python.org/2/
https://www.python.org/dev/peps/
http://pep8online.com/
https://pypi.python.org/pypi
Monty Python
http://www.montypython.com/
http://en.wikipedia.org/wiki/Monty_Python
https://www.youtube.com/user/MontyPython

Multi-Paradigm
Programming
Procedural, modular, script,
OO & functional programming

Facts at a glance
 Although OO at its core, Python
supports multiple programming styles
 Python has the expected set of control
flow structures for most styles
 Each file in Python corresponds
properly to a module
 Pythonic style has many functional
programming aspects

Multi-paradigm programming
 The Python language is object oriented
 Everything is an object
 Python programming, on the other
hand, is multi-paradigm
 Supports a straight procedural style, a
modular approach, classic shell scripting,
functional programming and OOP
 The same problem can be solved and
expressed in different ways

Procedural programming
 Procedural programming is typically
characterised by...
 Sequential, conditional and repetitive
control flow
 Local and global variables with
assignment
 Top–down decomposition of named
procedures, i.e., functions
 Data passed as arguments

Basic control flow
if condition:
...
elif condition:
...
else:
...
while condition:
...
else:
...
for variable in sequence:
...
else:
...
try:
...
except exception:
...
else:
...
finally:
...
pass
No-op
Multiway conditional
Exception handling
Condition-based loop
Value-based loop

Functions
 Functions are the workhorses of Python
 Can be called both with positional and
with keyword arguments
 Can be defined with default arguments
 Can return multiple values
def roots(value):
from math import sqrt
result = sqrt(value)
return result, -result
def is_at_origin(x, y):
return x == y == 0
first, second = roots(4) is_at_origin(0, 1)

Variables
 A variable holds an object reference
 A variable is a name for an object within a
scope
 None is a reference to nothing
 A variable is created in the current
scope on first assignment to its name
 It's a runtime error if an unbound variable
is referenced
 Note that assignments are statements

Scope
 Variables are introduced in the
smallest enclosing scope
 Parameter names are local to their
corresponding construct (i.e., module,
function, lambda or comprehension)
 To assign to a global from within a
function, declare it global in the function
 Control-flow constructs, such as for, do not
define scopes
 del removes a name from a scope

Assignment
parrot = 'Dead'
Simple assignment
x = y = z = 0
Assignment of single value to multiple targets
lhs, rhs = rhs, lhs
Assignment of multiple values to multiple targets
counter += 1
Augmented assignment
world = 'Hello'
def farewell():
global world
world = 'Goodbye'
Global assignment from within a function

Modular programming
 A Python file corresponds to a module
 A program is composed of one or more
modules
 A module defines a namespace, e.g., for
function and class names
 A module's name defaults to the file
name without the .py suffix
 Module names should be short and in
lower case

Standard modules
 Python has an extensive library of
standard modules
 Much of going beyond the core language
is learning to navigate the library
https://docs.python.org/3/library/

import
 Names in another module are not
accessible unless imported
 A module is executed on first import
 Names beginning _ considered private
import sys
import sys as system
from sys import stdin
from sys import stdin, stdout
from sys import stdin as source
from sys import *
sys.stdin, ...
system.stdin, ...
stdin
stdin, stdout
source
stdin, ...
Import Imported
Discouraged

__name__ & dir
 A module's name is held in a module-
level variable called __name__
 A module's contents can be listed
using the built-in dir function
 Note that dir can also be used to list
attributes on any object, not just modules
import sys
print(sys.__name__, 'contains', dir(sys))
print(__name__, 'contains', dir())

The '__main__' module
 A module's name is set to '__main__'
when it is the root of control
 I.e., when run as a script
 A module's name is unchanged on import
...
def main():
...
if __name__ == '__main__':
main()
A common idiom is to
define a main function to
be called when a module is
used as '__main__'

Shell scripting
 Shell scripting often characterised by...
 Argument handling
 Console and file I/O
 File and directory manipulation
 String-based operations
#!/usr/bin/env python3
import sys
print(' '.join(sys.argv))
Program arguments available
as list of strings, where
argv[0] is the script name
The appropriate shebang line
for Unix and Unix-like
operating systems

Basic I/O
 I/O defaults to stdin and stdout
 input optionally shows a prompt and
returns a string result
 print supports output of one or more
values (not necessarily strings)
print('We are the {} who say {}!'.format(what, say))
what = input('What are you? ')
say = input('What do you say? ')
print('We are the', what, 'who say', say + '!')
🐍

File I/O
 File handling is simple and uniform
 Files integrate easily with other constructs
 Always open files using with so that file
closing is automatic
import sys
if len(sys.argv) > 1:
for filename in sys.argv[1:]:
with open(filename) as file:
print(file.read())
else:
print(sys.stdin.read())
A slice of argv that ignores
the zeroth argument (the
script name)

Experiment
 Using os.listdir, write a simple script that
behaves like the Unix ls command
 Lists the contents of the current directory if
no arguments are supplied
 Lists the contents of the given directory if a
single argument is supplied
 Lists the contents of each directory for
multiple arguments, prefixing each listing
with the directory name

Functional programming
 Functional programming is based on...
 Functions as principal units of composition
 A declarative rather than imperative style,
emphasising data structure relations
 Functions executing without side-effects,
i.e., functions are pure functions
 Immutability, so querying state and
creating new state rather than updating it
 Lazy rather than eager access to values

Function application
leap_years = []
for year in years:
if is_leap_year(year):
leap_years.append(year)
leap_years = list(filter(is_leap_year, years))
Imperative list initialisation
Filtering
def is_leap_year(year):
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
years = range(1800, 2100)

Comprehensions
squares = []
for i in range(13):
squares.append(i**2)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]
squares = [i**2 for i in range(13)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]
Imperative list initialisation
List comprehension

OO programming
 Object orientation is founded on
encapsulation and polymorphism
 Encapsulation combines function and
data into a behavioural entity with identity
 Polymorphism supports uniform object use
across compatible object protocols
 Inheritance factors out common and
introduces hooks for polymorphism, but is
an auxiliary not essential feature of OO

Classes
 Python classes support a full OO
programming model
 Class- and instance-level methods
 Class- and instance-level attributes
 Multiple inheritance
class Point:
def __init__(self, x=0, y=0):
self.x, self.y = x, y
def is_at_origin(self):
return self.x == self.y == 0
Class statement introduces
name and any base classes
__init__ is automatically
invoked after object creation
Convention rather than
language dictates that the
current object is called self

Class instantiation
 Objects are instantiated by using a
class name as a function
 Providing any arguments expected by the
special __init__ function
 The self argument is provided implicitly
origin = Point()
print('Is at origin?', origin.is_at_origin())
unit = Point(1, 1)
print(unit.x, unit.y)

Ducks, types & polymorphism
When I see a bird that walks like a
duck and swims like a duck and
quacks like a duck, I call that bird
a duck.
James Whitcomb Riley
In other words, don't check whether it IS-a
duck: check whether it QUACKS-like-a duck,
WALKS-like-a duck, etc, etc, depending on
exactly what subset of duck-like behaviour you
need to play your language-games with.
Alex Martelli

Substitutable classes
class PolarPoint:
def __init__(self, r=0, theta=0):
self.__r, self.__theta = r, theta
def x(self):
from math import cos
return self.__r * cos(self.__theta)
def y(self):
from math import sin
return self.__r * sin(self.__theta)
def r(self):
return self.__r
def theta(self):
return self.__theta
class CartesianPoint:
self.__x, self.__y = x, y
def x(self):
return self.__x
def y(self):
return self.__y
def r(self):
return (self.__x**2 + self.__y**2)**0.5
def theta(self):
from math import atan
return atan(self.__y / self.__x)
Leading __ in identifier names
keeps them effectively private
Instances of PolarPoint and
instances of CartesianPoint
support the same method calls,
and are therefore substitutable
for one another — quack, quack

Syntax & Mechanics
Keywords, identifiers, spacing,
built-in types & more

Facts at a glance
 Python syntax is line oriented and
space sensitive rather than free format
 Python's built-in types include numeric
primitives and container types
 Integers hold arbitrary precision values
 Both floating-point and complex
numbers supported in the language
 Python has expected set of operators

Identifiers
 Identifiers are case-sensitive names for
source code entities
 E.g., functions, classes and variables
 Some identifier classes have reserved
meanings
_*
__*__
__*
_load_config
__init__
__cached_value
Class Example Meaning
Not imported by wildcard module imports —
a convention to indicate privacy in general
System-defined names, such as special
method names and system variables
Class-private names, so typically used to
name private attributes

Keywords
False
None
True
and
as
assert
break
class
continue
def
del
elif
else
except
finally
for
from
global
if
import
in
is
lambda
nonlocal
not
or
pass
raise
return
try
while
with
yield

Indentation
 Indentation is significant in Python and
is used to define block structure
 The suite is indented from the header
 Multiple statements can occur at same
level of indentation
response = input('Who are you? ')
if response == '':
print('Hello, World!')
else:
print('Hello, ' + response + '!')
print('Welcome to the machine...')

Spanning multiple lines
 A single statement can extend over
multiple lines
 Implicit continuation across unclosed
bracketing ((...), [...], {...})
 Forced continuation after at end of line
films = [
'The Holy Grail',
'The Life of Brian',
'The Meaning of Life'
]
total = amount +
tax

Compound statements
 It is possible to combine multiple
statements on a single line
 The semi-colon is a statement separator
 This is, however, strongly discouraged
if eggs: print('Egg'); print('Spam')
if eggs:
print('Egg')
print('Spam')
Possible
Preferred

Comments
 Code comments are introduced with #
 Line-based, i.e., but independent of
indentation (but advisable to do so)
 Shell-script friendly, i.e., #! as first line
 As in other languages, use sparingly
# This is a comment
if eggs: # This is also a comment
# This is an aligned comment
print('Egg')
# This is a (discouraged) comment

Built-in types are classes
 Python's built-in types are all classes,
with operators and methods
 E.g., integers, strings, lists and dictionaries
 Use type(value) to query a value's type
and dir(value) to query its attributes
 Most built-in types have a literal form
 E.g., 97 is an int, 'swallow' is a str, (4, 2) is a
tuple pair, [] is an empty list, {'parrot'} is a
set with a single value, {} is an empty dict

Common built-in types
object
bool False True
int 42 -97 0x2a
float 3.14159 3e8
complex 4+2j 9.7+2.3j 1j
str 'Nice' "Isn't it?" r'C:tmp' 'u0030'
bytes b'Its bark is worse than its byte'
bytearray
list [] [42, 'Forty two']
tuple () (42,) ('pair', 'pear')
range
dict {} {'Norway': 'Oslo', 'UK': 'London'}
set {15, 30, 40}
frozenset
🐍
🐍

Explicit type conversions
 You can use a type name to convert
an object of one type to another
 Assuming that some kind of conversion
exists from one type to the other
int('314')
str(314)
str([3, 1, 4])
list('314')
set([3, 1, 4, 1])
314
'314'
'[3, 1, 4]'
['3', '1', '4']
{1, 3, 4}

Integers
 The int type offers arbitrary precision
 Not limited to machine word size
 It supports the usual operators
 But / results in a float,
so use // if integer
division is needed
42
-273
0b101010
0o1232
0xffff

Floating-point numbers
 Python float typically offers better than
32-bit precision
 Maps to platform double-precision type
 It supports the usual operators
 But also supports
integer division
and modulo
operator
3e8
-273.15
.5
float('NaN')
float('-Infinity')

Further numeric operations
abs(value) Absolute value
bin(integer) String of number in binary
divmod(dividend, divisor) Integer division and remainder
float(string) Floating-point number from string
hex(integer) String of number in hexadecimal
int(string) Integer from decimal number
int(string, base) Integer from number in base
oct(integer) String of number in octal
pow(value, exponent) value ** exponent
round(value) Round to integer
round(value, places) Round to places decimal places
str(value) String form of number (decimal)
sum(values) Sum sequence (e.g., list) of values
sum(values, initial) Sum sequence from initial start

Numeric & bitwise operators
+ Addition
- Subtraction
* Multiplication
** Power
/ Division
// Integer division
% Modulo
+ Unary plus
- Unary minus
~ Bitwise complement
<< Bitwise left shift
>> Bitwise right shirt
& Bitwise and
| Bitwise or
^ Bitwise xor
Binary arithmetic operators
Unary arithmetic operators
Bitwise operators
🐍

Comparison & logic operators
in Membership
not in Non-membership
is Identical
is not Non-identical
== Equality
!= Inequality
< Less than
<= Less than or equal to
> Greater than
>= Greater than or equal to
and Logical and
or Logical or
not Negation
if else Conditional (ternary) operator
Relational
Identity
Membership and containment
Boolean
Conditional

Augmented assignments
 Augmented assignment forms exist for
each binary operator
 Like regular assignment, augmented
assignments are statements not
expressions
 Cannot be chained
and can only have
a single target
 There is no ++ or --
+= /= <<=
-= //= >>=
*= %= &=
**= |=
^=

Logic & Flow
From the conditional to the
exceptional

Facts at a glance
 Logic is not based on a strict Boolean
type, but there is a bool type
 The and, or and if else operators are
partially evaluating
 There is no switch/case — use if
 Exception handling is similar to that in
other languages
 with simplifies safe resource usage

What is truth?
 Boolean logic works with many types
 Use bool as a function to convert a value
to its corresponding canonical Boolean
False
None
0
0.0
''
b''
[]
{}
()
True
Non-null references and not otherwise false
Non-zero numbers
Non-empty strings
Non-empty containers
Other empty containers with
non-literal empty forms are also
considered false.

and & or
 The logical operators and and or are
partially evaluating
 I.e., they do not evaluate their right-hand
operand if they do not need to
 They return the last evaluated operand,
without any conversion to bool
'Hello' and 'World'
'Hello' or 'World'
[] and [3, 1, 4]
{42, 97} or {42}
{0} and {1} or [2]
'World'
'Hello'
[]
{42, 97}
{1}

Chained comparisons
 Comparisons can be combined
without using an intermediate and
 The short-circuiting evaluation is the
same, i.e., if the first comparison is false,
no further evaluation occurs
minimum < value < maximum
'' != selection in options
minimum < value and value < maximum
'' != selection and selection in options
Brief form...
Equivalent to...

if else operator
 The conditional operator has a very
different syntax to the if statement
 There is no header–suite delineation, as
for statements
 The else is mandatory
 There is no elif
user = input('Who are you? ')
user = user.title() if user else 'Guest'

Exception handling
 An exception is a signal (with data) to
discontinue a control path
 A raised exception propagates until
handled by an except in a caller
prompt = ('What is the airspeed velocity '
'of an unladen swallow? ')
try:
response = input(prompt)
except:
response = ''

Exceptions
 Exceptions are normally used to signal
error or other undesirable events
 But this is not always the case, e.g.,
StopIteration is used by iterators to signal
the end of iteration
 Exceptions are objects and their type
is defined in a class hierarchy
 The root of the hierarchy is BaseException
 But yours should derive from Exception

Catching exceptions by type
 Exceptions can be handled by type
 except statements are tried in turn until
there is a base or direct match
try:
...
except ZeroDivisionError:
...
except ArithmeticError:
...
except:
...
The most specific exception
type: ZeroDivisionError
derives from ArithmeticError
The most general match
handles any remaining
exceptions, but is not
recommended

Accessing an exception
 A handled exception can be bound to
a variable
 The variable is bound only for the duration
of the handler, and is not accessible after
try:
...
except ZeroDivisionError as byZero:
...
except ArithmeticError:
...
except Exception as other:
...
byZero is only
accessible here

One handler, many types
 It is possible to define an except
handler that matches different types
 A handler variable can also be assigned
try:
...
except (ZeroDivisionError, OverflowError):
...
except (EOFError, OSError) as external:
...
except Exception as other:
...
🐍

Raising exceptions
 A raise statement specifies a class or
an object as the exception to raise
 If it's a class name, an object instantiated
from that class is created and raised
raise Exception
raise Exception("I don't know that")
raise
raise Exception from caughtException
raise Exception from None
Re-raise current
handled exception
Raise a new
exception chained
from an existing
exception named
caughtException Raise a new exception ignoring
any previous exception

try else
 A try and except can be associated
with an else statement
 This is executed after the try if and only if
no exception was raise
try:
hal.open(pod_bay.doors())
except SorryDave:
airlock.open()
else:
pod_bay.park(pod)

try finally
 A finally statement is executed
whether an exception is raised or not
 Useful for factoring out common code
from try and except statements, such as
clean-up code
log = open('log.txt')
try:
print(log.read())
finally:
log.close()

Permissible try forms
try:
...
except:
...
try:
...
finally:
...
try:
...
except:
...
finally:
...
try:
...
except:
...
else:
...
try:
...
except:
...
else:
...
finally:
...
One or more except
handlers, but no
more than a single
finally or else
else cannot appear unless
it follows an except

with
 The with statement makes regular and
exception-safe clean-up simple
 A clean-up action is called automatically
whether or not an exception is raised
 Multiple objects can be specified
 Relies on __enter__ and __exit__ methods
with open('log.txt') as log:
print(log.read())
Recommended style
for using open

Exception guidelines
 Don't catch an exception unless you
know what to do with it
 And be suspicious if you do nothing with it
 Always use with for resource handling,
in particular file handling
 And don't bother checking whether a file
is open after you open it
 Use exceptions rather than error codes

for
 for iterates over a sequence of values
 Over containers — e.g., string, list, tuple,
set or dictionary — or other iterables
 Loop values are bound to one or more
target variables
machete = ['IV', 'V', 'II', 'III', 'VI']
for episode in machete:
print('Star Wars', episode)
for episode in 'IV', 'V', 'II', 'III', 'VI':
print('Star Wars', episode)

Iterating over a range
 It is common to use range to define a
number sequence to loop over
 A range is a first-class, built-in object and
doesn't allocate an actual list of numbers
for i in range(100):
if i % 2 == 0:
print(i)
for i in range(0, 100, 2):
print(i)
Iterate from 0 up to (but not
including) 100
Iterate from 0 up to (but not
including) 100 in steps of 2

How not to iterate containers
 Do not use a range-derived index to
index into lists and tuples
 Traverse the elements directly using for
 Only the keys will be iterated over if a
dictionary is the object of a for loop
 To iterate over the values or the key–value
pairs use a view, i.e., values or items — do
not iterate over the keys and look up the
corresponding value each time

Iterating over dictionaries
for code in airports:
print(code)
airports = {
'AMS': 'Schiphol',
'LHR': 'Heathrow',
'OSL': 'Oslo',
}
for code in airports.keys():
print(code)
for name in airports.values():
print(name)
for code, name in airports.items():
print(code, name)
Iterate over the keys
Iterate over the keys
Iterate over the values
Iterate over key–value pairs as tuples

Loop else statements
 Both while and for support optional
else statements
 It is executed if when the loop completes,
i.e., (mostly) equivalent to a statement
following the loop
for line in log:
if line.startswith('DEBUG'):
print(line, end='')
else:
print('*** End of log ***')

break & continue
 Both while and for support...
 Early loop exit using break, which
bypasses any loop else statement
 Early loop repeat using continue, which
execute else if nothing further to loop
for line in log:
if line.startswith('FATAL'):
print(line, end='')
break

assert
 The assert statement can be used to
check invariants in program code
 Can also be used for ad hoc testing
assert value is not None
if __debug__ and not (value is not None):
raise AssertionError
assert value is not None, 'Value missing'
if __debug__ and not (value is not None):
raise AssertionError('Value missing')
Equivalent to...
Equivalent to...

Strings
From string theory to string
practice

Facts at a glance
 Strings are immutable sequences
 There are many string literal forms
 Operations include comprehensive
support for indexing and slicing
 There are two supported approaches
to string formatting
 Strings are used for function, class and
module documentation

Of strings & bytes
 Strings are immutable
 Cannot be modified in place; if you want
a different string, use a different string
 The str type holds Unicode characters
 There is no type for single characters
 The bytes type is used for strings of
bytes, i.e., ASCII or Latin-1
 The bytearray type is used for modifiable
byte sequences

String literal forms
'Single-quoted string'
"Double-quoted string"
'String withnnewline'
'Unbroken
string'
r'n is an escape code'
'Pasted' ' ' 'string'
('Pasted'
' '
'string')
"""String with
newline"""
Single-quoted string
Double-quoted string
String with
newline
Unbroken string
n is an escape code
Pasted string
Pasted string
String with
newline
print(...) gives...

String operations
chr(codepoint)
len(string)
ord(character)
str(value)
first + second
string * repeat
repeat * string
String concatenation
lhs == rhs
lhs != rhs
lhs < rhs
lhs <= rhs
lhs > rhs
lhs >= rhs
String comparison
(lexicographical ordering)
substring in string
substring not in string
Substring containment
Built-in query functions

String indexing
 Strings can be indexed, which results
in a string of length 1
 As strings are immutable, a character can
be subscripted but assigned to
 Index 0 is the initial character
 Indexing past the end raises an exception
 Negative indexing goes through the
string in reverse
 I.e., -1 indexes the last character

String slicing
 It is possible to take a slice of a string
by specifying one or more of...
 A start position, which defaults to 0
 A non-inclusive end position (which may
be past the end, in which case the slice is
up to the end), which defaults to len
 A step, which defaults to 1
 With a step of 1, a slice is equivalent to
a simple substring

String indexing & slicing
string[index] General form of subscript operation
string[0] First character
string[len(string) – 1] Last character
string[–1] Last character
string[–len(string)] First character
string[first:last] Substring from first up to last
string[index:] Substring from index to end
string[:index] Substring from start up to index
string[:] Whole string
string[first:last:step] Slice from first to last in steps of step
string[::step] Slice of whole string in steps of step

Selection of string methods
string.join(strings) Join each element of strings with string
string.split() Split into a list based on spacing
string.split(separator) Split into a list based on separator
string.replace(old, new) Replace all occurrences of old with new
string.strip() Strip leading and trailing spaces
string.lower() All to lower case
string.upper() All to upper case
string.startswith(text) Whether starts with text substring
string.endswith(text) Whether ends with text substring
string.count(text) Number of occurrences of text
string.find(text) Index of first occurrence of text, or -1
string.index(text) Like find, but ValueError raised on fail
string.isalpha() True if all characters are alphabetic
string.isdecimal() True if all characters are decimal digits
string.islower() True if all characters are lower case
string.isupper() True if all characters are lower case

String formatting with format
 Strings support format, a method for
formatting multiple arguments
 Default-ordered, positional and named
parameter substitution are supported
'First {}, now {}!'.format('that', 'this')
'First {0}, now {1}!'.format('that', 'this')
'First {x}, now {y}!'.format(x='that', y='this')
Use {{ and }} to embed { and } in a string without format substitution

String formatting with %
 Strings also support a printf-like
approach to formatting
 The mini-language is based on C's printf,
plus some additional features
 Its use is often discouraged as it is error
prone for large formatting tasks
'First %s, now %s!' % ('that', 'this')
'First %(x)s, now %(y)s!' % {'x': 'that', 'y': 'this'}
'First %d, now %d!' % (1, 2)

Documentation strings
 The first statement of a function, class
or module can optionally be a string
 This docstring can be accessed via
__doc__ on the object and is used by IDEs
and the help function
 Conventionally, one or more complete
sentences enclosed in triple quotes
def echo(strings):
"""Prints space-adjoined sequence of strings."""
print(' '.join(strings))

Functions
Defining, calling & passing

Facts at a glance
 Functions are first-class objects
 Python supports lambda expressions
and nested function definitions
 Argument values can be defaulted
 Functions can take both positional
arguments and keyword arguments
 Functions can be defined to take an
arbitrary number of arguments

Functions as objects
 Functions can be passed as arguments
and can be used in assignment
 This supports many callback techniques
and functional programming idioms
 Conversely, any object that is callable
can be treated as a function
 callable is a built-in predicate function
 Functions always return a value
 None if nothing is returned explicity

Passing & calling functions
def does_nothing():
pass
assert callable(does_nothing)
assert does_nothing() is None
def is_even(number):
return number % 2 == 0
def print_if(values, predicate):
for value in values:
if predicate(value):
print(value)
print_if([2, 9, 9, 7, 9, 2, 4, 5, 8], is_even)
unsorted = ['Python', 'parrot']
print(sorted(unsorted, key=str.lower)) Keyword argument

Lambda expressions
 A lambda is simply an expression that
can be passed around for execution
 It can take zero or more arguments
 As it is an expression not a statement, this
can limit the applicability
 Lambdas are anonymous, but can be
assigned to variables
 But defining a one-line named function is
preferred over global lamba assignment

Lambdas expressed
def print_if(values, predicate):
for value in values:
if predicate(value):
print(value)
print_if(
[2, 9, 9, 7, 9, 2, 4, 5, 8],
lambda number: number % 2 == 0)
An ad hoc function that takes a single argument — in this case,
number — and evaluates to a single expression — in this case,
number % 2 == 0, i.e., whether the argument is even or not.

Experiment
 Create a dict mapping airport codes
to airport names
 Select 3 to 6 airports
 Use sorted to sort by...
 Airport code
 Airport name
 Longitude and/or latitude — either extend
the mapping from just names or introduce
an additional dict with positions

Nested functions
 Function definitions can be nested
 Each invocation is bound to its
surrounding scope, i.e., it's a closure
def logged_execution(action, output):
def log(message):
print(message, action.__name__, file=output)
log('About to execute')
try:
action()
log('Successfully executed')
except:
log('Failed to execute')
raise

Name access
world = 'Hello'
def outer_function():
def nested_function():
nonlocal world
world = 'Ho'
world = 'Hi'
print(world)
nested_function()
print(world)
outer_function()
print(world)
Hi
Ho
Hello
Refers to any world that will be
assigned in within outer_function,
but not the global world

Default arguments
 The defaults will be substituted for
corresponding missing arguments
 Non-defaulted arguments cannot follow
defaulted arguments in the definition
def line_length(x=0, y=0, z=0):
return (x**2 + y**2 + z**2)**0.5
line_length()
line_length(42)
line_length(3, 4)
line_length(1, 4, 8)

Defaults & evaluation
 Defaults evaluated once, on definition,
and held within the function object
 Avoid using mutable objects as defaults,
because any changes will persist
between function calls
 Avoid referring to other parameters in the
parameter list — this will either not work at
all or will appear to work, but using a
name from an outer scope

Arbitrary argument lists
 A function can be defined to take a
variable argument list
 Variadic arguments passed in as a tuple
 Variadic parameter declared using * after
any mandatory positional arguments
 This syntax also works in assignments
def mean(value, *values):
return sum(values, value) / (1 + len(values))

Unpacking argument lists
 To apply values from an iterable, e.g.,
a tuple, as arguments, unpack using *
 The iterable is expanded to become the
argument list at the point of call
def line_length(x, y, z):
return (x**2 + y**2 + z**2)**0.5
point = (2, 3, 6)
length = line_length(*point)

Keyword arguments
 Reduce the need for chained builder
calls and parameter objects
 Keep in mind that the argument names
form part of the function's public interface
 Arguments following a variadic parameter
are necessarily keyword arguments
def date(year, month, day):
return year, month, day
sputnik_1 = date(1957, 10, 4)
sputnik_1 = date(day=4, month=10, year=1957)

Arbitrary keyword arguments
 A function can be defined to receive
arbitrary keyword arguments
 These follow the specification of any other
parameters, including variadic
 Use ** to both specify and unpack
 Keyword arguments are passed in a
dict — a keyword becomes a key
 Except any keyword arguments that
already correspond to formal parameters

Positionals and keywords
def present(*listing, **header):
for tag, info in header.items():
print(tag + ': ' + info)
for item in listing:
print(item)
present(
'Mercury', 'Venus', 'Earth', 'Mars',
type='Terrestrial', star='Sol')
type: Terrestrial
star: Sol
Mercury
Venus
Earth
Mars

Annotations
 A function's parameters and its result
can be annotated with expressions
 No semantic effect, but are associated
with the function object as metadata,
typically for documentation purposes
def is_leap_year(year : 'Gregorian') -> bool:
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
is_leap_year.__annotations__
{'return': <class 'bool'>, 'year': 'Gregorian'}

Decorators
 A function definition may be wrapped
in decorator expressions
 A decorator is a function that transforms
the function it decorates
class List:
@staticmethod
def nil():
return []
@staticmethod
def cons(head, tail):
return [head] + tail
nil = List.nil()
[]
one = List.cons(1, nil)
[1]
two = List.cons(2, one)
[2, 1]

Built-in Containers
Sequences, sets & dictionaries

Facts at a glance
 range, tuple and list are sequence
types
 Sequence types hold values in an
indexable and sliceable order
 range, tuple and frozenset are
immutable containers
 set and frozenset hold unique values
 dict is a mutable mapping type

Iterable objects
 All container types — including range
and str — are iterable
 Can appear on right-hand side of in (for or
membership) or of a multiple assignment
 Except for text and range types,
containers are heterogeneous
first, second, third = [1, 2, 3]
head, *tail = range(10)
*most, last = 'Hello'

Container operations
len(container)
min(container)
max(container)
any(container)
all(container)
sorted(container)
lhs == rhs
lhs != rhs
Equality comparison
value in container
value not in container
Membership (key membership for mapping types)
Built-in queries and predicates
Returns sorted list of container's values
(also takes keyword arguments for key
comparison — key — and reverse
sorting — reverse)

Sequences
 A tuple is an immutable sequence
 Supports (negative) indexing, slicing,
concatenation and other operations
 A list is a mutable sequence
 It supports similar operations to a tuple,
but in addition it can be modified
 A range is an immutable sequence
 It supports indexing, slicing and other
operations

Immutable sequences
sequence.index(value)
sequence.count(value)
first + second
sequence * repeat
repeat * sequence
Concatenation (not for range)
lhs < rhs
lhs <= rhs
lhs > rhs
lhs >= rhs
Lexicographical ordering
(not for range)
sequence[index]
sequence[first:last]
sequence[index:]
sequence[:index]
sequence[:]
sequence[first:last:step]
sequence[::step]
Indexing and slicing
Search methods
Raises exception if value not found

Tuples
 Tuples are the default structure for
unpacking in multiple assignment
 The display form of tuple relies on
parentheses
 Thus it requires a special syntax case to
express a tuple of one item
x = 1,
x = 1, 2
x, y = 1, 2
x = 1, (2, 3)
x = (1,)
x = (1, 2)
(x, y) = (1, 2)
x = (1, (2, 3))

Lists
 As lists are mutable, assignment is
supported for their elements
 Augmented assignment on subscripted
elements
 Assignment to subscripted elements and
assignment through slices
 List slices and elements support del
 Removes them from the list

list extras
list[index]
list[index] = value
del list[index]
list[first:last:step]
list[first:last:step] = other
del list[first:last:step]
Index- and slice-based operations
list.append(value)
list.insert(index, value)
list.pop()
list.pop(index)
list.remove(value)
list.clear()
list.reverse()
list.sort()
Whole-list operations Element modification methods

Dictionaries
 dict is a mapping type
 I.e., it maps a key to a correspond value
 Keys, values and mappings are viewable
via keys, values and items methods
 Keys must be of immutable types
 This includes int, float, str, tuple, range and
frozenset, but excludes list, set and dict
 Immutable types are hashable (hash can
be called on them)

dict operations
key in dict
key not in dict
dict.get(key, default)
dict.get(key)
dict[key]
dict[key] = value
del dict[key]
Key-based operations
Equivalent to calling get with a default of None
Automagically creates entry if key not already in dict
dict.clear()
dict.pop(key)
dict.pop(key, default)
dict.get(key)
dict.get(key, default)
dict.update(other)
dict.keys()
dict.values()
dict.items()
Views
Manipulation methods

Sets
 set and frozenset both define
containers of unique hashable values
 set is mutable and has a display form —
note that set() is the empty set, not {}
 frozenset is immutable and can be
constructed from a set or other iterable
text = 'the cat sat on the mat'
words = frozenset(text.split())
print('different words used:', len(words))

set & frozenset operations
lhs < rhs
lhs <= rhs lhs.issubset(rhs)
lhs > rhs
lhs >= rhs lhs.issuperset(rhs)
lhs.isdisjoint(rhs)
Set relations (in addition to equality and set membership)
lhs | rhs lhs.union(rhs)
lhs & rhs lhs.intersection(rhs)
lhs – rhs lhs.difference(rhs)
lhs ^ rhs lhs.symmetric_difference(rhs)
Set combinations

set extras
lhs |= rhs lhs.update(rhs)
lhs &= rhs lhs.intersection_update(rhs)
lhs –= rhs lhs.difference_update(rhs)
lhs ^= rhs lhs.symmetric_difference_update(rhs)
Augmented assignment and updates
set.add(element)
set.remove(element)
set.discard(element)
set.clear()
set.pop()
Manipulation methods
Removes and returns
arbitrary element

Iteration
Iterables, comprehensions,
iterators & generators

Facts at a glance
 A number of functions eliminate the
need to many common loop patterns
 Functional programming tools reduce
many loops to simple expressions
 A comprehension creates a list, set or
dictionary without explicit looping
 Iterators and generators support a lazy
approach to handling series of values

Iteration
 The conventional approach to iterating
a series of values is to use for
 Iterating over one or more iterables
directly, as opposed to index-based loops
 However, part of the secret to good
iteration is... don't iterate explicitly
 Think more functionally — use functions
and other objects that set up or perform
the iteration for you

Being lazy (part 1)
 Be lazy by taking advantage of
functionality already available
 E.g., the min, max, sum, all, any and
sorted built-ins all apply to iterables
 Many common container-based looping
patterns are captured in the form of
container comprehensions
 Look at itertools and functools modules for
more possibilities

Being lazy (part 2)
 Be lazy by using abstractions that
evaluate their values on demand
 You don't need to resolve everything into
a list in order to use a series of values
 Iterators and generators let you create
objects that yield values in sequence
 An iterator is an object that iterates
 For some cases you can adapt existing
iteration functionality using the iter built-in

Enumerating iterable items
 Iterating a list without an index is
easy... but what if you need the index?
 Use enumerate to generate indexed pairs
from any iterable
codes = ['AMS', 'LHR', 'OSL']
for index, code in enumerate(codes, 1):
print(index, code)
1 AMS
2 LHR
3 OSL

Zipping iterables together
 Elements from multiple iterables can
be zipped into a single sequence
 Resulting iterator tuple-ises corresponding
values together
codes = ['AMS', 'LHR', 'OSL']
names = ['Schiphol', 'Heathrow', 'Oslo']
for airport in zip(codes, names):
print(airport)
airports = dict(zip(codes, names))

Mapping over iterables
 map applies a function to iterable
elements to produce a new iterable
 The given callable object needs to take
as many arguments as there are iterables
 The mapping is carried out on demand
and not at the point map is called
def histogram(data):
return map(lambda size: size * '#', map(len, data))
text = "I'm sorry Dave, I'm afraid I can't do that."
print('n'.join(histogram(text.split())))

Filtering iterable values
 filter includes only values that satisfy a
given predicate in its generated result
 If no predicate is provided — i.e., None —
the Boolean of each value is assumed
numbers = [42, 0, -273.15, 0.0, 97, 23, -1]
positive = filter(lambda value: value > 0, numbers)
non_zero = filter(None, numbers)
list(positive)
[42, 97, 23]
list(non_zero)
[42, -273.15, 97, 23, -1]

Comprehensions
 Comprehensions are expressions that
define value sequences declaratively
 Defined by intension as an expression,
rather than procedurally
 Comprehension syntax is used to create
lists, sets, dictionaries and generators
 Although the for and if keywords are
used, they have different implications
 Can read for as from and if as where

Filtering values (again)
 Prefer use of comprehensions over use
of map and filter
 But note that a list comprehension is fully
rather than lazily evaluated
numbers = [42, 0, -273.15, 0.0, 97, 23, -1]
positive = [value for value in numbers if value > 0]
non_zero = [value for value in numbers if value]
positive
[42, 97, 23]
non_zero
[42, -273.15, 97, 23, -1]

Container comprehensions
[i**2 for i in range(13)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]
{abs(i) for i in range(-10, 10)}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{i: i**2 for i in range(8)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49}
List comprehension
Set comprehension
Dictionary comprehension

One way to do it?
list(range(0, 100, 2))
list(range(100))[::2]
list(range(100)[::2])
list(map(lambda i: i * 2, range(50)))
list(filter(lambda i: i % 2 == 0, range(100)))
[i * 2 for i in range(50)]
[i for i in range(100) if i % 2 == 0]
[i for i in range(100)][::2]

Experiment
values = ['A'] + list(range(2, 11)) + ['J', 'Q', 'K']
suits = ['spades', 'hearts', 'diamonds', 'clubs']
[(value, suit) for suit in suits for value in values]
In what order do you expect the elements
in the comprehension to appear?

Experiment
 A Pythagorean triple is three integers
— a, b and c — such that a2 + b2 = c2
 E.g., (3, 4, 5) and (5, 12, 13) are
Pythagorean triples
 Write a comprehension to find
Pythagorean triples (up to some value)
 Try to ensure that triples occur once, i.e.,
(3, 4, 5) but not also (4, 3, 5), (5, 4, 3), etc.

Iterables & iterators
 An iterator is an object that supports
the __next__ method for traversal
 Invoked via the next built-in function
 An iterable is an object that returns an
iterator in support of __iter__ method
 Invoked via the iter built-in function
 Iterators are iterable, so the __iter__
method is an identity operation

Generators
 A generator is a comprehension that
results in an iterator object
 It does not result in a container of values
 Must be surrounded by parentheses
unless it is the sole argument of a function
(i * 2 for i in range(50))
(i for i in range(100) if i % 2 == 0)
sum(i * i for i in range(10))

Generator functions & yield
 You can write your own iterator classes
or, in many cases, just use a function
 On calling, a generator function returns an
iterator and behaves like a coroutine
def evens_up_to(limit):
for i in range(0, limit, 2):
yield i
for i in evens_up_to(100):
print(i)

Classes & Objects
Definition, instantiation & usage

Facts at a glance
 Object types are defined by classes
 Attributes are not strictly private
 Methods can be bound to instance or
class or be static
 Classes derive from one or more other
classes, with object as default base
 Classes and methods may be abstract
by convention or by decoration

Classes
 A class's suite is executed on definition
 Instance methods in a class must allow for
a self parameter, otherwise they cannot
be called on object instances
 Attributes are held internally within a dict
class Point:
self.x, self.y = x, y
return self.x == self.y == 0
By default all classes
inherit from object🐍

Object initialisation
 The special __init__ method is used to
initialise an object instance
 It is called automatically, if present
 A class name is callable, and its call
signature is based on __init__
 Introduce instance attributes by
assigning to them in __init__
 Can be problematic in practice to
introduce instance attributes elsewhere

Publicity & privacy
 Attribute and method names that
begin __ are considered private
 They are mangled with the class name,
e.g., __x in Point becomes _Point__x
 Other names publicly available as written
class Point:
self.__x, self.__y = x, y
return self.__x == self.__y == 0
__x and __y are mangled to
_Point__x and _Point__y
Within Point's methods
__x and __y are available
by their unmangled names

Attribute & method access
 Attributes and methods of an object
can be accessed using dot notation
 Access from outside is subject to name
mangling if the features are private
 Access within a method is unmangled
class Spam:
def __bacon(self):
return Spam()
def egg(self):
return self.__bacon()
Private method
Private method call

Class attributes
 A class attribute is defined as a
variable within the class statement
 Can be accessed as a variable of the
class using dot notation
 Can be accessed by methods via self
 Single occurrence shared by all instances
class Menu:
options = {'spam', 'egg', 'bacon', 'sausage'}
def order(self, *choice):
return set(choice) <= self.options

Class methods
 Class methods are bound to the class,
not just its instances
 They are decorated with @classmethod
 They take a class object, conventionally
named cls, as their first argument
 They can be overridden in derived classes
 They are also accessible, via self, within
instance methods

Derived breakfast
class Menu:
@classmethod
def options(cls):
return {'spam', 'egg', 'bacon', 'sausage'}
return set(choice) <= self.options()
class NonSpammyMenu(Menu):
@classmethod
def options(cls):
return {'beans', 'egg', 'bacon', 'sausage'}

Static methods
 Static methods are scoped within a
class but have no context argument
 I.e., neither a cls nor a self argument
 They are effectively global functions in
a class scope
class Menu:
@staticmethod
def options():
return {'spam', 'egg', 'bacon', 'sausage'}
return set(choice) <= self.options()

Methods versus functions
 Instance and class methods are
functions bound to their first argument
 A bound function is an object
 Method definitions are ordinary
function definitions
 Can be used as
functions, accessed
with dot notation from
the class
class Spam:
def egg(self):
pass
spam = Spam()
spam.egg()
Spam.egg(spam)

Inheritance
 A class can be derived from one or
more other classes
 By default, all classes inherit from object
 Method names are searched depth first
from left to right in the base class list
class Base:
pass
class Derived(Base):
pass
class Base(object):
pass
class Derived(Base):
pass
🐍

Inheritance & overriding
 Methods from the base classes are
inherited into the derived class
 No difference in how they are called
 They can be overridden simply by
defining a new method of the same name
 Inheritance is queryable feature of objects
isinstance(value, Class)
issubclass(Class1, Class2)

Abstract classes
 Abstract classes are more a matter of
convention than of language
 Python lacks the direct support found
found in statically typed languages
 There are two approaches...
 In place of declaring a method abstract,
define it to raise NotImplementedError
 Use the @abstractmethod decorator from
the abc module

Two abstract
class Command:
def execute(self):
raise NotImplementedError
from abc import ABCMeta
from abc import abstractmethod
class Command(metaclass=ABCMeta):
@abstractmethod
def execute(self):
pass
Instances of Command
can be instantiated, but
calls to execute will fail
Instances of Command
cannot be instantiated
— but ABCMeta must
be the metaclass for
@abstractmethod to be
used

Outroduction
What's done is done

The end?
 No, only a beginning
 There is more to the language and how to
use it effectively
 There is more to the library and how to use
it effectively
 There is more to the Python ecosystem
and how to use it effectively
 But it is a beginning
 Well done!

What next?
 Language...
 Namespaces, decorators, special
methods, generators, etc.
 Libraries...
 Both the extensive standard one and the
even more extensive non-standard ones
 Styles...
 Master Python's OO approach and its
support for functional programming

Guidance
 Labs should be undertaken in pairs
using Cyber-Dojo
 Swap between driving and navigator roles
within the same pair
 Homework is carried out individually in
your own environment
 Do not spend too much time on this — an
hour or so — and try not to overengineer
the solution!

Lab: Day 1
Yatzy
The game of Yatzy is a simple dice game. Each player rolls five six-sided
dice. The player places the roll in a category, such as Ones, Twos, Fives,
Pair, Two Pairs, etc.
If the roll is compatible with the category, the player gets a score for the roll
according to the rules. If the roll is not compatible with the category, the
player scores zero for the roll.
For example, if a player rolls 5, 6, 5, 5, 2 and scores the dice in the Fives
category they would score 15 (three fives).
Your task is to score a given roll in a given category.
You do not have to program the random dice rolling.
You do not have to program re-rolls (as in the real game).
You do not play by letting the computer choose the highest scoring
category for a given roll.

Lab: Day 1
Yatzy categories and scoring rules
Chance: The player scores the sum of all dice, no matter what they read.
E.g., 1, 1, 3, 3, 6 placed on Chance scores 14 (1+1+3+3+6); 4, 5, 5, 6, 1
placed on Chance scores 21 (4+5+5+6+1).
Yatzy: If all dice have the same number, the player scores 50 points. E.g.,
1, 1, 1, 1, 1 placed on Yatzy scores 50; 5, 5, 5, 5, 5 placed on Yatzy scores
50; 1, 1, 1, 2, 1 placed on Yatzy scores 0.
Ones, Twos, Threes, Fours, Fives, Sixes: The player scores the sum of the dice
that reads 1, 2, 3, 4, 5 or 6, respectively. E.g., 1, 1, 2, 4, 4 placed on Fours
scores 8 (4+4); 2, 3, 2, 5, 1 placed on Twos scores 4 (2+2); 3, 3, 3, 4, 5 placed
on Ones scores 0.
Pair: If exactly two dice have the same value, the player scores the sum of
the two highest matching dice. E.g., when placed on Pair: 3, 3, 3, 4, 4
scores 8 (4+4); 1, 1, 6, 2, 6 scores 12 (6+6); 3, 3, 3, 4, 1 scores 0; 3, 3, 3, 3, 1
scores 0.

Lab: Day 1
Yatzy categories and scoring rules (continued)
Two Pairs: If exactly two dice have the same value and exactly two dice
have a different value, the player scores the sum of these four dice. E.g.,
when placed on Two Pairs: 1, 1, 2, 3, 3 scores 8 (1+1+3+3); 1, 1, 2, 3, 4 scores
0; 1, 1, 2, 2, 2 scores 0.
Three of a Kind: If there are exactly three dice with the same number, the
player scores the sum of these dice. E.g., when placed on Three of a Kind:
3, 3, 3, 4, 5 scores 9 (3+3+3); 3, 3, 4, 5, 6 scores 0; 3, 3, 3, 3, 1 scores 0.
Four of a Kind: If there are exactly four dice with the same number the
player scores the sum of these dice. E.g., when placed on Four of a Kind:
2, 2, 2, 2, 5 scores 8 (2+2+2+2); 2, 2, 2, 5, 5 scores 0; 2, 2, 2, 2, 2 scores 0.
Small Straight: When placed on Small Straight, if the dice read 1, 2, 3, 4, 5,
the player scores 15 (the sum of all the dice).
Large Straight: When placed on Large Straight, if the dice read 2, 3, 4, 5, 6,
the player scores 20 (the sum of all the dice).
Full House: If the dice are two of a kind and three of a different kind, the
player scores the sum of all five dice. E.g., when placed on Full House:
1, 1, 2, 2, 2 scores 8 (1+1+2+2+2); 2, 2, 3, 3, 4 scores 0; 4, 4, 4, 4, 4 scores 0.

Homework
numgen — Phone number generator
Write a small command line tool that reads a data file (numgen.dat)
containing existing numbers, generate a new unique random 8-digit
number and add it to the data file. Consider also printing it out to the
console. If you give the program a numeric argument, it should append
that many new numbers to the data file.
It is important that the new numbers generated are unique, but also that
they are reachable: a number is unreachable if there exists another
number in the database that is a leading substring of the number. E.g., if
911 exists in the database, 91134345 would not be valid number to add
because when someone tries to dial the 8-digit number you will reach 911
first. You should assume that the order of numbers in the data file is
significant, so you should only append new numbers to it. A naïve, but
completely acceptable approach, is to iterate over every existing number
and make sure it is neither the same nor a leading substring of a candidate
number you have generated.
When you are done with the initial version, consider one of the options.
NB: You should find relevant info and code snippets in the Python
Codebook and https://docs.python.org/3/index.html.

Homework
Usage example
$ cat numgen.dat
911
112
999
45783349
56778856
$ python numgen.py
88533934
$ python numgen.py 4
65899323
89798871
01334908
73344345
$ cat numgen.dat
911
112
999
88533934
65899323
89798871
01334908
73344345

Homework
Option 1: Make numget more like a command-line utility
The next step is to use module argparse to parse the command line (see
documentation) and try to make it look like a professional and solid tool
that others might want to use. E.g., something like this:
$ python numgen.py
usage: numgen.py [-h] [-n] [n]
Create random, unique and reachable 8-digit phone numbers.
positional arguments:
n how many numbers to generate (default is 1)
optional arguments:
-h, --help show this help message and exit
-n, --dry-run do not actually update the database
--db file specify data file (default is numgen.dat)
If on a Unix-like environment, make it look and behave like a
Unix command: add #!/usr/bin/env python3 as first line in
your script, then make the file executable (chmod 0755
numgen.py) and remove the .py suffix (mv numgen.py numgen).

Homework
Option 2: Improve performance
How long does it take to execute numgen for 1000, 10000 and 100000 new
numbers?
How far can you improve the code so it runs faster? Experiment with
different techniques.
Option 3: Guarantee termination
What happens when the database fills up? If you ask to generate more
numbers than are available, what does numgen do?
Ensure that it does something sensible, such as stopping once it reaches a
limit — either database full or after too many failed attempts to generate a
new number — or refusing a request to create more numbers than are
available.
Option 4: Alternative implementations under different constraints
If you changed one of the basic constraints of the problem, such as using
5- or 6-digit rather than 8-digit numbers, what alternative implementations
would be practical? Experiment with different techniques.

Lab: Day 2
ISBNs – International Standard Book Numbers
There are two ISBN standards: ISBN-10 and ISBN-13. In this
exercise, support for ISBN-13 is essential, whereas support for
ISBN-10 is optional.
Here are some valid examples of each:
ISBN-10: 0471958697, 0 471 60695 2, 0-470-84525-2, 0-321-14653-0.
ISBN-13: 9780470059029, 978 0 471 48648 0, 978-0596809485,
978-0-13-149505-0, 978-0-262-13472-9.
Main task
Create a function that takes a string and returns true if that is a
valid ISBN-13 and false otherwise.
Optional task
Also return true if the string is a valid ISBN-10.

Lab: Day 2
ISBN-10 and ISBN-13 definitions
ISBN-10 is made up of 9 digits plus a check digit (which may be
X) and ISBN-13 is made up of 12 digits plus a check digit. Spaces
and hyphens may be included in a code, but are not significant.
This means 9780471486480 is equivalent to 978-0-471-48648-0 and
978 0 471 48648 0.
The check digit for ISBN-10 is calculated by multiplying each
digit by its position (i.e., 1 x 1st digit, 2 x 2nd digit, etc.), summing
these products together and taking modulo 11 of the result (with
X used if the result is 10).
The check digit for ISBN-13 is calculated by multiplying each
digit alternately by 1 or 3 (i.e., 1 x 1st digit, 3 x 2nd digit, 1 x 3rd
digit, 3 x 4th digit, etc.), summing these products together, taking
modulo 10 of the result and subtracting this value from 10, and
then taking the modulo 10 of the result again to produce a
single digit.

Python Foundation – A programmer's introduction to Python concepts & style

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Python Foundation – A programmer's introduction to Python concepts & style (20)

More from Kevlin Henney (20)

Recently uploaded (20)

Python Foundation – A programmer's introduction to Python concepts & style