1. 8 For-Statements © 2010 David A Watt, University of Glasgow Accelerated Programming 2 Part I: Python Programming 1

2. 8-2 For-statements (1)  Many loops involve a variable that is assigned a sequence of values: –e.g., a variable is assigned 1, then 2,..., then 10.  Other loops involve a variable that is assigned each element of a list (or string) in turn: –e.g., given a list [2, 3, 5, 7, 11], a variable is assigned 2, then 3, then 5, then 7, then 11. –e.g., given a string ‘QWERTY’, a variable is assigned ‘Q’, then ‘W’, then ‘E’, then ‘R’, then ‘T’, then ‘Y’.  Such loops can be programmed most concisely as for-statements.

3. 8-3 For-statements (2)  A for-statement is a loop that executes code a pre-determined number of times.  A for-statement has the form: for name in expression : body  To execute this for-statement: 1.The expression is evaluated to yield a sequence s. 2.The body is executed once for each element of s, with the values s[0], s[1], …, s[–1] successively assigned to the named variable.  A sequence is a string, list, or tuple.

4. 8-4 Example: consecutive integers  Function to print consecutive integers together with their squares: def print_squares (p, q): # Print each integer in the range p … q # together with its square. for n in range(p, q+1): print n, n**2

5. 8-5 Example: tabulation (1)  Tabulation program: def tabulate (low, high): # Tabulate the GCD of every pair of integers in the # range low … high. print_heading(low, high) for m in range(low, high+1): print_row (m, low, high)

6. 8-6 Example: tabulation (2)  Tabulation program (continued): def print_heading (low, high): # Print column headings in the range low … high. print 'Table of GCDs' print '\t', for n in range(low, high+1): print n, '\t', print def print_row (m, low, high): # Print a row of GCDs of m and integers in the # range low … high. print m, '\t', for n in range(low, high+1): print gcd(m, n), '\t',

7. 8-7 Example: list traversal  The following function traverses a list: def print_elements (l): # Print all values in list l, one per line. for v in l: print v

8. 8-8 Example: sorting a list (1)  Sorting function (selection-sort): def sort (l): # Sort the list l. for i in range(0, len(l)-1): p = find_least(l, i) if p > i: least = l[p] l[p] = l[i] l[i] = least

9. 8-9 Example: sorting a list (2)  Auxiliary function: def find_least (l, i): # Return the position of the least element in # the sub-list l[i:]. p = i least = l[p] for j in range(i+1, len(l)): if l[j] < least: p = j least = l[p] return p

10. 8-10 Example: computing prime numbers (1)  Problem: Compute the set of all prime numbers in the range 2…m–1.  Idea: Start with the set {2, …, m–1}. Remove all multiple of 2 from the set, then all multiples of 3, etc.  This idea leads to Eratosthenes’ sieve algorithm.

11. 8-11 Example: computing prime numbers (2)  Function: def primes (m): # Return a list of all prime numbers less than m. sieve = list(range(2, m)) n = 2 while n**2 < m: if n in sieve: # Remove multiples of n from sieve … for mult in range(2*n, m, n): remove(sieve, mult) n += 1 return sieve

12. 8-12 Example: computing prime numbers (3)  Auxiliary function: def remove (l, v): # If v is an element of list l, remove it. for i in range(0, len(l)): if l[i] == v: del l[i] return

13. 8-13 List comprehensions  A list comprehension is an expression that iterates over the elements of a list (or several lists).  The general form is: [ expression for name in expression if expression ] may be replicated as often as you need may be omitted  In the following examples assume: ps = [2, 3, 5, 7, 11] ws = ['a', 'an', 'the']

14. 8-14 List comprehensions: single list  We can iterate over a single list: [2*p for p in ps] – constructs a list of values 2*p, where p takes each value in the list ps – yields [4, 6, 10, 14, 22] [2*w for w in ws] – constructs a list of values 2*w, where w takes each value in the list ws – yields [‘aa’, ‘anan’, ‘thethe’] [len(w) for w in ws] – constructs a list of values len(w), where w takes each value in the list ws – yields [1, 2, 3]

15. 8-15 List comprehensions: multiple lists  We can iterate over two (or more) lists: [n*p for p in ps for n in range(2,4)] – constructs a list of values n*p, where p takes each value in the list ps and n takes each value in the list [2, 3] – yields [4, 6, 6, 9, 10, 15, 14, 21, 22, 33]

16. 8-16 List comprehensions: filtering  We can filter the list elements: [2*p for p in ps if 2 < p < 10] – constructs a list of values 2*p, where p takes each value in the list ps and such that 2<p<10 yields True – yields [6, 10, 14]