Week 6

Scope, While Loops, and String Operations

Scope demo

>>> def fun(param):
        local_var = 3
        print local_var, param, global_var

>>> global_var = 4
>>> fun(2)
3 2 4

>>> def fun2():
        print local_var

>>> fun2()
Traceback (most recent call last):
  File "", line 1, in ?
  File "", line 2, in fun2
NameError: global name 'local_var' is not defined
>>> def fun3():
        global_var = 5 # this actually creates a local variable
        print global_var

>>> fun3()
5
>>> global_var
4

Local vs. global variables

• Variables assigned outside of function bodies are global
  • they live forever
• Variables assigned inside the body of a function, and the function's parameters, are local to the function
  • they are created when the function is called and destroyed when it returns
  • FYI: the global statement, which we will not use now, allows global variables to be assigned within functions

Scope of variables

• The part of a program in which a variable can be referenced is its scope
• The scope of a local variable is the body of the function in which it is declared
  • excluding the bodies of nested functions that have a local variable with the same name
• The scope of a global variable is the entire program
  • except where there is a local variable with the same name
• Two variables with the same scope cannot have the same name
  • a second assignment changes the value of the existing variable, rather than creating a new one

While loop statement

• Syntax: while test_expression : body_block
• Semantics: repeatedly execute body_block until test_expression returns a false value
  • if test_expression is false to begin with, the body is never executed
  • if test_expression is always true, the loop is infinite (it never ends)
  • in words: while the test expression is true, execute the body
• Repeatedly executing some code is called iteration
  • a while loop iterates until the test expression is false

While loop control flow diagram

Direct exits from a loop body

• Statement syntax: break
  • only allowed in the body of a loop
• Semantics: exit from the enclosing loop immediately
  • if there is more than one enclosing loop, exit from the innermost one

Example: powers

def powers(n):
    """
    Prints a table of the first n integers and the corresponding
    power of two.
    >>> powers(10)
    1 2
    2 4
    3 8
    4 16
    5 32
    6 64
    7 128
    8 256
    9 512
    10 1024
    >>>
    """
    i = 1
    while i <= n:
        print i, 2**i
        i = i + 1

Counted loops

• In a counted loop one or more variables (usually integers) change value systematically with each loop iteration
• Examples
  • the powers function loop above
  • all the loops in chapter 6 of your text

Avoiding infinite loops

Most loops exit when the value of a variable referenced in the loop's test expression changes in a way that makes the expression false

• these are sometimes called sentry variables
  • example: the variable i in the powers function above
• they are usually initialized just before the loop begins
• infinite loops commonly result from program errors, such as failure to change the value of a sentry variable
  • example: forgetting the i = i + 1 line in the powers function

Accumulator loops

• In an accumulator loop one or more variables store the result of accumulating (gathering) information in the loop

• For Example, an accumulator sentinel loop that prints the product of the input numbers. Transcript:

  Enter number, or Enter to exit: 3
  Enter number, or Enter to exit: 2.5
  Enter number, or Enter to exit: -23.6
  Enter number, or Enter to exit:
  Product = -177.0
  

• Solution: product.py

  # product.py, by chaynes@indiana.edu
  # input a series of numbers and print their product
  
  product = 1
  
  while True:
      text = raw_input('Enter number, or  to exit: ')
      if text == '':
          break
      product = product * float(text) # same as: product *= float(text)
  
  print 'Product =', product
  
  

Exercise: powers_acc

def powers_acc(n):
    """
    Same as powers(n), but use an accumulator and not the
    exponentiation operator.
    Hint: initialize the accumulator to 2 and multiply it by
    two with each iteration.
    >>> powers_acc(3)
    1 2
    2 4
    3 8
    >>>
    """
    #.
    #.
    #.
    #.
    #.
    #.

Solution: powers_acc

def powers_acc(n):
    """
    Same as powers(n), but use an accumulator and not the
    exponentiation operator.
    Hint: initialize the accumulator to 2 and multiply it by
    two with each iteration.
    >>> powers_acc(3)
    1 2
    2 4
    3 8
    >>>
    """
    i = 1
    accumulator = 2
    while i <= n:
        print i, accumulator
        accumulator = accumulator * 2
        i = i + 1

Review: printing vs. returning

• print shows something to the user
• return gives a value to the caller of the function

If a function f is supposed to return a value (other than None), must f contain a return statement in its body?

1. Yes
2. No, the return statement might be in the body of a function that is called from the body of f
3. No, values can be returned in other ways

Answer: A

If a function f is supposed to print a value, must f contain a print statement in its body?

1. Yes
2. No, the print statement might be in a function that is called from the body of f

Answer: B

Which of the following defines a global variable named x containing 3?

1. def x(): 3
2. x == 3
3. x = 3
4. x <= 3

Answer: C

Which of the following is not a Python comparison operator?

1. !=
2. =<
3. ~=
4. all of the above
5. B and C

Answer: E

The value of 2<1 or not 2<3 and 3<4 is

1. True
2. False
3. there is an error

Answer: B

Review exercise: ordinal_form function

• The ordinal suffix of 1, 2, and 3 is st, nd, and rd, respectively, while that of integers larger than 3 and less than 21 is th

• Define the function ordinal_form(n) that returns a string consisting of n followed by its ordinal suffix assuming n is an integer in the range from 1 through 20

  • if you have time, consider how you could make it work for any positive integer

  >>> ordinal_form(3)
  '3rd'
  >>> ordinal_form(1)
  '1st'
  >>> ordinal_form(10)
  '10th'
  >>> ordinal_form(2)
  '2nd'
  

Solutions: ordinal_form function

def ordinal_form(n):
    # assume n is an integer in the range from 1 through 20
    if n == 1:
        return '1st'
    elif n == 2:
        return '2nd'
    elif n == 3:
        return '3rd'
    else:
        return str(n) + 'th'

Which of the following is true just when x is in the range from 0 to 10, inclusive of both endpoints?

1. 0 <= x and x <= 10
2. (x >= 0) and (x <= 10)
3. A and B
4. none of the above

Answer: C

How would you rate the first assignment?

1. rather easy
2. about right in difficulty
3. too hard

How are you doing in the current assignment?

1. We're making some progress
2. We're really stuck
3. We haven't really worked on it yet

How would you rate the last lab?

1. rather easy
2. about right in difficulty
3. too hard

Demo: String escape characters

>>> print 'line 1\nline 2'
line 1
line 2
>>> print 'a\ttab'
a   tab
>>> print 'He said "What?"'
He said "What?"
>>> print "That's ok"
That's ok
>>> print 'He said "That\'s ok"'
He said "That's ok"
>>> print "He said \"That's ok\""
He said "That's ok"
>>> print "dir\\subdir"
dir\subdir
>>> 'dir\\subdir'
'dir\\subdir'
>>> 'a\xy'
ValueError: invalid \x escape

String escape characters

• The backslash, "\" , is the string escape character that is combined with certain following characters to indicate one character
• Some commonly used escape sequences are
  • \n is a newline character
  • \t is a tab character
  • \\ is (just one) backslash
  • \' is a single quote (which does not end a single-quote string)
  • \" is a double quote (similarly useful in double-quoted strings)

Demo: String operators and len function

::

>>> 'one string' + 'and another'
'one stringand another'
>>> print 'Answer: ' + 3.14 * 5
Traceback (most recent call last):
  File "", line 1, in ?
TypeError: cannot concatenate 'str' and 'float' objects
>>> print 'Answer: ' + str(3.14 * 5)
Answer: 15.7
>>> 'Answer: ' + 42
TypeError: cannot concatenate 'str' and 'int' objects
>>> 'Answer: ' + str(42)
'Answer: 42'
>>> int(' 3\n')
3
>>> int('1 + 2')
ValueError: invalid literal for int(): 1 + 2
>>> len('py')
2
>>> len('')
0
>>> 'NI' * 3
'NININI'
>>> ' ' * 5
'     '
>>>

String operators and len function

• concatenation: s1 + s2
  • returns a new string, with the characters of s1 followed by those of s2
    • 'ab' + 'cd' ⇒ 'abcd'
  • it is an error if one argument is a string and the other is not
• replication: s * n
  • returns a new string formed by concatenating n copies of the string s
  • 'ab' * 3 ⇒ 'ababab'
  • n must be an integer
• the built-in function len(str) returns the length of the string

Overloaded operators

• An operator that behaves differently depending on the type of its arguments is said to be overloaded
• Examples:
  • numeric operators do different kinds of arithmetic on floating point and integer values
  • + and * do string concatenation and replication as well as numeric operations

Right and left justification

• The multiplication table would look better if the columns were aligned

• In chapter 6 of your text, this is done using tab (\t) characters, but this is undesirable because tabs skip some fixed amount that may not be what you want and depends on how printing is done

• Tabs also left justifies columns, whereas numbers look better when right justified

  • for example, the first column below is left justified, and the second is right justified:

    1          1
    12        12
    123      123
    

Defining a right-justification function

def right_justify(n, string):
    """
    Returns the string with enough blanks added at the beginning
    to make it n characters long.
    >>> right_justify(5, 'foo')
    '  foo'
    >>>
    """
    return ' ' * (n - len(string)) + string

FYI Python, like most languages, has a somewhat complicated formatting mechanism that allows justification and some other formatting possibilities to be expressed in a very compact way. But that's beyond this course, and sometimes you still have to know how to do it yourself anyway.

Example: mult_table

def mult_table(n):
    """
    Print an n by n multiplication table.
    >>> mult_table(9)
    1 2 3 4 5 6 7 8 9
    2 4 6 8 10 12 14 16 18
    3 6 9 12 15 18 21 24 27
    4 8 12 16 20 24 28 32 36
    5 10 15 20 25 30 35 40 45
    6 12 18 24 30 36 42 48 54
    7 14 21 28 35 42 49 56 63
    8 16 24 32 40 48 56 64 72
    9 18 27 36 45 54 63 72 81
    >>>
    """
    i = 1
    while i <= n:
        j = 1
        line = ''
        while j <= n:
            line = line + str(i * j) + ' '
            j = j + 1
        print line
        i = i + 1

Nested loops

• A nested loop is a loop within a loop, as in the multiplication table program, which may be
  • syntactic nesting: a loop in the body of another loop
  • dynamic nesting: a loop in a function called directly or indirectly from the body of another loop
• Chapter 6 of your text has related programs
  • it uses dynamic nesting, with a loop that prints a single line in a function called from the loop that prints the whole table
  • it uses a soon-to-be-obsolete print syntax with a comma at the end, which avoids the need to accumulate each line in a string

Exercise: justified_mult_table

def justified_mult_table(n, width):
    """
    Print an n by n multiplication table in which each column has
    the indicated width.
    >>> justified_mult_table(9, 4)
       1   2   3   4   5   6   7   8   9
       2   4   6   8  10  12  14  16  18
       3   6   9  12  15  18  21  24  27
       4   8  12  16  20  24  28  32  36
       5  10  15  20  25  30  35  40  45
       6  12  18  24  30  36  42  48  54
       7  14  21  28  35  42  49  56  63
       8  16  24  32  40  48  56  64  72
       9  18  27  36  45  54  63  72  81
    >>>
    """
    i = 1
    while i <= n:
        j = 1
        line = ''
        while j <= n:
            #...
            j = j + 1
        print line
        i = i + 1

Solution: justified_mult_table

def justified_mult_table(n, width):
    """
    Print an n by n multiplication table in which each column has
    the indicated width.
    >>> justified_mult_table(9, 4)
       1   2   3   4   5   6   7   8   9
       2   4   6   8  10  12  14  16  18
       3   6   9  12  15  18  21  24  27
       4   8  12  16  20  24  28  32  36
       5  10  15  20  25  30  35  40  45
       6  12  18  24  30  36  42  48  54
       7  14  21  28  35  42  49  56  63
       8  16  24  32  40  48  56  64  72
       9  18  27  36  45  54  63  72  81
    >>>
    """
    i = 1
    while i <= n:
        j = 1
        line = ''
        while j <= n:
            line = line + right_justify(width, str(i * j))
            j = j + 1
        print line
        i = i + 1

Exercise: powers_formatted

def powers_formatted(n):
    """
    Prints a table of the first n integers and the corresponding
    power of two.
    Right justify the integers in two columns and the power in 6,
    with a space between the columns.
    >>> powers_formatted(10)
     1      2
     2      4
     3      8
     4     16
     5     32
     6     64
     7    128
     8    256
     9    512
    10   1024
    >>>
    """
    i = 1
    while i <= n:
        #...
        #...
        print formatted_i, formatted_power
        i = i + 1

Solution: powers_formatted

def powers_formatted(n):
    """
    Prints a table of the first n integers and the corresponding
    power of two.
    Right justify the integers in two columns and the power in 6,
    with a space between the columns.
    >>> powers_formatted(10)
     1      2
     2      4
     3      8
     4     16
     5     32
     6     64
     7    128
     8    256
     9    512
    10   1024
    >>>
    """
    i = 1
    while i <= n:
        formatted_i = right_justify(2, str(i))
        formatted_power = right_justify(6, str(2**i))
        print formatted_i, formatted_power
        i = i + 1

Formatting floating point numbers

• The module fpformat has a function fix(x, digs) that takes a number x and a positive integer digs (for "digits") and returns a floating point string with digs digits after the decimal point.

  >>> import fpformat
  >>> fpformat.fix(2.58, 1)
  '2.6'
  >>> fpformat.fix(-2.0 / 3, 3)
  '-0.667'
  >>> fpformat.fix(3, 4)
  '3.0000'
  

• This can be used in combination with a string justification function to right or left justify floating point numbers.