Control Flow - Swami Iyersame status as assignment statements or any other statement As a result, we...

Control Flow

Compound Assignment and Variable Scope

A compound assignment statement is shorthand for modifying the value of a variable

Examples:

i += 1 is equivalent to i = i + 1

i *= k is equivalent to i = i * k

The scope of a variable is the part of the program that can refer to that variable by name

Generally the scope comprises the statements that follow the variable definition in thesame block (marked by indentation) as the definition

Branching

The if statement is used to perform different actions under different conditions

if <boolean expression >:

<statement >

<statement >

...

elif <boolean expression >:

<statement >

<statement >

...

elif <boolean expression >:

<statement >

<statement >

...

...

else:

<statement >

<statement >

...

...

Branching

/ grade.py

� Accepts score (float) as command-line argument.

� Writes the corresponding letter grade to standard output.

& ~/workspace/ipp/programs

$ python3 grade.py 97

A

$ python3 grade.py 56

F

$

Branching

L grade.py

import stdio

import sys

score = float(sys.argv [1])

if score >= 93:

stdio.writeln(’A’)

elif score >= 90:

stdio.writeln(’A-’)

elif score >= 87:

stdio.writeln(’B+’)

elif score >= 83:

stdio.writeln(’B’)

elif score >= 80:

stdio.writeln(’B-’)

elif score >= 77:

stdio.writeln(’C+’)

elif score >= 73:

stdio.writeln(’C’)

elif score >= 70:

stdio.writeln(’C-’)

elif score >= 67:

stdio.writeln(’D+’)

elif score >= 63:

stdio.writeln(’D’)

elif score >= 60:

stdio.writeln(’D-’)

else:

stdio.writeln(’F’)

Branching

A conditional expression is used to decide between two expressions

<expression1 > if <boolean expression > else <expression2 >

Branching

/ flip.py

� Simulates a coin flip by writing ‘Heads’ or ‘Tails’ to standard output.


$ python3 flip.py

Heads

$ python3 flip.py

Heads

$ python3 flip.py

Tails

$

Branching

L flip.py

import stdio

import stdrandom

result = ’Heads ’ if stdrandom.bernoulli (0.5) else ’Tails’

stdio.writeln(result)

Looping

A loop (while or for) statement is used for repetitive computations

While statement

while <boolean expression >:

<statement >

<statement >

...

...

Looping

/ nhellos.py

� Accepts n (int) as command-line argument.

� Writes n Hellos to standard output.


$ python3 nhellos.py 10

Hello # 1

Hello # 2

Hello # 3

Hello # 4

Hello # 5

Hello # 6

Hello # 7

Hello # 8

Hello # 9

Hello # 10

$

Looping

L nhellos.py

import stdio

import sys

n = int(sys.argv [1])

i = 1

while i <= n:

stdio.writeln(’Hello # ’ + str(i))

i += 1

Looping

For statement

for <variable > in <iterable object >:

<statement >

<statement >

...

...

The most commonly used iterable objects are the lists containing arithmetic progressionsof integers, returned by the built-in function range()

The call range(start, stop, step) returns a list starting at start, ending just before stop, and inincrements (or decrements) given by step

The call range(start, stop) is shorthand for range(start, stop, 1)

The call range(stop) is shorthand for range(0, stop, 1)

Examples

range(8, 0, -2) # returns list [8, 6, 4, 2]

range(3, 9) # returns list [3, 4, 5, 6, 7, 8]

range (5) # returns [0, 1, 2, 3, 4]

Looping

/ powersoftwo.py


� Writes a table of powers of 2 that are less than or equal to 2n.


$ python3 powersoftwo.py 8

0 1

1 2

2 4

3 8

4 16

5 32

6 64

7 128

8 256

$

Looping

L powersoftwo.py

import stdio

import sys


power = 1

for i in range(n + 1):

stdio.writeln(str(i) + ’ ’ + str(power))

power *= 2

Looping

Strings are iterable objects, so a string’s characters can be enumerated using a forstatement

For example, the following code

import stdio

for c in ’Python ’:

stdio.writeln(c)

stdio.writeln ()

produces the following output

P

y

t

h

o

n

Nesting

The if, while, and for statements, collectively called the control-flow statements, have thesame status as assignment statements or any other statement

As a result, we can use them wherever a statement is called for

In particular, we can use (nest) one or more of them in the body of another statement tomake compound statements

Nesting

/ divisorpattern.py


� Writes a table to standard output where entry (i, j) is a ‘* ’ if j divides i or i divides j and a ‘ ’ otherwise.


$ python3 divisorpattern.py 20

* * * * * * * * * * * * * * * * * * * * 1

* * * * * * * * * * * 2

* * * * * * * 3

* * * * * * * 4

* * * * * 5

* * * * * * 6

* * * 7

* * * * * 8

* * * * 9

* * * * * 10

* * 11

* * * * * * 12

* * 13

* * * * 14

* * * * 15

* * * * * 16

* * 17

* * * * * * 18

* * 19

* * * * * * 20

$

Nesting

L divisorpattern.py

import stdio

import sys


for i in range(1, n + 1):

for j in range(1, n + 1):

if i % j == 0 or j % i == 0:

stdio.write(’* ’)

else:

stdio.write(’ ’)

stdio.writeln(i)

Applications

/ harmonic.py


� Writes to standard output the nth harmonic number: 1 + 12

+ ... + 1n

.


$ python3 harmonic.py 10

2.9289682539682538


7.485470860550343


9.787606036044348

$

Applications

L harmonic.py

import stdio

import sys


total = 0.0

for i in range(1, n + 1):

total += 1 / i

stdio.writeln(total)

Applications

/ sqrt.py

� Accepts c (float) as command-line argument.

� Writes the square root of c to standard output.


$ python3 sqrt.py 2

1.414213562373095

$ python3 sqrt.py 1000000

1000.0

$ python3 sqrt.py 0.4

0.6324555320336759


1023.9995117186336


4082.2106756021303

$ python3 sqrt.py 1e-50

9.999999999999999e-26

$

Applications

Applications

L sqrt.py

import stdio

import sys

c = float(sys.argv [1])

EPSILON = 1e-15

t = c

while abs(t - c / t) > EPSILON * t:

t = (c / t + t) / 2

stdio.writeln(t)

Applications

/ binary.py


� Writes the binary representation of n to standard output.


$ python3 binary.py 19

10011


11111111


1000000000


111011100110101100101000000000

$

Applications

12

16 8 4 2 1

19

16

1 0 0 1 1

Applications

L binary.py

import stdio

import sys


v = 1

while v <= n // 2:

v *= 2

while v > 0:

if n < v:

stdio.write(’0’)

else:

stdio.write(’1’)

n -= v

v //= 2

stdio.writeln ()

Applications

/ gambler.py

� Accepts stake (int), goal (int), and trials (int) as command-line arguments.

� Runs trials experiments (dollar bets) that start with stake dollars and terminate on 0 dollars or goal;and writes to standard output the percentage of wins and the average number of bets per experiment.


$ python3 gambler.py 10 20 1000

46% wins

Avg # bets: 97


19% wins

Avg # bets: 12069


19% wins

Avg # bets: 1155781

$

Applications

goal

stake

0

goal

stake

0

win

loss

Applications

L gambler.py

import stdio

import sys

import stdrandom

stake = int(sys.argv [1])

goal = int(sys.argv [2])

trials = int(sys.argv [3])

bets = 0

wins = 0

for t in range(trials ):

cash = stake

while cash > 0 and cash < goal:

bets += 1

if stdrandom.bernoulli ():

cash += 1

else:

cash -= 1

if cash == goal:

wins += 1

stdio.writeln(str (100 * wins // trials) + ’% wins’)

stdio.writeln(’Avg # bets: ’ + str(bets // trials ))

Applications

/ factors.py

� Accepts n (int) as command-line arguments.

� Writes to standard output the prime factors of n.


$ python3 factors.py 3757208

2 2 2 7 13 13 397

$ python3 factors.py 287994837222311

17 1739347 9739789

$

Applications

L factors.py

import stdio

import sys


factor = 2

while factor * factor <= n:

while n % factor == 0:

stdio.write(str(factor) + ’ ’)

n //= factor

factor += 1

if n > 1:

stdio.write(n)

stdio.writeln ()

Break and Continue

The break statement immediately exits a loop without letting it run to completion

Example (writes to standard output numbers less than or equal to n)

i = 0

while True:

if i > n:

break

stdio.writeln(i)

i += 1

A continue statement skips to next iteration of a loop

Example (writes to standard output odd numbers less than or equal to n)

for i in range(n + 1):

if i % 2 == 0:

continue

stdio.writeln(i)

Control Flow - Swami Iyersame status as assignment statements or any other statement As a result, we...

Documents

Transcript of Control Flow - Swami Iyersame status as assignment statements or any other statement As a result, we...