Download presentation
Presentation is loading. Please wait.
Published byHubert Wilson Modified over 9 years ago
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]
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.