CSC111 Lab 3 2015

--D. Thiebaut (talk) 21:22, 9 February 2015 (EST)

---

Understanding how Floats take over Expressions

In this section I am asking you to play and get an understanding of important functions, and also how floating point numbers (numbers with a decimal point) take over expressions, when they are present in them.

Open the Python shell and type the expressions below. Try to predict the output of the interpreter when you are about to press the ENTER key.

>>> a = 3
>>> x = 1.5
>>> type( a )

>>> type( x )

>>> type( a * x )

>>> type( a * 100 )

>>> type( 1 )

>>> type( 1.0 )

>>> type( "1" )

>>> a / 3

>>> a // 3

>>> type( a/3 )

>>> type( 5/4 )

>>> type( 5//4 )

>>> type( int( 1.5 ) )

>>> int( 1.5 )

>>> round( 1.6 )

>>> round( 1.4 )

>>> round( -1.8 )

>>> type( round( 1.4 ) )

>>> round( -1.8 )

>>> abs( -4 )

>>> abs( 10 )

>>> type( abs( -19.3 ) )

>>> type( abs( -4 ) )

• Note how once something is a float, if forces whatever it gets combined with to yield a result that is float, except for the int() function, of course.

Challenge #0: (we always start at 0 in Computer Science!)

• Write a small program (either in the Python Shell, or in the Edit window), that asks the user to enter a number between 0 and 100, and that prints out 0 if the number is between 0 and 25 (25 not included), 1 if the number is between 25 and 50 (50 not included), 2 if the number is between 50 and 75 (75 not inclulded), and 3 if the number is between 75 and 100 (100 not included).

• Here is an example of the type of exchange I had with

>>> 
>>> x = eval( input( "Enter a number: " ) )
Enter a number: 75.7
>>> result =  ...  write an expression here that takes x and computes the expected result
>>> result
3
>>> x = 1
>>> result = ...  use the same expression you wrote above...
>>> result
0
>>> x = 24.99999
>>> result = ...  use the same expression you wrote above...
>>> result
0
>>> x = 25.00000001
>>> result = ...  use the same expression you wrote above...
>>> result
1
>>>

Teller Machine Program

This section will get you to write a program similar (though not necessarily the same) to the program we wrote in class on Monday. The program takes an integer (without a decimal part) amount of dollars and figures out how to break it down into the least number of 20-, 10-, 5-, and 1-bills.

Reviewing the Division Operators, // and %

Use the Python shell, and try to predict the result of the following operations.

>>> 21 // 5

>>> 21 % 5

>>> 9 // 2

>>> 9 % 2

>>> 13 // 3

>>> 13 % 3

>>> 139 // 20

>>> 139 % 20 

Beginning Program

• Write a program that contains
  • a short header with the program name (lab3.py, for example),
  • your name,
  • the date, and
  • A short description of the program.
• Create 3 different comment lines that will create an outline of your program.

# lab3.py
# yourName
# date
# blah blah blah blah blah blah...
#

# get the initial amount

# compute number of bills

# output number of bills to give out

• Save and Run the program, just to make sure you do not have a syntax error.

Define original amount

• Under the #get the initial amount comment, create a variable called amount and initialize it with a value of your choice. Pick a value that is not a multiple of 5.
• Add a print() statement under the #output number of bills comment, and make it print the amount the user wants to withdraw.
• Verify that your program works.

Compute the number of $20s to give out

• Using the right operator (//, /, or %), make your program compute the number of $20 and store that value in a new variable, called no20s. Add this code under the # compute number of bills.
• Make your program output the no20s variable in the output section.
• Verify that your program works.

Computing the Left-Over Amount

• Go back to the computation of the number of $20s, and compute the amount of money left over once the $20s are taken out of the amount. You have several ways of doing this. You can do it using the % modulo operator, or using multiplication and subtraction. Whichever method you use is fine for today.
• Make your program output the left-over amount, just to make sure that value is computed correctly.
• Verify that your program works fine.

Computing the Remaining Quantities

• Now that you have the structure for your program, add enough Python code to make your code display
  • The total amount
  • The number of $20-bills
  • The number of $10-bills
  • The number of $5-bills
  • The number of $1-bills

• Verify that your program works. Below is a typical output you should try to emulate:

Amount to withdraw =  97

Please lift keyboard and find: 
4 $20-bill(s)
1 $10-bill(s)
1 $5-bill(s)
2 $1-bill(s)

Flexibility and Adaptability

Imagine that your program will be used in an area where the bills do not come in 20, 10, 5 or 1 denominations, but in 100, 50, 10, and 1.

Figure out a way to make the least amount of change to your program so that it now outputs the correct break down for any amount, but in $100-, $50-, $10- and $1-bills.

Make sure your program works! Below is the output of the program if the amount is set to $97:

Amount to withdraw = $ 97

Please lift keyboard and find: 
0 $ 100 bill(s)
1 $ 50 bill(s)
4 $ 10 bill(s)
7 $ 1 bill(s)

Challenge #1: A Change Machine

• Using a similar approach, write a program that, given some number of pennies, will output the correct number of quarters, dimes, nickels, and pennies. You should initialize the amount of pennies with an integer, like this:

 pennies = 84

• Here is an example of what your program should output for 84 pennies:

Amount to withdraw = 84 cent(s)

Please lift keyboard and find: 
3 quarter(s)
0 dime(s)
1 nickel(s)
4 cent(s)

Formatted Output

Strings

In this section you will work on formatting strings, ints, and floats using the {...} formatting command.

• Try this statement out:

    name = "Snow White"
    print( "Hello {0:1}! How are you?".format( name ) )

• Then modify the {0:1} part and try these different combinations: {0:5}, {0:10}, {0:15}, {0:20}. For each one, make sure you understand why the output changes (or not).
• Then try these different formats: {0:>1}, {0:>5}, {0:>10}, {0:>15}, {0:>20}. Notice the right-justification of the string Snow White in this second set of outputs.

• Now try this piece of code:

    print( )
    for friend in [ "Bashful", "Doc", "Dopey",  "Happy", "Sleepy", "Sneezy", "Grumpy"]:
        print( "Hello {0:10}!".format( friend ) )

Printing 2 strings at once

• Change the print() statement so that you now print two different strings, each with its own {...} format:

    print( )
    for friend in [ "Bashful", "Doc", "Dopey",  "Happy", "Sleepy", "Sneezy", "Grumpy"]:
        print( "{0:1} wants to take {1:1} to the Valentine's ball." . format( friend, "Snow White" ) )

• Now switch the 0 and the 1 in the two {...} expressions, as illustrated in the line below:

        print( "{1:1} wants to take {0:1} to the Valentine's ball." . format( friend, "Snow White" ) )

• Notice how the first number in the {...} expressions is used to figure out which string to pick in the format(...) block.

Printing a String and an Int

• Try this formatting command:

    name = "Valentine's Day" 
    day = 15
    print( "{0:>20} is on the {1:1}th of the month" . format( name, day ) )
    name = "My birthday"
    day  = 6
    print( "{0:>20} is on the {1:1}th of the month" . format( name, day ) )

• Here's another statement to try:

    name = "Snow White"
    length = len( name )
    print( "the string {0:1} contains {1:1} characters" . format( name, length ) ) )

Challenge #2:

• Modify the for-loop you used before so that your program now outputs friend and len( friend ), as shown below.

Bashful 7
Doc 3
Dopey 5
Happy 5
Sleepy 6
Sneezy 6
Grumpy 6

• Once you get this output, format it into a nice looking table.

+------------+-----+
| Bashful    |   7 |
| Doc        |   3 |
| Dopey      |   5 |
| Happy      |   5 |
| Sleepy     |   6 |
| Sneezy     |   6 |
| Grumpy     |   6 |
+------------+-----+

• Note: the number in the second column