CSC111 Programs Created in Class 2018

D. Thiebaut (talk) 12:30, 31 January 2018 (EST)

---

1/30/18

# wedWeek1.py
# D. Thiebaut
# Demo program week 1


# variables
age = 20
year = 2018

# compute year born
print( year - age )


# example of for loop
for name in [ "smith", 23, 3.14159, "hello" ]:
    print( name )

"""
challenge: print the following lines
***
Mae
*****
Alice
*******
Felicia
"""

for name in [ "Mae", "Alice", "Felicia" ]:
    print( '*' * len( name ) )
    print( name )


"""
new challenge: print the following lines
*
Mae
********
Alice
****
Felicia
**
"""

for name in [ "*", "Mae", "********", "Alice", "****", "Felicia", "**" ]:
    print( name )

02/05/18

Table of Fahrenheit to Celsius conversion

# 020518.py
# D. Thiebaut
#
# print table of temperatures
# start at 100 F down to -30 F
# in steps of 10
# using the formula: Celsius = (Farhenheit - 32 ) * 5 / 9

# print the header 
print( "Fahrenheit --> Celsius" )

# display the table of temperatures
# ranging from 100 down to -30F.
for fTemp in range( 100, -31, -10 ):
    cTemp = ( fTemp - 32 ) * 5 / 9
    print( fTemp, '-->', cTemp )

Problem: get user name and grade and display user information and grade as a bar graph.

# barGraph.py
# D. Thiebaut
# this program prompts the user for her information
# and grade and displays a bar-graph.
#
#First name?  Dominique
#Last name?   Thiebaut
#Id?          990123456
#Final grade? 90
#
#+———————————————————————————————————-———————————-+
#|Dominique Thiebaut                    990123456 |
#+———————————————————————————————————-———————————-+
#      00...10...20...30...40...50...60...70...80...90...100
#grade: #############################################
#class: ########################################
#
#

# input section
fName = input( "First name?  " )
lName = input( "Last name?   " )
Id    = input( "Id?          " )
final = input( "Final grade? " )

# output section
print( fName, lName, Id )
bar = "+———————————————————————————————————-———————————-+"
barLen = len( bar )
print( "barLen =", barLen )
nameIdLen = len( fName )+1+len( lName ) + len( Id )+1
print( "nameIdLen =", nameIdLen )

print( bar )
print( "|", fName, lName, ' '*(barLen-nameIdLen), Id, '|' )
print( bar )

2/7/18

We didn't have time to cover this problem, because of the snow storm... But it simply displays an 8 by 8 chessboard using hash tags.

# chessBoard.py
# D. Thiebaut
# displays an 8x8 chessboard, as shown below.
"""
###   ###   ###   ###   
###   ###   ###   ###   
###   ###   ###   ###   
   ###   ###   ###   ###
   ###   ###   ###   ###
   ###   ###   ###   ###
###   ###   ###   ###   
###   ###   ###   ###   
###   ###   ###   ###   
   ###   ###   ###   ###
   ###   ###   ###   ###
   ###   ###   ###   ###
###   ###   ###   ###   
###   ###   ###   ###   
###   ###   ###   ###   
   ###   ###   ###   ###
   ###   ###   ###   ###
   ###   ###   ###   ###
###   ###   ###   ###   
###   ###   ###   ###   
###   ###   ###   ###   
   ###   ###   ###   ###
   ###   ###   ###   ###
   ###   ###   ###   ###
"""
numRows = eval( input( "Number of rows?    " ) )
numCols = eval( input( "Number of columns? " ) )
white="   "
black="###"

bar1 = ""
bar2 = ""
for i in range( numCols//2 ):
    bar1 = bar1 + white + black
    bar2 = bar2 + black + white

for i in range( numRows//2 ):
    # display 2 lines of squares
    # alternating the colors
    # 5    ###   ###   ###   ###
    #     ###   ###   ###   ###
    #     ###   ###   ###   ###
    #  ###   ###   ###   ###   
    #  ###   ###   ###   ###   
    #  ###   ###   ###   ###   
    for n in range( 3 ):
        print( bar1 )
    for n in range( 3 ):
        print( bar2 )

2/9/18

# barGraph.py
# D. Thiebaut
# this program prompts the user for her information
# and grade and displays a bar-graph.
#
#First name?  Dominique
#Last name?   Thiebaut
#Id?          990123456
#Final grade? 90
#
#+———————————————————————————————————-———————————-+
#|Dominique Thiebaut                    990123456 |
#+———————————————————————————————————-———————————-+
#      00...10...20...30...40...50...60...70...80...90...100
#grade: #############################################
#class: ########################################
#
#

# box geometry
bar = "+———————————————————————————————————-———————————-+"
barLen = len( bar )

# input section
fName      = input( "First name? " )
fNameLen   = len( fName )
lName      = input( "Last name?  " )
lNameLen   = len( lName )
Id         = input( "Id?         " )
IdLen      = len( Id )
numSpaces  = barLen -3 -(fNameLen+1+lNameLen+IdLen)
grade      = eval( input( "Final grade? " ) )
classGrade = 80

# output section
print( bar )
print( '|' + fName, ' ', lName, ' '*(numSpaces), Id, ' |', sep='' )
print( bar )

# print the scale
print( "      00...10...20...30...40...50...60...70...80...90...100" )

# print the student grade as a bar
numHashTags = grade // 2
print( "grade:", '#' * numHashTags )

#print the class grade as a bar
numHashTags = classGrade // 2
print( "class:", '#' * numHashTags )

2/12/18

# teller.py
# D. Thiebaut
# simulates teller machine program
# prompts user, displays number of bills

# input amount to withdraw (use eval)
amount = eval( input( "Amount to withdraw? " ) )
amount = abs( amount )
print( "Amount:", amount )


# compute number of bills, 20, 10, 5, 1
no20s  = amount // 20
amount = amount % 20  # leftover after giving out all the 20s 

no10s  = amount // 10 
amount = amount % 10 # leftover after giving out all the 10s 

no5s   = amount // 5
amount = amount % 5 # leftover after giving out all the 5s 

no1s   = amount


# display number of bills
print( no20s, "$20-bill(s)" )
print( no10s, "$10-bill(s)" )
print( no5s, "$5-bill(s)" )
print( no1s, "$1-bill(s)" )

2/14/18

# generate a table of the powers of 2
"""
    0    1
    1    2
    2    4
    3    8
    4   16
    5   32
    6   64
    7  128
    8  256
    9  512
1234567890123
"""
for i in range( 10 ):
    print( "{0:5}{1:5}".format( i, 2**i ) )


# display the following table:
# 1: len(Doc    )= 3
# 2: len(Grumpy )= 6
# 3: len(Happy  )= 5
# 4: len(Sleepy )= 6
# 5: len(Dopey  )= 5
# 6: len(Bashful)= 7
# 7: len(Sneezy )= 6

count = 1
for name in ["Doc", "Grumpy", "Happy", 
                    "Sleepy", "Dopey", "Bashful",
                    "Sneezy" ]:
    print( "{0:1}: len({1:<7})= {2:1}"
            .format( count, name, len(name) ) )
    count = count + 1

2/16/18

# accumulate.py
# D. Thiebaut
# solution programs for 2/16/18

# --------------------------------------
# sum of all the numbers from 1 to 100
total = 0
#print( "initial total:", total )
for i in range( 0, 100+1, 5):
    #print( i, total )
    total = total + i
    #print( "after sum:", i, total )
    #print()

print( total )

# --------------------------------------
# average of [100, 95,100, 90, 60, 85]
total = 0
count = 0
for i in [100, 95,100, 90, 60, 85]:
    total = total + i
    print( "i =", i )
    count = count + 1
    print( "count = ", count )
    
print( "total = ", total, "count = ", count )
print( "average = ", total/count )


# --------------------------------------
a = "#"
b = "+"
final = ""
# from numbers to string
print( "before loop: a=", a, "b=", b )
for i in   [1,2,1,1,3,4]:
    #print( i * a, end="", sep="" )
    print( "i=", i, "a=", a, "b=", b )
    final = final + i*a
    print( "final =", final )
    a, b = b, a

print( "final string = ", final )

2/19/18

Different ways to print all the strings in a list.

def main():
    farm = ["pig", "dog", "horse", "hen" ]

    #--------------------------------------------------
    print( "method 1" )
    print( """pig
dog
horse
hen""" )

    #--------------------------------------------------
    print( "method 2" )
    print( farm )
    
    #--------------------------------------------------
    print( "method 3" )
    print( "pig\ndog\nhorse\nhen" )
    
    #--------------------------------------------------
    print( "method 4" )
    print( list( farm ) )

    #--------------------------------------------------
    print( "method 5" )
    print( farm[0], farm[1], farm[2], farm[3] )
    
    #--------------------------------------------------
    print( "method 6" )
    print( farm[0], farm[1], farm[2], farm[3], sep="\n" )
    
    #--------------------------------------------------
    print( "method 7" )
    for n in [0,1,2,3]:
       print( farm[n] )

    #--------------------------------------------------
    print( "method 8" )
    for animal in farm:
            print( animal )

    #--------------------------------------------------
    print( "method 9" )
    for animal in farm:
        for c in range( len( animal ) ):
            print( animal[c], sep="", end="")
        print(" " )
        
    #--------------------------------------------------
    print( "method 10" )
    for i in range( len( farm ) ):
        print( farm[i] )

    #--------------------------------------------------
    print( "method 11" )
    for i in range( -1, -len(farm), -1 ):
            print( farm[ i ] )

    #--------------------------------------------------
    print( "method 12" )
    for i in range( -1, -len(farm)-1, -1 ):
            print( farm[ i ] )

    #--------------------------------------------------
    print( "method 13" )
    for i in range( -len(farm), 0, 1 ):
            print(farm[i] )

main()

02/21/18

>>> name = "H:/Documents/solutionsHw4.doc"

>>> name
'H:/Documents/solutionsHw4.doc'
>>> drive = name[0:2]
>>> drive
'H:'
>>> name
'H:/Documents/solutionsHw4.doc'
>>> ext = name[-3: ]
>>> ext
'doc'
>>> newName = name[0:-3]
>>> newName
'H:/Documents/solutionsHw4.'
>>> newName = name[0:-3] + "txt"
>>> newName
'H:/Documents/solutionsHw4.txt'
>>> fname = "Alex"
>>> lname = "Booth"
>>> account = fname[0:1] + lname
>>> account
'ABooth'
>>> account = fname[0] + lname
>>> account
'ABooth'


>>> date = "02212018"
>>> wanted = "21 Feb 2018"
>>> date
'02212018'
>>> wanted
'21 Feb 2018'
>>> months = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun"
	   ,"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
>>> months
['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
>>> months[1]
'Feb'
>>> months[2]
'Mar'
>>> months = ["Dummy", 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
>>> months[2]
'Feb'
>>> day = date[2:4]
>>> day
'21'
>>> month = date[0:2]
>>> month
'02'
>>> int( month )
2
>>> months[ int( month ) ]
'Feb'
>>> date
'02212018'
>>> year = date[4: ]
>>> year
'2018'
>>> print( day, months[ int( month ) ], year )
21 Feb 2018
>>> date
'02212018'
>>> day
'21'
>>> month
'02'
>>> year
'2018'
>>> months
['Dummy', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
>>> months[ int( month ) ]
'Feb'


>>> fname = "Maria"
>>> lname = "Luce"
>>> name = fname + lname
>>> name
'MariaLuce'
>>> for i in range( len( name ) ):
	print( i )

	
0
1
2
3
4
5
6
7
8
>>> for i in range( len( name ) ):
	print( i, name[0:i] )

	
0 
1 M
2 Ma
3 Mar
4 Mari
5 Maria
6 MariaL
7 MariaLu
8 MariaLuc

>>> for i in range( len(name ) ):
	print( i, name[0:i+1] )

	
0 M
1 Ma
2 Mar
3 Mari
4 Maria
5 MariaL
6 MariaLu
7 MariaLuc
8 MariaLuce
>>> for i in range( len( name ) ):
	print( name[0:i+1] )

	
M
Ma
Mar
Mari
Maria
MariaL
MariaLu
MariaLuc
MariaLuce


>>> farm = [ "pig", "dog", "cat" ]
>>> farm
['pig', 'dog', 'cat']
>>> farm[0]
'pig'
>>> farm[1]
'dog'
>>> farm[-1]
'cat'
>>> 
>>> 
>>> farm[ 0 ] = "horse"
>>> farm
['horse', 'dog', 'cat']
>>> farm[2] = "mouse"
>>> farm
['horse', 'dog', 'mouse']
>>> farm[-1] = "cat"
>>> farm
['horse', 'dog', 'cat']
>>> name = "Smith College"
>>> 
>>> 
>>> 
>>> 
>>> name[0]
'S'
>>> name[-1]
'e'
>>> name[2]
'i'
>>> name[0] = 'Z'
Traceback (most recent call last):
  File "<pyshell#94>", line 1, in <module>
    name[0] = 'Z'
TypeError: 'str' object does not support item assignment   <--- strings are immutable!
>>> farm2 = ( "cat", "dog", "mouse" )
>>> farm2[1]
'dog'
>>> farm2[1] = "horse"
Traceback (most recent call last):
  File "<pyshell#97>", line 1, in <module>
    farm2[1] = "horse"
TypeError: 'tuple' object does not support item assignment
>>> animal = "horse"
>>> animal[0] = 'H'
Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    animal[0] = 'H'
TypeError: 'str' object does not support item assignment
>>> animal = 'H' + animal[1: ]
>>> animal
'Horse'



>>> greeting = "hello there"
>>> greeting.upper()
'HELLO THERE'
>>> greeting
'hello there'
>>> greeting = greeting.upper()
>>> greeting
'HELLO THERE'
>>> lname = "Max"
>>> fname = "Joe"
>>> fname[0] + lname
'JMax'
>>> account = fname[0] + lname
>>> account
'JMax'
>>> account = account.lower()
>>> account
'jmax'
>>> title = "CSC111 Intro to CS"
>>> title.center( 60 )
'                     CSC111 Intro to CS                     '
>>> title
'CSC111 Intro to CS'
>>> print( title.center( 60 ) )
                     CSC111 Intro to CS                     
>>> name = "alex booth"
>>> name.capitalize()
'Alex booth'
>>> name
'alex booth'
>>> name.title()
'Alex Booth'
>>> name = "MICKEY MOUSE"
>>> name.capitalize()
'Mickey mouse'
>>> name.title()
'Mickey Mouse'
>>> name
'MICKEY MOUSE'
>>> name = name.title()
>>> name
'Mickey Mouse'
>>> name.find( 'z' )
-1
>>> name.find( 'o' )
8
>>> name.find( 'M' )
0
>>> name.find( 'c' )
2
>>> name.find( "ou" )
8
>>> name
'Mickey Mouse'
>>> name.replace( "Mickey", "Minnie" )
'Minnie Mouse'
>>> name
'Mickey Mouse'
>>> name.replace( "Mouse", "Cat" )
'Mickey Cat'
>>> name
'Mickey Mouse'
>>> name.replace( 'M', 'Z' )
'Zickey Zouse'
>>> name
'Mickey Mouse'
>>>

2/23/18

# examples
# D. Thiebaut

line = "The quick red fox jumped over the lazy brown sleeping dog"
line.split( " " )   # that's a space



poem = """Chocolate
Chocolate is the first luxury.
It has so many things wrapped up in it:
Deliciousness in the moment,
childhood memories,
and that grin-inducing
feeling of getting a reward for being good.
--Mariska Hargitay"""

Working with Text Files

Here's the text to store in the text file called chocolate.txt. You can use Notepad or TextEdit to do that. Make sure you use ".txt" as the extension, and select "plain text" or "plain ASCII" as the format.

Strength is the capacity to break

a Hershey bar into four pieces

with your bare hands - and then

eat just one of the pieces.

-Judith Viorst

And here's the program that reads this file

# readChocolateFile.py
# D. Thiebaut
# Opens a text file and displays it contents.
# Note: you need to have a file called chocolate.txt
# in the same directory/folder where you have saved
# this program!!!
@

def main():
    # open file
    file = open( "chocolate.txt", "r" )

    # read each line from file and display it
    for line in file:
        print( line )

    # close the file
    file.close()

main()

2/26/18

# readChocolateFile.py
# D. Thiebaut
# Opens a text file and displays it contents.
# Note: you need to have a file called chocolate.txt
# in the same directory/folder where you have saved
# this program!!!


def main():
    # open file
    file = open( "chocolate.txt", "r" )

    # read each line from file and display it
    for line in file:
        print( line.strip() )

    # close the file
    file.close()

main()

# ----------------------------------------------------------------------


def singHappyBirthday( minion ):
    print( "Happy birthday to you" )
    print( "Happy birthday to you" )
    print( "Happy birthday, dear", minion )
    print( "Happy birthday to you" )
    print( )
    
def main():
    for minion in [ "Dave", "Stuart", "Jerry", "Jorge" ]:
        singHappyBirthday( minion )

main()

# ----------------------------------------------------------------------

# DaveEats.py
# D. Thiebaut


def DaveEats( fruit ):
    print( "Dave opens their mouth" )
    print( "and eats the", fruit )
    print()



def main():
    for fruit in [ "banana", "apple", "orange" ]:
        DaveEats( fruit )
        
    
main()

# ----------------------------------------------------------------------

# printBarSayHello.py
# D. Thiebaut


def printBar():
    print( 60 * '-' )


def sayHello():
    print( )
    print( "Hello, and welcome!" )
    print( )

def main():
    printBar()
    printBar()

main()
 

# ----------------------------------------------------------------------

3/2/2018

functionBootCamp2

# functionBootCamp2.py
# D. Thiebaut

def cutDNA( DNA, marker ):
    DNA = DNA.upper()
    marker = marker.upper()
      
    index = DNA.find( marker )
    index2 = index + len( marker )
    leftOver = DNA[ index2: ]
    return leftOver

def main():
    dna = "ACGTTTA"
    marker = "G"

    print( cutDNA( dna, marker ) )

    print( cutDNA( "AAAAATTTT", "at" ) )

main()

Program developed in Class

The assignment is to write a program that gets lines from a text file, representing a memo, and words from another text file, representing words to censure out of the memo. The program then takes both list of strings and blocks out all the bad words from the memo.

def block( bad, line ):
    """ takes a line and a bad word and replaces
    the bad word with xs"""
    xbad = "x" * len( bad )
    line = line.replace( bad, xbad )
    return line

def getMemo():
    memo = [ "Send 10 tons of burgers to White House",
             "before midnight", "That's a lot of burgers!" ]
    return memo

def getBad():
    bad = [ "burger", "tons", "House" ]
    return bad

def processMemo( lines, bad ):
    newLines = [ ]
    for line in lines:
        line = block( bad, line )
        newLines.append( line )
    return newLines

def main():
    lines = getMemo( )
    bads   = getBad()

    for bad in bads:
        lines = processMemo( lines, bad )

    for line in lines:
        print( line )
        
main()

Good Preparation for Homework #5

The same program is developed in several steps (versions) below. We start with a very simplified version of what we have to implement, and one step at a time we add more functionality, using functions.

Version 1

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured"""
    return "Please deliver 10 burgers and 1 bottle of ketchup"

def getBadWord():
    """gets the word to block out"""
    return "burger"

def main():
    # get a line of text, and a bad word 
    line = getMemo( )
    bad  = getBadWord( )

    # modify line by removing the bad word
    line = line.replace( bad, "x" )
    print( line )
    
main()

Version 2

In this version, we create a new function called block() that gets a line and a bad word, and replaces the bad word in line by a series of xs. Block() returns the new version of the line.

The main program now calls block() to block out the bad word in the line, gets the line back and prints it.

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured"""
    return "Please deliver 10 burgers and 1 bottle of ketchup"

def getBadWord():
    """gets the word to block out"""
    return "burger"

def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line
    
def main():
    # get a line of text, and a bad word 
    line = getMemo( )
    bad  = getBadWord( )

    # modify line by removing the bad word
    line = block( line, bad )

    # display the resulting line
    print( line )
    
main()

Version 3

In this version, instead of working with just one word, we work with a list of bad words. We change the name of getBadWord() to getBadWords() to reflect the fact that it is returning a list of words. We now have for loop in the main program to iterate through all the bad words.

You may want to remove the #-sign in the main program to see what is happening with the code.

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured"""
    return "Please deliver 10 burgers and 1 bottle of ketchup"

def getBadWords():
    """gets the word to block out"""
    badWords = [ "burger", "ketchup" ]
    return badWords

def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line
    
def main():
    # get a line of text, and a bad word 
    line = getMemo( )
    badWords  = getBadWords( )

    # modify line by removing the bad word
    for bad in badWords:
        #print( "blocking out word:", bad )
        #print( "line before:      ", line )
        line = block( line, bad )
        #print( "line after:       ", line )
        #print()

    # display the resulting line
    print( line )
    
main()

Output

blocking out word: burger
line before:       Please deliver 10 burgers and 1 bottle of ketchup
line after:        Please deliver 10 xxxxxxs and 1 bottle of ketchup

blocking out word: ketchup
line before:       Please deliver 10 xxxxxxs and 1 bottle of ketchup
line after:        Please deliver 10 xxxxxxs and 1 bottle of xxxxxxx

Please deliver 10 xxxxxxs and 1 bottle of xxxxxxx

Version 4

We're making the code more modular by taking some code from main and packaging into a new function, called blockAllWordsInOneLine().
No new behavior is brought in, just moving some code out of main to keep main short and easy to read.

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured"""
    return "Please deliver 10 burgers and 1 bottle of ketchup"

def getBadWords():
    """gets the word to block out"""
    badWords = [ "burger", "ketchup" ]
    return badWords

def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line

def blockAllWordsInOneLine( line, badWords ):
    """ gets one line and a list of bad words and
    blocks out all the bad words in the line.  Returns
    the edited line.
    """
    for bad in badWords:
        line = block( line, bad )
    return line

def main():
    # get a line of text, and a bad word 
    line = getMemo( )
    badWords  = getBadWords( )

    # modify line by removing the bad word
    line = blockAllWordsInOneLine( line, badWords )
        
    # display the resulting line
    print( line )
    
main()

Version 5

We now make the function getMemo() return a list of lines, rather than just one line.
The main program must be changed, since it is now getting a list of strings rather than one string. A for-loop is all that we need. Not much change, but much more powerful program!

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured"""
    memo = [ "Please deliver 10 burgers and 1 bottle of ketchup",
             "Make it 20 burgers and a caisse of ketchup",
             "burgers and ketchup are the best food!" ]
    
    return memo

def getBadWords():
    """gets the word to block out"""
    badWords = [ "burger", "ketchup" ]
    return badWords

def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line

def blockAllWordsInOneLine( line, badWords ):
    """ gets one line and a list of bad words and
    blocks out all the bad words in the line.  Returns
    the edited line.
    """
    for bad in badWords:
        line = block( line, bad )
    return line

def main():
    # get a line of text, and a bad word 
    lines = getMemo( )
    badWords  = getBadWords( )

    for line in lines:
        # modify line by removing the bad word
        line = blockAllWordsInOneLine( line, badWords )
        
        # display the resulting line
        print( line )
    
main()

Please deliver 10 xxxxxxs and 1 bottle of xxxxxxx
Make it 20 xxxxxxs and a caisse of xxxxxxx
xxxxxxs and xxxxxxx are the best food!

Version 6

In this version we change the getMemo() function so that it gets the lines of the memo from the file memo.txt. This file is already defined in the same directory where we save our programs. For this example, memo.txt contains the following lines:

We need 10 tons of burgers and 1 ton of ketchup 
sent to the President before midnight.

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured from the file memo.txt"""
    #memo = [ "Please deliver 10 burgers and 1 bottle of ketchup",
    #         "Make it 20 burgers and a caisse of ketchup",
    #         "burgers and ketchup are the best food!" ]

    # open the file for reading
    file = open( 'memo.txt', 'r' )

    # add each line of the file to memo (list)
    memo = []
    for line in file:
        memo.append( line.strip() )

    # close the file
    file.close()

    # return the list of string read from the file
    return memo

def getBadWords():
    """gets the word to block out"""
    badWords = [ "burger", "ketchup" ]
    return badWords

def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line

def blockAllWordsInOneLine( line, badWords ):
    """ gets one line and a list of bad words and
    blocks out all the bad words in the line.  Returns
    the edited line.
    """
    for bad in badWords:
        line = block( line, bad )
    return line

def main():
    # get a line of text, and a bad word 
    lines = getMemo( )
    badWords  = getBadWords( )

    for line in lines:
        # modify line by removing the bad word
        line = blockAllWordsInOneLine( line, badWords )
        
        # display the resulting line
        print( line )
    
main()

Output

We need 10 tons of xxxxxxs and 1 ton of xxxxxxx
sent to the President before midnight.

Version 7

Since we were successful getting the lines from file for the memo, we are doing the same thing for the bad words.

The file badwords.txt contains the following words:

burger
ketchup
President

# censureText.py
# D. Thiebaut
# This program opens two text files,
# one containing lines of text, the other one
# containing a list of words to remove,
# and prints the contents of the first file
# with words blocked out.

def getMemo():
    """gets the memo to be censured from the file memo.txt"""
    #memo = [ "Please deliver 10 burgers and 1 bottle of ketchup",
    #         "Make it 20 burgers and a caisse of ketchup",
    #         "burgers and ketchup are the best food!" ]

    # open the file for reading
    file = open( 'memo.txt', 'r' )

    # add each line of the file to memo (list)
    memo = []
    for line in file:
        memo.append( line.strip() )

    # close the file
    file.close()

    # return the list of string read from the file
    return memo

def getBadWords():
    """gets the list of words to block out from file"""
    # open the file for reading
    file = open( 'badwords.txt', 'r' )

    # add each line of the file to list of bad words
    bads = []
    for line in file:
        bad = line.strip()
        bads.append( bad )
        
    # close the file
    file.close()

    # return the list of string read from the file
    return bads


def block( line, bad ):
    # create a word with 'x' the same length
    # as the bad word
    badx = "x" * len( bad )

    # modify the line and replace bad with "xx...x"
    line = line.replace( bad, badx )
    return line

def blockAllWordsInOneLine( line, badWords ):
    """ gets one line and a list of bad words and
    blocks out all the bad words in the line.  Returns
    the edited line.
    """
    for bad in badWords:
        line = block( line, bad )
    return line

def main():
    # get a line of text, and a bad word 
    lines = getMemo( )
    badWords  = getBadWords( )

    for line in lines:
        # modify line by removing the bad word
        line = blockAllWordsInOneLine( line, badWords )
        
        # display the resulting line
        print( line )
    
main()

Output

We need 10 tons of xxxxxxs and 1 ton of xxxxxxx
sent to the xxxxxxxxx before midnight.

03/09/18

libraryDemo.py

# libraryDemo.py
# D. Thiebaut

from myLibrary import *

def main():
    lines = [ "Soon there'll be lunch", "Spring into action",
              "Break bad habits!" ]

    for line in lines:
        print( getFirstWordOf( line ), end=" " )

    print()

main()

myLibrary.py

# myLibrary.py
# D. Thiebaut


def getFirstWordOf( line ):
    '''receives a line assumed not to be empty
    and returns its first words.  Uses whitespace
    to split the line into words.
    '''
    words = line.strip().split()
    return words[0]

NQueens.py

#! /opt/local/bin/python
# D. Thiebaut
# Usage:
#   nqueens.py N
# where N is the number of queens wanted, i.e. the dimension
# of the board.
# The program will look for the first available solution where N queens
# can be put on the board such that they cannot take each other.

import sys
import time
QUEEN = -10
EMPTY = 0

class timePerfClass:
    """A class to keep track of processor and user time.
    use by first calling start(), then stop(), then 
    printElapsed()"""

    def __init__(self):
        self.clockStart = time.clock() # init all 4 counters
        self.clockEnd   = time.clock() # to current time
        self.timeStart  = time.time()
        self.timeEnd    = time.time()

    def start( self ):
        """set the start counters to current time"""
        self.clockStart = time.clock()
        self.timeStart  = time.time()

    def stop( self ):
        """set the end counters to current time"""
        self.clockEnd   = time.clock()
        self.timeEnd    = time.time()

    def printElapsed( self ):
        """print the difference between end and start counters"""
        print "processor time:   ", (self.clockEnd-self.clockStart), "sec"
        print "user time     :   ", (self.timeEnd-self.timeStart), "sec"


def makeBoard( N ):
    """create a 2-D array of ints with dimension N
    Returns the 2D array"""
    board = []
    for i in range( N ):
        board.append( [] )
        for j in range( N ):
            board[i].append( EMPTY )
    return board
    
def goHome():
    """when used  in a terminal window that supports ANSI codes,
    brings the cursor back to top left position"""
    sys.stderr.write( "\x1b[0;0H" )

def displaySolution( board ):
  """display the solution, in the form of a series of column numbers"""
  list = []
  for i in range( len( board ) ):
      for j in range( len( board ) ):
          if board[ i ][ j ]==QUEEN:
              list.append( str( j ) )
  print "Solution = ", ','.join( list )

def displayBoard( board, home=False ):
    """display the 2D array, showing empty cells as .
    and queens as Q"""
    if home: goHome()
    for i in range( len( board ) ):
        for j in range( len( board ) ):
            if board[i][j]==QUEEN: 
               print 'Q',
            else: 
               print '.',
        print
    displaySolution( board )
    
def markLowerBoard( board, row, col, offset ):
    """Once a queen is positioned at location (row,col), 
    all the cells on a lower diagonal and lower vertical
    of this queen must be marqued as unavailable so that
    another queen cannot be put in this place"""

    N = len( board )
    diagleft = col-1
    diagright = col+1
    # mark all lower rows on diagonals and vertical
    for r in range( row+1, N ):
        if diagleft >=0:  board[r][diagleft] += offset
        if diagright <N:  board[r][diagright] += offset
        board[r][col] += offset
        diagleft  -= 1
        diagright += 1

def tryRow( board, row,  N, display=False ):
    """ put a queen on give row, and recursively try all queens
    on successive rows"""
    if row >= N:
       return True #we found a solution!

    if display:
        displayBoard( board, True )
    for col in range( N ):
        if board[row][col] == EMPTY:
            # put a queen here
            board[ row ][ col ] = QUEEN
            markLowerBoard( board, row, col, +1 )
            ok = tryRow( board, row+1, N )
            if not ok:
                # backtrack
                board[ row ][ col ] = EMPTY
                markLowerBoard( board, row, col, -1 )
            else:
                return True
    return False           
           
       
# ---------------------------------------------------------------------------
def main():
    if len( sys.argv ) < 2:
        print "Syntax: nqueens.py N"
        print "        where N is the # of queens"
        return

    #--- start measurement ---
    perf = timePerfClass()
    perf.start()

    #--- get dimension, create board, and solve! ---
    N = int( sys.argv[1] )
    board = makeBoard( N )
    ok = tryRow( board, 0, N )

    #--- stop measurement ---
    perf.stop()
    perf.printElapsed()
    
    if ok:
         print "Success!"
         displayBoard( board )

if __name__=="__main__":
    main()

03/19/18

facebookNews.txt

This file is taken from a news article published on 3/18/2018 about Facebook.

Lawmakers in the United States and Britain are calling on Facebook chief executive Mark Zuckerberg 
to explain how the names, preferences and other information from tens of millions of users ended up 
in the hands of a data analysis firm connected with President Trump's 2016 campaign.

The demands came in response to news reports Saturday about how the firm, Cambridge Analytica, used 
a feature once available to Facebook app developers to collect information on 270,000 people and, 
in the process, gain access to data on tens of millions of their Facebook friends  few, if any, 
of whom had given explicit permission for this sharing.

emails.txt

Lauryn@smith.edu
Amaris@smith.edu
Lujun@smith.edu
Cora@smith.edu
smithy@umass.edu
Olive@smith.edu
Giuliana@smith.edu
Marina@smith.edu
Aliyah@smith.edu
Itzel@hampshire.edu
Rui@smith.edu
Perla@smith.edu
Julissa@smith.edu
Linda@smith.edu
Carolina@smith.edu
Beatrice@smith.edu
Carly@smith.edu
Iris@umass.edu
Lu@smith.edu
Armani@smith.edu
Julianna@smith.edu
Mattie@smith.edu
Diya@smith.edu
Maria@smith.edu
Payten@smith.edu
Caroline@amherst.edu
Gemma@smith.edu
Jade@smith.edu
Scarlet@smith.edu
Alejandra@smith.edu
Phoebe@smith.edu
Harper@smith.edu
Tianna@smith.edu
Litzy@smith.edu
Adison@mtholyoke.edu
Isabell@smith.edu
Yuliana@smith.edu
Lillian@smith.edu
Callie@smith.edu
Hadley@smith.edu
Camille@smith.edu
Tara@smith.edu
Desirae@smith.edu
Miya@smith.edu
Laura@smith.edu
Leticia@smith.edu
Emily@smith.edu
Krista@smith.edu
Ashtyn@smith.edu
Alina@smith.edu
Tiara@smith.edu
Cameron@smith.edu
Amaya@smith.edu
Jewel@smith.edu
Brenda@smith.edu
Angel@smith.edu
Anahi@smith.edu
Lara@smith.edu
Regina@smith.edu
Mylie@smith.edu
Kyra@smith.edu
Lindsay@smith.edu
Katherine@smith.edu
Raven@smith.edu
Chloe@smith.edu
Wendy@smith.edu
Amara@smith.edu
Adelyn@smith.edu
Sharon@smith.edu
Carlee@smith.edu
Aisha@smith.edu
Chana@smith.edu
Paisley@smith.edu
Amelie@smith.edu
Dixie@smith.edu
America@smith.edu
Karla@smith.edu
Alana@smith.edu
Dulce@smith.edu
Marlene@smith.edu
Serena@smith.edu
Annabel@smith.edu
Karley@smith.edu
Lyla@smith.edu
Sandra@smith.edu
Breanna@smith.edu
Gracelyn@smith.edu
Crystal@smith.edu
Taniya@smith.edu
Jazmin@smith.edu
Madalyn@smith.edu
Holly@smith.edu
Janiya@smith.edu
Paige@smith.edu
Jaylene@smith.edu
Cecelia@smith.edu
Jaylynn@smith.edu
Tori@smith.edu
Madeline@smith.edu
Aliza@smith.edu
Rebekah@smith.edu
Kimora@smith.edu
Mayra@smith.edu
Shea@smith.edu
Ana@smith.edu
Britney@smith.edu
Aleena@smith.edu
Yaritza@smith.edu
Bridget@smith.edu
Lindsey@smith.edu
Ava@smith.edu
Yareli@smith.edu
Violet@smith.edu
Londyn@smith.edu
Tatum@smith.edu
Patience@smith.edu
Ayana@smith.edu
Lizbeth@smith.edu
Madison@smith.edu
Elisabeth@smith.edu
Halle@smith.edu
Hallie@smith.edu
Ashley@smith.edu
Evelyn@smith.edu
Evelin@smith.edu

writeThankYous.py

# writeThankYous.py
# D. Thiebaut

def writeFile( fileName, name, amount ):
    file1 = open( fileName, "w" )
    thankYou = "Dear {0:1}, thank you very much for your gift of ${1:1}!\n".format( name, amount )
    file1.write( thankYou )
    file1.close()
    
def main():
    names = [("Alex", 100), ("Joe", 10), ("Fifi", 50)]

    for name, amount in names:
        #print( tuple )
        #name = tuple[0]
        #amount = tuple[1]
        #print( "name = ", name, "amount = ", amount )
        fileName = name + ".txt"
        writeFile( fileName, name, amount )

main()

readEmails2.py

# readEmails.py
# D. Thiebaut

def writePoem( fileName, text ):
    file3 = open( fileName, "w" )
    file3.write( text )
    file3.close()
    
def numberOfLines( fileName ):
    file1 = open( fileName, "r" )
    text = file1.read().strip()
    file1.close()
    lines = text.split( "\n"  )
    return len( lines )
    
def main():
    #print( "number of emails = ", numberOfLines( "emails.txt" ) )
    text = """The quick red fox
    jumped over the lazy brown dog"""
    writePoem( "poem.txt", text )
    
    
main()

03/21/18

randomColor1.py

# randomColor1.py
# your name here
# generates a rectangle with a random width
# and height, and a given color on the screen.

from graphics import *
from random import *

def main():
    win = GraphWin("Lab 7", 600,600)

    # create rectangle with these 2 corners
    r = Rectangle( Point(50,50), Point(300,300) )

    # create a color from 3 different RGB values
    red   = randint( 0, 255 )
    green = randint( 0, 255 )
    blue  = randint( 0, 255 )
    color = color_rgb( red, green, blue )

    # set the rectangle's color with this color
    r.setFill( color )

    # draw the rectangle
    r.draw( win )

    # wait for user to click on the window before closing
    win.getMouse()
    win.close()
    
main()

animation.py

# animation.py
# D. Thiebaut
# Moves a red circle on the graphics window.
# Waits for user to click the mouse in order to stop.
from graphics import *

def main():
    win = GraphWin( "Lab 7 Moving ball", 600, 400 )

    # create and draw a red circle
    center = Point( 100, 100 )
    circ     = Circle( center, 30 )
    circ.setFill( 'red' )
    circ.draw( win )

    # set initial direction of ball
    dx = 1.5
    dy = 0.25
    
    # move ball on screen
    while win.checkMouse() == None:
        circ.move( dx, dy )
        #x = circ.getCenter().getX()
        #y = circ.getCenter().getY()
    
    win.close()    # Close window when done

main()

3/23/18

tellerWithIfsPrep.py

# teller.py
# D. Thiebaut
# simulates teller machine program
# prompts user, displays number of bills

def getAmount():
    # get amount from user
    amount = eval( input( "Amount to withdraw? " ) )
    amount = abs( int( amount ) )
    
    # return valid amount
    return amount

def breakDown( amount, denom ):
    numBills = amount // denom
    amount   = amount % denom
    return numBills, amount

def display( numBills, denom ):
    print( "{0:2} ${1:1}-bill(s)".format( numBills, denom ) )

def main():
    # get amount from user
    amount = getAmount()
    print( "Amount:", amount )

    # break it down into 20, 10, 5, and 1 $bills
    no20s, amount = breakDown( amount, 20 )
    no10s, amount = breakDown( amount, 10 )
    no5s,  no1s   = breakDown( amount, 5 )

    # display number of bills
    display( no20s, 20 )
    display( no10s, 10 )
    display( no5s,  5 )
    display( no1s,  1 )

main()

stopForLoop.py

# stopForLoop.py
# D. Thiebaut
# (there are better ways to do this,
# but when we don't know about the
# "break" statement, this will do!

def main():

    plays = [ "SS", "PP", "PS", "SP", "PR", "RR", "RR" ]

    count = 0
    for players in plays:
        if count < 3:
            print( "processing", players )
            
        count = count + 1

main()

filterVowels.py

# filterVowels.py
# D. Thiebaut
# gets a string from user
# and keep only the vowels in the string

def main():
    answer = input( "> " ).strip().lower()
    valid = ""
    for letter in answer:
        if letter in [ 'a', 'e', 'i', 'o', 'u' ]:
            valid = valid + letter

    print( "valid letters = ", valid )

main()

RPSSkeleton.py

# RPSSkeleton.py
# D. Thiebaut
# implements a skeleton game of Rock, Paper, Scissors

# 3 constants indicating the output of 1 play
PLAYER1WINS = 1
PLAYER2WINS = 2
TIE = 0

def check( P1, P2 ):
    '''given two upper case letters in P1, and P2 equal to
    "R", "S", or "P", decides which of P1 or P2 is the winner.'''

    # tie?
    if P1 == P2:
        return TIE
    else:
        # no tie, so check for all other possible combinations
        # of P1 and P2.
        if P1 == "R":
            if P2 == "S":
                return PLAYER1WINS
            else:
                return PLAYER2WINS
        if P1 == "S":
            if P2 == "R":
                return PLAYER2WINS
            else:
                return PLAYER1WINS
        if P1 == "P":
            if P2 == "S":
                return PLAYER2WINS
            else:
                return PLAYER1WINS
            
            
            
def main():
    # keep track of the score of each player
    score1 = 0
    score2 = 0

    # create a list of possible plays...
    plays = [ "RR", "RS", "SP", "PP", "PR" ]

    # evaluate the outcome of each play in the list
    for play in plays:
        #play = input( "> " ).strip().upper()
        print( "play = ", play )

        # define Player 1 and Player 2
        P1 = play[0]
        P2 = play[1]

        # output will be PLAYER1WINS, PLAYER2WINS, or TIE
        outcome = check( P1, P2 )

        # display who the winner is
        if outcome == PLAYER1WINS:
            print( "Player 1 wins" )
            score1 = score1 + 1
        if outcome == PLAYER2WINS:
            print( "Player 2 wins" )
            score2 = score2 + 1
        if outcome == TIE:
            print( "It's a tie!" )

        # update the user with the current score
        print( "Player1:", score1, "  Player2:", score2 )
        
main()

3/26/18

distanceDemo.py

# distanceDemo.py
# D. Thiebaut
# A simple program that tests a function returning
# the distance between 2 graphic points (using the
# graphics.py library)
from math import *
from graphics import *

def distance( x1, y1, x2, y2 ):
    '''returns the distance between two points with
    coordinates (x1,y1) and (x2,y2)'''
    return sqrt( (x1-x2)*(x1-x2) +
                 (y1-y2)*(y1-y2) )

def distanceP( p1, p2 ):
    '''returns the distance between two graphics
    points'''
    x1, y1 = p1.getX(), p1.getY()
    x2, y2 = p2.getX(), p2.getY()
    return distance( x1, y1, x2, y2 )

def main():
    point1 = Point( 3, 5 )  # difference in x = 4
    point2 = Point( 7, 8 )  # difference in y = 3 ==> distance is 5
    d = distanceP( point1, point2 )
    print( "distance =", d )

main()

Eliza1.py

# Eliza1.py
# D. Thiebaut
# A very short beginning program for Eliza
from time import sleep
from os import system

# --------------------------------------------------------------------------
# just print the string to the console
# will be transformed to something better later...
def myprint( string ):
    print( string )
    #system('say ' + string )
    #sleep( 0.5 )
    
# sayGoodBye
# say goodbye to the user.
def sayGoodBye( name ):
    myprint( "Good bye " + name )

# isGoodBye
# checks to see if what the user said is one of the keywords for
# ending the conversation.
def isGoodBye( userAnswer ):
    if userAnswer.lower().strip() in [ "bye", "goodbye", "ciao" ]:
        return True
    else:
        return False

def greetings():
    myprint( "Hello there!" )
    myprint( "What is your name?" )
    name = input( "> " )
    myprint( "Welcome " + name )
    return name

# --------------------------------------------------------------------------
# main function
# --------------------------------------------------------------------------                   
def main():

     # greet user and get her name
     userName = greetings()
     
     # conversation: get user input, and respond
     for i in range( 1000 ):

         # get user's statement
         userAnswer = input( "> " )

         # if it is a goodbye statement, exit the loop
         if isGoodBye( userAnswer ) == True:
             break

         # tell the user to continue speaking
         myprint( "Please tell me more..." )


     # if we're here, it's because the loop stopped.
     # say goodbye to the user
     sayGoodBye( userName )
            
         
main()

Eliza2.py

# Eliza2.py
# D. Thiebaut (created in class on 3/28)
# A very short beginning program for Eliza
from time import sleep
from os import system
from random import choice

# --------------------------------------------------------------------------
# just print the string to the console
# will be transformed to something better later...
def myprint( string ):
    print( string )
    #system('say ' + string )
    #sleep( 0.5 )
    
# sayGoodBye
# say goodbye to the user.
def sayGoodBye( name ):
    myprint( "Good bye " + name )

# isGoodBye
# checks to see if what the user said is one of the keywords for
# ending the conversation.
def isGoodBye( userAnswer ):
    if userAnswer.lower().strip() in [ "bye", "goodbye", "ciao" ]:
        return True
    else:
        return False

def greetings():
    myprint( "Hello there!" )
    myprint( "What is your name?" )
    name = input( "> " )
    myprint( "Welcome " + name )
    return name

# --------------------------------------------------------------------------
# main function
# --------------------------------------------------------------------------                   
def main():

     prompts = ["Please go on...", "Please tell me more...",
            "Interesting... Go on, please", 
            "Yes?  Really? Go on",
            "Weird... I'm not sure what to think of that..." ]

     family = [ "mother", "father", "brother", "sister" ]
     
     # greet user and get her name
     userName = greetings()
     
     # conversation: get user input, and respond
     for i in range( 1000 ):

         # get user's statement
         userAnswer = input( "> " )

         # if it is a goodbye statement, exit the loop
         if isGoodBye( userAnswer ) == True:
             break # break out of for-loop

         familyMatter = False
         for word in family:
             if userAnswer.lower().find( word ) != -1:
                 familyMatter = True

         if familyMatter == True:
             myprint( "tell me more about your family" )
         else:
             # tell the user to continue speaking
             myprint( choice( prompts ) )


     # if we're here, it's because the loop stopped.
     # say goodbye to the user
     sayGoodBye( userName )
            
         
main()

3/30/18

YesNo.py

# get a YES/NO answer from user
def getAnswerYesNo():
   x = input( "Continue (Yes/No)? " ).upper()
   while x != "NO" and x != "YES":
       print( "Invalid input, must be YES or NO" )
       x = input( "Continue (Yes/No)? " ).upper()
   return x

def getAnswerYesNo2():
   x = input( "Continue (Yes/No)? " )
   while not x.upper() in [ "NO", "YES", "NOPE", "YEAH" ]:
       print( "Invalid input, must be YES or NO" )
       x = input( "Continue (Yes/No)? " )
   return x

def main():
    ans = getAnswerYesNo()    
    print( ans )                

    ans = getAnswerYesNo2()    
    print( ans )                

main()

Eliza3.py

# Eliza3.py
# D. Thiebaut
# This version of Eliza implements reflection and detection
# of negative comments
from time import sleep
from os import system
from random import choice

# --------------------------------------------------------------------------
# just print the string to the console
# will be transformed to something better later...
def myprint( string ):
    print( string )
    # system('say ' + string )
    # sleep( 0.5 )
    
# sayGoodBye
# say goodbye to the user.
def sayGoodBye( name ):
    myprint( "Good bye " + name )

# isGoodBye
# checks to see if what the user said is one of the keywords for
# ending the conversation.
def isGoodBye( userAnswer ):
    if userAnswer.lower().strip() in [ "bye", "goodbye", "ciao" ]:
        return True
    else:
        return False

def greetings():
    myprint( "Hello there!" )
    myprint( "What is your name?" )
    name = input( "> " )
    myprint( "Welcome " + name )
    return name

# --------------------------------------------------------------------------
# main function
# --------------------------------------------------------------------------                   
def main():

     prompts = ["Please go on...", "Please tell me more..." ]
     negPrompts = [ "My, my, why so negative?", "Really?", "Why not?" ]
     family = [ "mother", "father", "brother", "sister" ]
     
     # greet user and get her name
     userName = greetings()
     
     # conversation: get user input, and respond
     timeToStop = False
     while timeToStop==False:

         # get user's statement
         userAnswer = input( "> " )

         # if it is a goodbye statement, exit the loop
         if isGoodBye( userAnswer ) == True:
             timeToStop = True
             continue

         # is the patient talking about a family member?
         for word in family:
             if userAnswer.lower().find( word ) != -1:
                 myprint( "tell me more about your family" )
                 continue


         # reflection
         # "I XXXX you" --> "You XXXX me?"
         words = userAnswer.strip().split()
         if len( words )==3 and words[0]=="I" and words[2]=="you":
             myprint( "You " + words[1] + " me?" )
             prompts.append( "Is that why you " + words[1] + " me?" )
             continue
             
         # negative answers
         if userAnswer.upper() in [ "NO", "NEVER", "NOPE", "NADA", "NON" ]:
             myprint( choice( negPrompts ) )
             continue
         
         # if we're here, it's because none of the tests above were true,
         # and we didn't detect a negative answer, a family matter, or a
         # reflection.  So we just print a random prompt.
         myprint( choice( prompts ) )


     # if we're here, it's because the loop stopped.
     # say goodbye to the user
     sayGoodBye( userName )
            
         
main()

4/2/18

readCSV.py

# readCSVFile.py
# D. Thiebaut
# Example of a program that reads a CSV file
# and displays some of its contents.

def readCSV( fileName ):
    file = open( fileName, 'r' )
    Records = [ ]
    lines = file.readlines()
    for line in lines:
        #words = line.replace( '"','').strip().split( ',' )
        words = line.replace( '"','').strip().split( ',' )
        Records.append( words )
    file.close()
    return Records

def main():
    fileName = input( "File name? " )
    recs = readCSV( fileName )
    for i in range( len( recs ) ):
        record = recs[i]
        # record is a tuple
        # join each word in the tuple by a tab, and print
        # resulting string
        print( "Record ", i, "=", "\t".join( record ) )

main()

dieClass.py

# dieClass.py
# D. Thiebaut
# A class for the definition of a simple
# die, with any number of sides

# libraries
from random import *

# a class for a die
class Die:
    def __init__( self, n ):
         self.noSides = n
         self.value   = 1

    def roll( self ):
         self.value = randrange( 1, self.noSides+1 )

    def getValue( self ):
         return self.value

playDice.py

# playDice.py
# D. Thiebaut
# Uses the Class.py class
# and plays with a few dice

from dieClass import Die

def main():
    # Create 2 dice, one with 6 sides
    d1 = Die( 6 )
    d2 = Die( 8 )

    for play in range( 10 ):
        print( "\nPlay No.", play+1 )
        # Roll both dice
        d1.roll( )
        d2.roll( )

        # display their value
        print( "Die 1: ",  d1.getValue() )
        print( "Die 2: ",  d2.getValue() )

main()

Main Program for Cat Objects

# cats1.py
# D. Thiebaut
# Define a Cat class, and
# use it to create a collection of
# cats.

# -----------------------------------------------------------
# add class definition here!


# -----------------------------------------------------------
# main program
def main():
    """ main program.  Creates a list of cats and displays
    groups sharing the same property.
        Minou, 3, vac, stray
        Max, 1, not-vac, Burmese
        Gizmo, 2, vac, Bengal
        Garfield, 4, not-vac, Orange Tabby
    """
    cats = []
    cat = Cat( "Minou", "stray", True, 3 )
    cats.append( cat )
    
    cats.append( Cat( "Max", "Burmese", False, 1 ) )
    cats.append( Cat( "Gizmo", "Bengal", True, 2 ) )
    cats.append( Cat( "Garfield", "Orange Tabby", False, 4 ) )

    # print the list of all the cats
    print( "\nComplete List:" )
    for cat in cats:
        print( cat )

   


main()

4/4/18

cats.py with class

class Cat:
    def __init__( self, na, vacc, bre, ag ):
        self.name       = na
        self.vaccinated = vacc
        self.breed      = bre
        self.age        = ag

    def isVaccinated( self ):
        return self.vaccinated

    def getName( self ):
        return self.name

    def getAge( self ):
        return self.age
    
    def __str__( self ):
        vacc = "vaccinated"
        if self.vaccinated == False:
            vacc = "not vaccinated"
        return "{0:20}:==>{1:1}, {2:1}, {3:1} yrs old".format(
            self.name, self.breed, vacc, self.age )
    
def main():
    cats = [ ]
    
    # Minou, 3, vac, stray
    cat1 = Cat( "Minou", False, "stray", 3 )
    cats.append( cat1 )
    # Print if cat is vaccinated or not
    if cat1.isVaccinated():
        print( cat1.getName(), "is vaccinated" )
    else:
        print( cat1.getName(), "is not vaccinated" )
    """
    Minou, 3, vac, stray
    Max, 1, not-vac, Burmese
    Gizmo, 2, vac, Bengal
    Garfield, 4, not-vac, Orange Tabby"""

    cats.append( Cat( "Max", False, "Burmese", 1 ) )
    cats.append( Cat( "Gizmo", True, "Bengal", 2 ) )
    cats.append( Cat( "Garfield", False, "Orange Tabby", 4 ) )

    for cat in cats:
        if cat.getAge() >= 2 and not cat.isVaccinated():
            print( cat )
    
    
main()

4/6/18

Car Class. Version 1

# carClass.py
# D. Thiebaut
# Example program where we create a class for a car
# made of a body (rectangle) and two wheels.

from graphics import *

N = 5 # number of cars

class Car:
    '''a definition for a car made of a rectangle
    and two circles'''

    def __init__( self, topLeft, width, height ):
        '''constructor.  Builds a car from topLeft point,
        width, and height'''

        # save reference point and height and width  
        self.topLeft = topLeft
        self.width   = width
        self.height  = height
        
        # create bottom-right point P1
        x1 = topLeft.getX()
        y1 = topLeft.getY()
        P2 = Point( x1+width, y1+height )

        # create body
        self.body = Rectangle( topLeft, P2 )

        # create two wheels
        center1 = Point( x1+40, y1+height )
        self.wheel1 = Circle( center1, 20 )
        center2 = Point( x1+width-40, y1+height )
        self.wheel2 = Circle( center2, 20 )

        # define colors
        self.body.setFill( "yellow" )
        self.wheel1.setFill( "black" )
        self.wheel2.setFill( "black" )

    def draw( self, win ):
        '''draw the car on the window '''
        self.body.draw( win )
        self.wheel1.draw( win )
        self.wheel2.draw( win )

    def move( self, dx, dy ):
        ''' move the car (body and wheels) by dx, dy '''
        self.body.move( dx, dy )
        self.wheel1.move( dx, dy )
        self.wheel2.move( dx, dy )
        
def main():
    win = GraphWin( "Moving cars", 600, 400 )

    # create N cars
    cars = [ ]
    for i in range( N ):
        car1 = Car(  Point( 30,60*i ), 190, 40 )
        cars.append( car1 )

    # draw N cars
    for car1 in cars:
        car1.draw( win )

    # move N cars 20 dx pixels to the right
    dx = 10
    dy = 0
    for i in range( 20 ):
        for car1 in cars:
           car1.move( dx, dy )
      
    # wait for user to click the mouse 
    win.getMouse()
    win.close()    # Close window when done

main()

A more advanced Car class

# carClassDemo.py
# D. Thiebaut
# A program that defines a class for cars,
# and a demo main program that displays
# several cars.

# import all graphic objects
from graphics import *
from random import randrange

# constants
N = 5 # number of cars

class Car:
    """Definition for a car with a body and two wheels"""

    def __init__(self, win, topLeft, width, height ):
        """constructs a car made of 1 rectangle with top-left
        point topLeft, dimension width x height, and two wheels
        away from left and right by 10 pixesl"""
        # save width and height of car
        self.width = width
        self.height = height
        
        # create bottom-right point
        x1 = topLeft.getX()
        y1 = topLeft.getY()
        P2 = Point( x1+width, y1+height )

        # body is a rectangle between topLeft and P2
        self.body = Rectangle( topLeft, P2 )
        self.body.setFill( "yellow" )

        # create wheel #1
        center1 = Point( x1+20, y1+height )
        self.wheel1 = Circle( center1, 20 )
        self.wheel1.setFill( "black" )

        # create wheel #2
        center2 = Point( x1+width-20, y1+height )
        self.wheel2 = Circle( center2, 20 )
        self.wheel2.setFill( "black" )

        # create random speed
        self.dx = randrange( -100, 100 )/10

        # save window width (so that a car can detect
        # that it's going outside the left or right
        # margins)
        self.windowWidth = win.getWidth()

    def setFill( self, color ):
        '''sets the color of the body of the car'''
        self.body.setFill( color )
        
    def draw( self, win ):
        """draw the car on the window"""
        self.body.draw( win )
        self.wheel1.draw( win )
        self.wheel2.draw( win )
            
    def move( self ):
        """move the body and wheels of the car by dx"""
        self.body.move( self.dx, 0 )
        self.wheel1.move( self.dx, 0 )
        self.wheel2.move( self.dx, 0 )

        # is P1 outside the right margin?
        x = self.body.getP1().getX()
        if x > self.windowWidth:
            # yes! move the car to the left of the left margin
            self.body.move( -self.windowWidth-self.width, 0 )
            self.wheel1.move( -self.windowWidth-self.width, 0 )
            self.wheel2.move( -self.windowWidth-self.width, 0 )
            
        x = self.body.getP2().getX()
        # is P2 outside the left margin?
        if x < 0:
            # yes!  move the car to the right of the right margin
            self.body.move( +self.windowWidth+self.width, 0 )
            self.wheel1.move( +self.windowWidth+self.width, 0 )
            self.wheel2.move( +self.windowWidth+self.width, 0 )

def main():
        # open graphic window
        win = GraphWin( "Car Park", 700, 600 )

        # create a list of N cars
        cars = [ ]
        for i in range( N ):
            car =  Car( win, Point( randrange(1,700),
                                    randrange(1,500) ),
                        randrange( 100, 200),
                        randrange( 30, 50 ) ) 
            car.setFill( color_rgb( randrange( 0, 100 ),
                                    randrange( 100, 200 ),
                                    randrange( 100, 200 ) ) )
            cars.append( car )

        # draw all cars
        for car in cars:
            car.draw( win )

        # animation loop: move all the cars, until
        # user clicks mouse
        while True:
            if win.checkMouse(): break
            for car in cars:
                car.move( )
                         
        # wait for mouse-click
        win.getMouse()
        win.close()

main()

4/9/18

catGlasses.gif, 424 × 418

FlowersSmith.gif, 661 × 255

catHat.gif, 243 × 207

imageProcessingSkel.py

# imageProcessingSkel.py
# D. Thiebaut
# A skeleton program to start doing image processing
# in Python
from graphics import *
# image geometry = 424x18
# make the window the same geometry

WIDTH  = 424
HEIGHT = 418

def main():
    # open the window
    win = GraphWin( "CSC111 Image Viewer", WIDTH, HEIGHT )

    # get the file name from the user
    fileName = "catGlasses.gif" #input( "Image name? " )
    print()
    
    # open the cat image
    cat = Image( Point(WIDTH//2, HEIGHT//2), fileName )
    cat.draw( win )

    # wait for user to click the mouse...
    win.getMouse()

    # and close the window
    win.close()

main()

ImageProcessingRedSaturate.py

# ImageProcessingRedSaturate.py
# D. Thiebaut
# A skeleton program to start performing some image processing
# in Python.  Here we set pixels redder, and saturate the colors.

from graphics import *
from random import *


#WIDTH  = 661   # width and height of flowers.gif
#HEIGHT = 255

#WIDTH  = 424  # width and height for CatGlasses.gif
#HEIGHT = 418

WIDTH  = 243   # width and height for catHat.gif
HEIGHT = 207

def saturate( col ):
    '''given a color between 0 and 255, return 0 if the color
    is less than half 255, or 255 otherwise.  This will saturate
    the color'''
    if col < 255/2:
        return 0
    else:
        return 255

def makeRed( img, win ):
    '''given an image of geometry WIDTH x HEIGHT, touches
    all the pixels of the image and sets their RED component to
    255.'''

    for x in range( WIDTH ):
        win.update()
        for y in range( HEIGHT ):
            red, green, blue = img.getPixel( x, y )

            red = 255 

            # other possible transformations:
            #red = saturate( red )
            #green = randint( 0, 255 )
            #blue  = saturate( blue )
            img.setPixel( x, y, color_rgb( red, green, blue ) )
            

def drawBorder( img, win ):
    '''draws the beginning of a border at the top of the
    image.  The border is 20 pixels high, and red.'''
    for x in range( WIDTH ):
        for y in range( 20 ):
            img.setPixel(x,y, color_rgb( 255, 0, 0 ) )
        
def main():
    # open the window
    win = GraphWin( "CSC111 Image Viewer", WIDTH, HEIGHT )

    # get the file name from the user
    #fileName = "flowers.gif" #input( "Image name? " )
    #fileName = "CatGlasses.gif"
    fileName = "catHat.gif"
    print()
    
    # open the cat image
    cat = Image( Point(WIDTH//2, HEIGHT//2), fileName )
    cat.draw( win )

    # change the pixels to max red
    makeRed( cat, win )
    
    # change the pixels to max red
    drawBorder( cat, win )
    win.update()
    
    # wait for user to click the mouse...
    win.getMouse()

    # and close the window
    win.close()

main()

4/11/18

ImageProcessingCopy.py

# imageProcessingCopy.py
# D. Thiebaut
# A skeleton program to start doing image processing
# in Python
from graphics import *
# image geometry = 424x18
# make the window the same geometry

# catHatLong.gif
# 729 × 207

WIDTH  = 729          # 3 times the width of the cat
CATWIDTH = WIDTH // 3 # just the cat
HEIGHT = 207

def copy( win, img, srcX, offset, width ):
    '''copy part of the image starting at srcX, width pixels
    horizontally, at srcX+offset. Copies whole height of pixels.'''
    for x in range( srcX, srcX + width ):
        win.update()
        for y in range( 0, HEIGHT ):
            r,g,b = img.getPixel( x, y )
            color = color_rgb( r,g,b )
            img.setPixel( x+offset, y, color )
            
def main():
    # open the window
    win = GraphWin( "CSC111 Image Viewer", WIDTH, HEIGHT )

    # get the file name from the user
    fileName = "catHatLong.gif" #input( "Image name? " )
    print()
    
    # open the cat image
    cat = Image( Point(WIDTH//2, HEIGHT//2), fileName )
    cat.draw( win )

    # replicate the cat, from 0 to 1 CATWIDTH away,
    # copy CATWIDTH pixels, horizontally
    copy( win, cat, 0, CATWIDTH, CATWIDTH )
    copy( win, cat, 0, CATWIDTH*2, CATWIDTH )
    
    # wait for user to click the mouse...
    win.getMouse()

    # and close the window
    win.close()

main()

checkers0.py

# checkers0.py
# D. Thiebaut
# A first program to display an 8x8 chessboard
# in a graphic window.
# 
from graphics import *

WIDTH = 600    # width of the window
HEIGHT= 600    # height of the window
SIDE  = 600//8 # the side of a cell of the 8x8 board


def displayBoard( win ):
    """displays 8x8 cells covering the whole window."""   
    for i in range( 8 ):
        for j in range( 8 ):
            x = i * SIDE   # the coordinates of the top-left corner of a cell
            y = j * SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            rect.setFill( color_rgb( 50, 200, 50 ) )
            #rect.setFill( color_rgb( 255-(i+j)*10, i*j*3,  255-i*j*3 ) )
            rect.draw( win )
            
#----------------------------------------------------------------
def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase


def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # wait for user to click before closing everything...
    waitForClick( win, "click to close" )

    win.close()

main()

checkers2_incomplete.py

# checkers2.py
#
from graphics import *

WIDTH = 600
HEIGHT= 600
SIDE  = 600 // 8

# ------------------------------------------------------------
class CheckersPiece:
    '''a class for a checkers piece.  Made of 2 circles
    of different colors.  Can be light grey if white piece,
    or dark grey if black piece'''
    
    def __init__( self, color, i, j, win ):
        '''creates a piece at i, j, and draws it on window'''
        
        self.color = color
        self.i     = i
        self.j     = j
        self.circ1 = Circle( Point( (i+0.5)*SIDE, (j+0.5)*SIDE ),
                             (SIDE//2)-5 )
        self.circ2  = Circle( Point( (i+0.5)*SIDE, (j+0.5)*SIDE ),
                             (SIDE//2)-10 )
        if color=="black":
            self.circ1.setFill( "black" )
            self.circ2.setFill( "darkgrey" )
        else:
            self.circ1.setFill( "lightgrey" )
            self.circ2.setFill( "white" )
            
        self.circ1.draw( win )
        self.circ2.draw( win )
# ------------------------------------------------------------

        
def isBlack( i, j ):
    '''given the row and column of a square,
    returns True if the square is black.  False otherwise.
    '''
    if (i+j)%2==0:
        return True
    return False

def isWhite( i, j ):
    '''returns True if square at i,j is white'''
    return not isBlack( i, j )

        
def displayBoard( win ):
        
    for i in range( 0, 8 ):
        for j in range( 0, 8 ):
            x = i * SIDE
            y = j * SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if isWhite(i, j):
                rect.setFill( "white" )
            else:
                rect.setFill( "grey" )
            rect.draw( win )
 
def displayCheckers( win ):
    # display checkers
    # add code here!
    # ...
    
def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""

    # wait for user to click mouse to start
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ), message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase


def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # display the checkers on top of the board.
    # 3 rows of white checkers on black cells
    # and 3 rows of black checkers on white cells
    whites, blacks = displayCheckers( win )
                       
    waitForClick( win, "click to close" )

    win.close()

main()

4/13/18

checkers4.py

Make sure you download these two gif images first, and store them in the same directory where you will store your checkers4.py program. The left image is called piece.gif and the one on the right piece2.gif.
   

# checkers4.py
# D. Thiebaut
# Displays the images for the checkers.
#
from graphics import *

WIDTH = 680
HEIGHT= 680
SIDE  = 680 // 8

class CheckersPiece:
    def __init__( self, color, i, j, win ):
        self.color = color
        self.i     = i
        self.j     = j
        if color=="white":
            self.image = Image( Point( i*SIDE + SIDE//2,
                                       j*SIDE + SIDE//2 ), "piece2.gif" )
        else:
            self.image = Image( Point( i*SIDE + SIDE//2,
                                       j*SIDE + SIDE//2 ), "piece.gif" )
            
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()
        
def displayBoard( win ):
    for i in range( 0, 8 ):
        for j in range( 0, 8 ):
            x = i * SIDE
            y = j * SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if isWhite( i, j ):
                rect.setFill( "white" )
            else:
                rect.setFill( "grey" )
            rect.draw( win )
            #Text( Point( x+side//2, y+side//2 ),
            #      "{0:1} {1:1}".format( i, j ) ).draw(win)

def isBlack( i, j ):
    """returns True if the cell identified by (i,j) is
    a white cell on the board.  White cells correspond to
    i+j being an even number."""
    return (i+j) % 2 == 0

def isWhite( i, j ):
    return not isBlack( i, j)

def displayCheckers( win ):
    # display checkers
    checkers = []
    for i in range( 8 ):
        for j in range( 0, 3 ):
            if isBlack( i, j ):
                checkers.append( CheckersPiece( "white", i, j, win ) )

        for j in range( 5, 8 ):
            if isBlack( i, j ):
                checkers.append( CheckersPiece( "black", i, j, win ) )
    return checkers

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )

    # display the checkers on top of the board.
    # 3 rows of white checkers on black cells
    # and 3 rows of black checkers on white cells
    checkers = displayCheckers( win )
    
    win.getMouse()
    win.close()

main()

checkersInteractive1.py

In this version we can move the piece by click on them, then clicking on an empty square.

# checkersInteractive1.py
# D. Thiebaut
# Displays an 8x8 board, then 3 rows of 
# checkers made from gif images, and allows the
# user to click on a piece, then on an empty square,
# and move the piece there.
from graphics import *

WIDTH = 680    # width of the window
HEIGHT= 680    # height of the window
SIDE  = 680//8 # the side of a cell of the 8x8 board

class Piece:
    def __init__( self, ii, jj, col ):
        self.i = ii
        self.j = jj
        self.color = col
        x = ii * SIDE + SIDE//2
        y = jj * SIDE + SIDE//2
        """
        self.circ1 = Circle( Point( x, y ), SIDE//2 )
        if col=="white":
            self.circ1.setFill( color_rgb( 250, 250, 250 ) )
        else:
            self.circ1.setFill( color_rgb( 10, 10, 10 ) )
            
        self.circ2 = Circle( Point( x, y ), SIDE//2 - 5 )
        if col=="white":
            self.circ2.setFill( color_rgb( 230, 230, 230 ) )
        else:
            self.circ2.setFill( color_rgb( 50, 50, 50 ) )
        """
        if col=="white":
            self.image = Image( Point( x, y ), "piece2.gif" )
        else:
            self.image = Image( Point( x, y ), "piece.gif" )

    def __str__( self ):
        return "Piece: ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color )
    
    def draw( self, win ):
        """
        self.circ1.draw( win )
        self.circ2.draw( win )
        """
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()
        
    def getI( self ):
        return self.i

    def getJ( self ):
        return self.j
    
    def moveToSquare( self, i, j, win ):
        '''moves the checker piece from where it is,
        to the new position at i,j'''
        # convert i, j to an x, y coordinate
        destX = i * SIDE + SIDE//2
        destY = j * SIDE + SIDE//2
        # convert current i, j position to x,y coordinate
        currentX = self.i * SIDE + SIDE//2
        currentY = self.j * SIDE + SIDE//2
        # compute delta between where we are (currentX,currentY) to
        # where we want to be (destX,destY)
        deltaX = destX - currentX
        deltaY = destY - currentY
        # move the image by deltaX, deltaY
        self.image.move( deltaX, deltaY )
        # update our current i,j position
        self.i = i
        self.j = j
        
def displayBoard( win ):
    """display an 8x8 board"""
    for i in range( 8 ):
        for j in range( 8 ):
            x = i*SIDE
            y = j*SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if (i+j)%2 == 0:
                rect.setFill( color_rgb( 255, 255, 255 ) )
            else:
                rect.setFill( color_rgb( 100, 100, 100 ) )
            rect.draw( win )

def isBlack( i, j ):
    if (i+j)%2 == 0:
        return False
    else:
        return True
    
def displayCheckers( win ):
    checkers = []
    for i in range( 8 ):
        for j in range( 3 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "white" )
                piece.draw( win )
                checkers.append( piece )

    for i in range( 8 ):
        for j in range( 5, 8 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "black" )
                piece.draw( win )
                checkers.append( piece )
    return checkers

def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ),
                     message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase

def checkIfCheckerPieceAt( i, j, checkers ):
    '''goes through the list of checkers, and if one is
    found at location i, j, then return that piece.  Otherwise
    return None.'''
    for piece in checkers:
        if piece.getI() == i and piece.getJ() == j:
            return piece
    return None

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display 8x8 checkers board
    displayBoard( win )
    checkers = displayCheckers( win )

    # -----------------------------------------------
    # Animation Loop
    # -----------------------------------------------
    clickedPiece = None
    while True:            
        # see if the user clicked the mouse
        mouseClick = win.checkMouse()

        # if not, then keep looping and do nothing
        if mouseClick == None:
            continue

        # mouseClick is the point that was clicked.
        # transform the x and y of the point into i and j
        # identifying the squares of the checkerboard
        i = mouseClick.getX() // SIDE
        j = mouseClick.getY() // SIDE

        # check to see if a checkers piece was clicked
        piece = checkIfCheckerPieceAt( i, j, checkers )
        
        if piece != None:
            # yes, a piece was clicked!  Remember which one it is
            clickedPiece = piece
            print( "User clicked on", clickedPiece )
            continue
        else:
            # no, no piece clicked.  So user clicked an empty
            # square.  If she had clicked a piece before, then
            # move that piece.  Otherwise, just don't do anything
            print( "User clicked on a square at (",i,", ", j,")" )
            if clickedPiece != None:
                print( "Moving piece", clickedPiece, "to(",i,", ", j,")" )
                clickedPiece.moveToSquare( i, j, win )
                clickedPiece = None
        
    # wait for user to click before closing everything...
    waitForClick( win, "click to close" )

    win.close()

main()

checkers4MoveRemoveWithButton.py

# checkers4MoveRemoveWithButton.py
# D. Thiebaut
# A first program to display an 8x8 chessboard
# in a graphic window.
# 
from graphics import *

WIDTH = 680       # width of the window
HEIGHT= 680+30    # height of the window (30 for border at bottom)
SIDE  = 680//8    # the side of a cell of the 8x8 board

class Button:
    def __init__( self, x, y, w, h, caption ):
        self.box = Rectangle( Point( x, y ), Point(x+w, y+h) )
        self.box.setFill( "lightgrey" )
        self.caption = Text( Point( x+w//2, y+h//2), caption )

    def draw( self, win ):
        self.win = win
        self.box.draw( win )
        self.caption.draw( win )

    def isClicked( self, point ):
        x = point.getX()
        y = point.getY()
        x1, y1 = self.box.getP1().getX(), self.box.getP1().getY()
        x2, y2 = self.box.getP2().getX(), self.box.getP2().getY()
        return x1 <= x <= x2 and y1 <= y <= y2
    
class Piece:
    def __init__( self, ii, jj, col ):
        self.i = ii
        self.j = jj
        self.color = col
        x = ii * SIDE + SIDE//2
        y = jj * SIDE + SIDE//2
        """
        self.circ1 = Circle( Point( x, y ), SIDE//2 )
        if col=="white":
            self.circ1.setFill( color_rgb( 250, 250, 250 ) )
        else:
            self.circ1.setFill( color_rgb( 10, 10, 10 ) )
            
        self.circ2 = Circle( Point( x, y ), SIDE//2 - 5 )
        if col=="white":
            self.circ2.setFill( color_rgb( 230, 230, 230 ) )
        else:
            self.circ2.setFill( color_rgb( 50, 50, 50 ) )
        """
        if col=="white":
            self.image = Image( Point( x, y ), "piece2.gif" )
        else:
            self.image = Image( Point( x, y ), "piece.gif" )

    def __str__( self ):
        return "Piece: ({0:1},{1:1}) {2:1}".format( self.i, self.j, self.color )
    
    def draw( self, win ):
        """
        self.circ1.draw( win )
        self.circ2.draw( win )
        """
        self.image.draw( win )

    def undraw( self ):
        self.image.undraw()
        
    def getI( self ):
        return self.i

    def getJ( self ):
        return self.j
    
    def moveToSquare( self, i, j, win ):
        destX = i * SIDE + SIDE//2
        destY = j * SIDE + SIDE//2
        currentX = self.i * SIDE + SIDE//2
        currentY = self.j * SIDE + SIDE//2
        deltaX = destX - currentX
        deltaY = destY - currentY
        self.image.undraw()
        self.image._move( deltaX, deltaY )
        self.image.draw( win )
        self.i = i
        self.j = j
        
def displayBoard( win ):
    """display an 8x8 board"""
    for i in range( 8 ):
        for j in range( 8 ):
            x = i*SIDE
            y = j*SIDE
            rect = Rectangle( Point( x, y ), Point( x+SIDE, y+SIDE ) )
            if (i+j)%2 == 0:
                rect.setFill( color_rgb( 255, 255, 255 ) )
            else:
                rect.setFill( color_rgb( 100, 100, 100 ) )
            rect.draw( win )

def isBlack( i, j ):
    if (i+j)%2 == 0:
        return False
    else:
        return True
    
def displayCheckers( win ):
    checkers = []
    for i in range( 8 ):
        for j in range( 3 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "white" )
                piece.draw( win )
                checkers.append( piece )

    for i in range( 8 ):
        for j in range( 5, 8 ):
            if isBlack( i, j ):
                piece = Piece( i, j, "black" )
                piece.draw( win )
                checkers.append( piece )
    return checkers

def waitForClick( win, message ):
    """ waitForClick: stops the GUI and displays a message.  
    Returns when the user clicks the window. The message is erased."""
    startMsg = Text( Point( win.getWidth()/2, win.getHeight()-15 ),
                     message )
    startMsg.draw( win )    # display message
    win.getMouse()          # wait
    startMsg.undraw()       # erase

def checkIfCheckerPieceAt( i, j, checkers ):
    for piece in checkers:
        if piece.getI() == i and piece.getJ() == j:
            return piece

    return None

def main():
    # open the window
    win = GraphWin( "Checkers", WIDTH, HEIGHT )

    # display the Quit button
    quitButton = Button( WIDTH-60, HEIGHT-25, 50, 20, "Quit" )
    quitButton.draw( win )
    
    # display 8x8 checkers board
    displayBoard( win )
    checkers = displayCheckers( win )

    # -----------------------------------------------
    # Animation Loop
    # -----------------------------------------------
    clickedPiece = None
    while True:
        # did the user press the D key?
        key = win.checkKey()
        if key in ['D', 'd'] and clickedPiece != None:
            print( "User pressed 'D' and a piece is selected" )
            clickedPiece.undraw()
            checkers.remove( clickedPiece )
            clickedPiece = None
            continue
            
        # see if the user clicked the mouse
        mouseClick = win.checkMouse()

        # if not, then keep looping and do nothing
        if mouseClick == None:
            continue

        # did user click on the Quit button?
        if quitButton.isClicked( mouseClick ):
            print( "User pressed Quit" )
            break
        
        # mouseClick is the point that was clicked.
        # transform the x and y of the point into i and j
        # identifying the squares of the checkerboard
        i = mouseClick.getX() // SIDE
        j = mouseClick.getY() // SIDE

        # check to see if a checkers piece was clicked
        piece = checkIfCheckerPieceAt( i, j, checkers )
        
        if piece != None:
            # yes, a piece was clicked!  Remember which one it is
            clickedPiece = piece
            print( "User clicked on", clickedPiece )
            continue
        else:
            # no, no piece clicked.  So user clicked an empty
            # square.  If she had clicked a piece before, then
            # move that piece.  Otherwise, just don't do anything
            print( "User clicked on a square at (",i,", ", j,")" )
            if clickedPiece != None:
                print( "Moving piece", clickedPiece, "to(",i,", ", j,")" )
                clickedPiece.moveToSquare( i, j, win )
                clickedPiece = None
        
    # wait for user to click before closing everything...
    #waitForClick( win, "click to close" )

    win.close()

main()

4/16/18

emails.txt

Just a list of fake 5-col email addresses.

Lauryn@smith.edu
Amaris@smith.edu
Lujun@smith.edu
Cora@smith.edu
smithy@umass.edu
Olive@smith.edu
Giuliana@smith.edu
Marina@smith.edu
Aliyah@smith.edu
Itzel@hampshire.edu
Rui@smith.edu
Perla@smith.edu
Julissa@smith.edu
Linda@smith.edu
Carolina@smith.edu
Beatrice@smith.edu
Carly@smith.edu
Iris@umass.edu
Lu@smith.edu
Armani@smith.edu
Julianna@smith.edu
Mattie@smith.edu
Diya@smith.edu
Maria@smith.edu
Payten@smith.edu
Caroline@amherst.edu
Gemma@smith.edu
Jade@smith.edu
Scarlet@smith.edu
Alejandra@smith.edu
Phoebe@smith.edu
Harper@smith.edu
Tianna@smith.edu
Litzy@smith.edu
Adison@mtholyoke.edu
Isabell@smith.edu
Yuliana@smith.edu
Lillian@smith.edu
Callie@smith.edu
Hadley@smith.edu
Camille@smith.edu
Tara@smith.edu
Desirae@smith.edu
Miya@smith.edu
Laura@smith.edu
Leticia@smith.edu
Emily@smith.edu
Krista@smith.edu
Ashtyn@smith.edu
Alina@smith.edu
Tiara@smith.edu
Cameron@smith.edu
Amaya@smith.edu
Jewel@smith.edu
Brenda@smith.edu
Angel@smith.edu
Anahi@smith.edu
Lara@smith.edu
Regina@smith.edu
Mylie@smith.edu
Kyra@smith.edu
Lindsay@smith.edu
Katherine@smith.edu
Raven@smith.edu
Chloe@smith.edu
Wendy@smith.edu
Amara@smith.edu
Adelyn@smith.edu
Sharon@smith.edu
Carlee@smith.edu
Aisha@smith.edu
Chana@smith.edu
Paisley@smith.edu
Amelie@smith.edu
Dixie@smith.edu
America@smith.edu
Karla@smith.edu
Alana@smith.edu
Dulce@smith.edu
Marlene@smith.edu
Serena@smith.edu
Annabel@smith.edu
Karley@smith.edu
Lyla@smith.edu
Sandra@smith.edu
Breanna@smith.edu
Gracelyn@smith.edu
Crystal@smith.edu
Taniya@smith.edu
Jazmin@smith.edu
Madalyn@smith.edu
Holly@smith.edu
Janiya@smith.edu
Paige@smith.edu
Jaylene@smith.edu
Cecelia@smith.edu
Jaylynn@smith.edu
Tori@smith.edu
Madeline@smith.edu
Aliza@smith.edu
Rebekah@smith.edu
Kimora@smith.edu
Mayra@smith.edu
Shea@smith.edu
Ana@smith.edu
Britney@smith.edu
Aleena@smith.edu
Yaritza@smith.edu
Bridget@smith.edu
Lindsey@smith.edu
Ava@smith.edu
Yareli@smith.edu
Violet@smith.edu
Londyn@smith.edu
Tatum@smith.edu
Patience@smith.edu
Ayana@smith.edu
Lizbeth@smith.edu
Madison@smith.edu
Elisabeth@smith.edu
Halle@smith.edu
Hallie@smith.edu
Ashley@smith.edu
Evelyn@smith.edu
Evelin@smith.edu

filterEmails.py

# sortEmails.py
# D. Thiebaut

emails = """
Lauryn@smith.edu
Amaris@smith.edu
Lujun@smith.edu
Cora@smith.edu
smithy@umass.edu
Olive@smith.edu
Giuliana@smith.edu
Marina@smith.edu
Aliyah@smith.edu
Itzel@hampshire.edu
Rui@smith.edu
Perla@smith.edu
Julissa@smith.edu
Linda@smith.edu

Carolina@smith.edu
Beatrice@smith.edu
Carly@smith.edu
Iris@umass.edu
Lu@smith.edu
Armani@smith.edu
Julianna@smith.edu
Mattie@smith.edu
Diya@smith.edu
Maria@smith.edu
Payten@smith.edu
Caroline@amherst.edu
Gemma@smith.edu
Jade@smith.edu
Scarlet@smith.edu
Alejandra@smith.edu
Phoebe@smith.edu
Harper@smith.edu
Tianna@smith.edu
Litzy@smith.edu
Adison@mtholyoke.edu
Isabell@smith.edu
Yuliana@smith.edu
Lillian@smith.edu
Callie@smith.edu
Hadley@smith.edu
Camille@smith.edu
Tara@smith.edu
Desirae@smith.edu
Miya@smith.edu
Laura@smith.edu
Leticia@smith.edu
Emily@smith.edu
Krista@smith.edu
Ashtyn@smith.edu
Alina@smith.edu
Tiara@smith.edu
Cameron@smith.edu
Amaya@smith.edu
Jewel@smith.edu
Brenda@smith.edu
Angel@smith.edu
Anahi@smith.edu
Lara@smith.edu
Regina@smith.edu
Mylie@smith.edu
Kyra@smith.edu
Lindsay@smith.edu
Katherine@smith.edu
Raven@smith.edu
Chloe@smith.edu
Wendy@smith.edu
Amara@smith.edu
Adelyn@smith.edu
Sharon@smith.edu
Carlee@smith.edu
Aisha@smith.edu
Chana@smith.edu
Paisley@smith.edu
Amelie@smith.edu
Dixie@smith.edu
America@smith.edu
Karla@smith.edu
Alana@smith.edu
Dulce@smith.edu
Marlene@smith.edu
Serena@smith.edu
Annabel@smith.edu
Karley@smith.edu
Lyla@smith.edu
Sandra@smith.edu
Breanna@smith.edu
Gracelyn@smith.edu
Crystal@smith.edu
Taniya@smith.edu
Jazmin@smith.edu
Madalyn@smith.edu
Holly@smith.edu
Janiya@smith.edu
Paige@smith.edu
Jaylene@smith.edu
Cecelia@smith.edu
Jaylynn@smith.edu
Tori@smith.edu
Madeline@smith.edu
Aliza@smith.edu
Rebekah@smith.edu
Kimora@smith.edu
Mayra@smith.edu
Shea@smith.edu
Ana@smith.edu
Britney@smith.edu
Aleena@smith.edu
Yaritza@smith.edu
Bridget@smith.edu
Lindsey@smith.edu
Ava@smith.edu
Yareli@smith.edu
Violet@smith.edu
Londyn@smith.edu
Tatum@smith.edu
Patience@smith.edu
Ayana@smith.edu
Lizbeth@smith.edu
Madison@smith.edu
Elisabeth@smith.edu
Halle@smith.edu
invalid
Hallie@smith.edu
Ashley@smith.edu
Evelyn@smith.edu
Evelin@smith.edu

Tianna@smith.edu
Litzy@smith.edu
Adison@mtholyoke.edu
Isabell@smith.edu
Yuliana@smith.edu
Lillian@smith.edu

Tianna@smith.edu
Litzy@smith.edu
Adison@mtholyoke.edu
Isabell@smith.edu
Yuliana@smith.edu
Lillian@smith.edu

this is invalid
"""

def main():
    global emails

    # split the string into a list of email addresses
    emails  = emails.split( "\n" )

    # prepare list for smith emails and 5-col emails
    smith   = [ ]
    fiveCol = [ ]

    # loop through all the emails...
    for email in emails:
        # split email at the '@' character
        fields = email.split( "@" )

        # if not 2 words on each side, then invalid email, skip
        if len( fields ) != 2:
            continue

        # if "smith" appears in the second word, on the right of '@'
        # then it's a Smith College email
        if fields[1].lower().find( "smith" ) != -1:
            smith.append( email )
        else:
            # otherwise it's a 5-col email
            fiveCol.append( email )

    # remove duplicates in both new lists
    smith = list( set( smith ) )
    fiveCol = list( set( fiveCol ) )
    
    # display both lists
    print( "smith emails: ", ", ".join( smith ) )
    print( "5col emails: ", ", ".join( fiveCol ) )
    
main()

rainiest.py

# rainiest.py
# D. Thiebaut
# Takes the data file for the town of Cardiff, in the UK,
# stored at this URL:# http://cs.smith.edu/~dthiebaut/UKTemperatures/
# then outputs the rainiest month and year.


def getWebData( URL ):
    '''
    gets the list of lines from the Web page at URL.
    This solution was found in the Python docs, at
    https://docs.python.org/3/howto/urllib2.html
    '''
    # import the library for accessing Web URLs
    from urllib.request import urlopen
    from urllib.error import URLError

    # attempt to get the Web page
    try:
        f = urlopen( URL )
        text = f.read().decode('utf-8')
    except URLError as e:
        # if error, print error message and
        # return empty list
        print( "ERROR!\n", e.reason )
        return [ ]
    
    # return the list of lines
    lines = text.split( "\n" )
    return lines


def main():
    # get the lines of text from the Cardiff data file
    URL = "http://cs.smith.edu/~dthiebaut/UKTemperatures/cambridgedata.txt"
    lines = getWebData( URL )
    #lines = lines[0:10] + lines[50:55]
    
    for i in range( len( lines ) ):
        lines[i] = lines[i].replace( "73.6", "73.6*" )
        #print( lines[i] )        

    # filter
    # transform list of lines into list of tuples
    #    yyyy  mm   tmax    tmin      af    rain     sun
    #       degC    degC    days      mm   hours
    #    1959   1    4.4    -1.4      20     ---    78.1

    tuples = [ ]
    for line in lines:
        #print( line )
        line = line.replace( '*', '' )
        try:
            fields = line.split( )
            rain  = float( fields[5] )
            month = fields[1]
            year  = fields[0]
        except IndexError:
            continue
        except ValueError:
            continue
        #print( rain, month, year )
        tuples.append( (rain, month, year) )

    # sort
    tuples.sort()

    '''
    # display tuples
    for tuple in tuples:
        print( tuple )
    '''

    # display the rainiest month and year
    print( "rainiest month/year: {0:1}/{1:1}".format( 
           tuples[-1][1], tuples[-1][2]) )
        

main()

filterPresidents.py

# filterPresidents.py
# D. Thiebaut
# finds out who was president a given year.

presidents='''Presidency ,President, Took office ,Left office ,Party , Home State
1, George Washington, 30/04/1789, 4/03/1797, Independent, Virginia
2, John Adams, 4/03/1797, 4/03/1801, Federalist, Massachusetts
3, Thomas Jefferson, 4/03/1801, 4/03/1809, Democratic-Republican, Virginia
4, James Madison, 4/03/1809, 4/03/1817, Democratic-Republican, Virginia
5, James Monroe, 4/03/1817, 4/03/1825, Democratic-Republican, Virginia
6, John Quincy Adams, 4/03/1825, 4/03/1829, Democratic-Republican/National Republican, Massachusetts
7, Andrew Jackson, 4/03/1829, 4/03/1837, Democratic, Tennessee
8, Martin Van Buren, 4/03/1837, 4/03/1841, Democratic, New York
9, William Henry Harrison, 4/03/1841, 4/04/1841, Whig, Ohio
10, John Tyler, 4/04/1841, 4/03/1845, Whig, Virginia
11, James K. Polk, 4/03/1845, 4/03/1849, Democratic, Tennessee
12, Zachary Taylor, 4/03/1849, 9/07/1850, Whig, Louisiana
13, Millard Fillmore, 9/07/1850, 4/03/1853, Whig, New York
14, Franklin Pierce, 4/03/1853, 4/03/1857, Democratic, New Hampshire
15, James Buchanan, 4/03/1857, 4/03/1861, Democratic, Pennsylvania
16, Abraham Lincoln, 4/03/1861, 15/04/1865, Republican/National Union, Illinois
17, Andrew Johnson, 15/04/1865, 4/03/1869, Democratic/National Union, Tennessee
18, Ulysses S. Grant, 4/03/1869, 4/03/1877, Republican, Ohio
19, Rutherford B. Hayes, 4/03/1877, 4/03/1881, Republican, Ohio
20, James A. Garfield, 4/03/1881, 19/09/1881, Republican, Ohio
21, Chester A. Arthur, 19/09/1881, 4/03/1885, Republican, New York
22, Grover Cleveland, 4/03/1885, 4/03/1889, Democratic, New York
23, Benjamin Harrison, 4/03/1889, 4/03/1893, Republican, Indiana
24, Grover Cleveland, 4/03/1893, 4/03/1897, Democratic, New York
25, William McKinley, 4/03/1897, 14/9/1901, Republican, Ohio
26, Theodore Roosevelt, 14/9/1901, 4/3/1909, Republican, New York
27, William Howard Taft, 4/3/1909, 4/03/1913, Republican, Ohio
28, Woodrow Wilson, 4/03/1913, 4/03/1921, Democratic, New Jersey
29, Warren G. Harding, 4/03/1921, 2/8/1923, Republican, Ohio
30, Calvin Coolidge, 2/8/1923, 4/03/1929, Republican, Massachusetts
31, Herbert Hoover, 4/03/1929, 4/03/1933, Republican, Iowa
32, Franklin D. Roosevelt, 4/03/1933, 12/4/1945, Democratic, New York
33, Harry S. Truman, 12/4/1945, 20/01/1953, Democratic, Missouri
34, Dwight D. Eisenhower, 20/01/1953, 20/01/1961, Republican, Texas
35, John F. Kennedy, 20/01/1961, 22/11/1963, Democratic, Massachusetts
36, Lyndon B. Johnson, 22/11/1963, 20/1/1969, Democratic, Texas
37, Richard Nixon, 20/1/1969, 9/8/1974, Republican, California
38, Gerald Ford, 9/8/1974, 20/01/1977, Republican, Michigan
39, Jimmy Carter, 20/01/1977, 20/01/1981, Democratic, Georgia
40, Ronald Reagan, 20/01/1981, 20/01/1989, Republican, California
41, George H. W. Bush, 20/01/1989, 20/01/1993, Republican, Texas
42, Bill Clinton, 20/01/1993, 20/01/2001, Democratic, Arkansas
43, George W. Bush, 20/01/2001, 20/01/2009, Republican, Texas
44, Barack Obama, 20/01/2009, 20/01/2017, Democratic, Illinois
45, Donald Trump, 20/10/2017, present, Republican, New York
'''

def main():
    global presidents

    # split the presidents string in individual lines
    lines = presidents.split( "\n" )

    # set a year to search for
    keyYear = 2017 # eval( input( "> " ) ) 

    # look at each president, one after the other
    for line in lines:
        #print( line )

        # divide the line into fields (CSV format)
        fields = line.strip().split( "," )

        # if less than 5 fields in line, it's not a president
        if len( fields ) < 5:
            continue

        # if we don't get a / in the date at Index 3, then we're
        # dealing with the last president whose end date is not known.
        # replace "present" by today's date 
        if fields[3].find( "/" )==-1:
            fields[3] = "16/04/2018"

        # split the start and end years at the / character and pick the
        # word at Index 2 (the year) and make it an integer
        try:
            startYear = int( fields[2].split( "/" )[2] )
            endYear   = int( fields[3].split( "/" )[2] )
        except IndexError:
            # if we got an error, then we are not dealing with correctly
            # formatted dates.  Skip.
            continue


        # if the year we're looking for is between the start and end 
        # of this presidency, print the president information
        if startYear <= keyYear <= endYear:
            print( line )

main()

4/18/18

GenericCar_incomplete.py

# genericCar.py
# D. Thiebaut
# 
from graphics import *
from random import *

class GenericCar:
    """Definition for a car with a body and two wheels"""

    def __init__(self, win, topLeft, width, height ):
        """constructs a car made of 1 rectangle with top-left
        point topLeft, dimension width x height, and two wheels
        away from left and right by 10 pixesl"""
        # save width and height of car
        self.width = width
        self.height = height
        
        # create bottom-right point
        x1 = topLeft.getX()
        y1 = topLeft.getY()
        P2 = Point( x1+width, y1+height )

        # body is a rectangle between topLeft and P2
        self.body = Rectangle( topLeft, P2 )
        self.body.setFill( "yellow" )

        # create wheel #1
        center1 = Point( x1+20, y1+height )
        self.wheel1 = Circle( center1, 20 )
        self.wheel1.setFill( "black" )

        # create wheel #2
        center2 = Point( x1+width-20, y1+height )
        self.wheel2 = Circle( center2, 20 )
        self.wheel2.setFill( "black" )

        # create random speed
        self.dx = randrange( -3, 3 )

        # save window width (so that a car can detect
        # that it's going outside the left or right
        # margins)
        self.windowWidth = win.getWidth()

    def setSpeed( self, speed ):
        self.dx = speed
        
    def setFill( self, color ):
        '''sets the color of the body of the car'''
        self.body.setFill( color )
        
    def draw( self, win ):
        """draw the car on the window"""
        self.body.draw( win )
        self.wheel1.draw( win )
        self.wheel2.draw( win )
            
    def move( self ):
        """move the body and wheels of the car by dx"""
        self.body.move( self.dx, 0 )
        self.wheel1.move( self.dx, 0 )
        self.wheel2.move( self.dx, 0 )

ManyCars.py

# ManyCars.py
# A program that uses many different classes
# of cars, inherited from the GenericCar super
# class.
from genericCar import *
from graphics import *

WIDTH  = 700
HEIGHT = 500

def main():
    # open a graphic window
    win = GraphWin( "Cars Cars Cars", WIDTH, HEIGHT )

    # create a generic car, draw it, set its speed
    # and set its color to blue
    car = GenericCar( win, Point( 100, 100 ), 200, 50 )
    car.draw( win )
    car.setSpeed( -1.5 )
    car.setFill( "blue" )

    #taxi = Taxi(  win, Point( 150, 200 ), 200, 50 )
    #taxi.draw( win )
    #taxi.setSpeed( 1.5 )
    #taxi.setFill( "lightblue" )

    # keep on moving the car until the user clicks the mouse    
    while win.checkMouse()==None:
        car.move( )
        #taxi.move( )
        
    # close the graphic window        
    win.close()

main()

4/23/18

animalsTalk.py

# animalsTalk.py
# D. Thiebaut
# An example of polymorphism

class Animal:
    def whatAreYou( self ):
        return
    def sleep( self ):
        print( "Zzzzzz...\n" )
    def speak( self ):
        return

class Dog( Animal ):
    def whatAreYou( self ):
        print( "I'm a dog!" )
    def speak( self ):
        print( "Woof, woof!" )

class Cat( Animal ):
    def whatAreYou( self ):
        print( "Why, I'm a cat.  Leave me alone!" )
    def speak( self ):
        print( "Meow!" )

class Duck( Animal ):
    def whatAreYou( self ):
        print( "Donald" )
    def speak( self ):
        print( "Quack, quack!" )


def main():
    garfield = Cat()
    rex      = Dog()
    ducky    = Duck()

    garfield.whatAreYou()
    garfield.speak()
    garfield.sleep()

    rex.whatAreYou()
    rex.speak()
    rex.sleep()

    ducky.whatAreYou()
    ducky.speak()
    ducky.sleep()

main()

searchListAndDictionary.py

# searchDictionary.py
# D. Thiebaut
# initializes a list of N integers, and
# a dictionary of N integer keys.
# then search both for an item (NOTTHERE) that
# is not stored in either one.
# Typical run:
#
# List initialized with 100000000 items
# Dictionary initialized with 100000000 items
# searching for 1000 in list
# Not found
# Execution time = 3.498 sec
# searching for 1000 in dictionary
# Not found
# Execution time = 0.065 sec
# Done!
import time

N = 100000000
NOTTHERE = 1000

def main():
    # create a list with N integers
    bigList = []
    for i in range( N ):
        if i!= NOTTHERE:
            bigList.append( i )

    print( "List initialized with {0:1} items".format( N ) )

    # create a dictionary with N (key, values) pairs
    # the value is simply the key plus one.
    bigDictionary = { }
    for i in range( N ):
        if i != NOTTHERE:
            bigDictionary[ i ] = i+1

    print( "Dictionary initialized with {0:1} items".format( N ) )

    # search the list for an item that is not there, forcing
    # python to look at all the N items in the list.
    # keep track of the elapsed time.
    print( "searching for {0:1} in list".format( NOTTHERE ) )
    start_time = time.time()
    if NOTTHERE in bigList:
        print( "found it!" )
    else:
        print( "Not found" )
    end_time = time.time()
    print( "Execution time = {0:1.3f} sec".format( end_time-start_time ) )

    # search the dictionary for a key that is not there, 
    # and instead of looking at all the elements, Python looks
    # at very small number of them, possibly just one.
    # The elapsed time is measured, as well.
    print( "searching for {0:1} in dictionary".format( NOTTHERE ) )
    start_time = time.time()
    if NOTTHERE in bigDictionary:
        print( "found it!" )
    else:
        print( "Not found" )
    end_time = time.time()
    print( "Execution time = {0:1.3f} sec".format( end_time-start_time ) )
        
    print( "Done!" )

main()

totalCalories.py

# totalCalories.py
# D. Thiebaut
# A program illustrating the use of a dictionary
# to compute the total amount of calories in a
# smoothy containing several different fruit.
# Additional fruit and calorie data can be found
# at this URL: http://www.lasting-weight-loss.com/calories-in-fruit.html
#
caloriesDict = {
    "Apple"         : 95,
    "Apricot"       : 29,
    "Avocado"       : 270,
    "Banana"        : 95,
    "Blackberry"    : 25,
    "Blackcurrant"  : 28,
    "Blueberry"     : 30,
    "Boysenberry"   : 66,
    "Cherimoya"     : 115,
    "Coconut"       : 351,
    "Cranberry"     : 15,
    "Date"          : 107,
    "Fig"           : 43,
    "Grapefruit"    : 48 }

def main():
    # define a list of smoothies and their contents
    Smoothies = [ ( "Blueberry", "Banana", "Apple" ),
                  ( "fig", "grapefruit", "avocado" ) ]

    # for each smoothie, compute the total number of calories
    for smoothy in Smoothies:
        # display smoothie nicely formatted
        print( "Smoothy:", ", ".join( smoothy ) )

        # for each fruit in this smoothie, add its calorie count
        # to total
        totalCal = 0
        for fruit in smoothy:
            fruit = fruit.capitalize()
            if fruit in caloriesDict:
                print( "{0:20}-->{1:5}".format( fruit, caloriesDict[ fruit ] ) )
                totalCal = totalCal + caloriesDict[ fruit ]

        # print total calories
        print( "{0:20}   {1:5} calories".format( "Total calories", totalCal ) )
        print()
    
main()

4/25/18

countMajors.py

# countMajors.py
# D. Thiebaut
# given a file containing lines of the form shown below,
# computes the number of students for each major appearing
# in the lines.
#
# Wendy@smith.edu      ECO
# Yareli@smith.edu     FRN
# Yaritza@smith.edu    ARH
# Yuliana@smith.edu    ECO
# smithy@umass.edu     ARH
#

def main():
    # read the data from the file
    fileName = "majors.txt"
    file = open( fileName, 'r' )
    lines = file.readlines()
    file.close()

    # create a dictionary for the majors    
    majorsDict = {}

    # process each line...
    for line in lines:

        # split each line into 2 fields
        try:
            email, major = line.strip().split()
        except ValueError:
            continue

        # if major not a key in dictionary,
        # add it...
        if not major in majorsDict:
            majorsDict[ major ] = 0

        # increment count for the major just found
        majorsDict[ major ] += 1

    # display the majors and the number of students
    for major in majorsDict:
        print( major, "-->", majorsDict[major] )

main()

countMajorsDisplayMostPopular.py

# countMajors.py
# D. Thiebaut
# given a file containing lines of the form
#
# Wendy@smith.edu      ECO
# Yareli@smith.edu     FRN
# Yaritza@smith.edu    ARH
# Yuliana@smith.edu    ECO
# smithy@umass.edu     ARH

def main():
    # read the data from the file
    fileName = "majors.txt"
    file = open( fileName, 'r' )
    lines = file.readlines()
    file.close()

    # create a dictionary for the majors    
    majorsDict = {}

    # process each line...
    for line in lines:

        # split each line into 2 fields
        try:
            email, major = line.strip().split()
        except ValueError:
            continue

        # if major not a key in dictionary,
        # add it...
        if not major in majorsDict:
            majorsDict[ major ] = 0

        # increment count for the major just found
        majorsDict[ major ] += 1

    # Create a list of ( count, major ) tuples
    List = [ ]
    for major in majorsDict:
        List.append(  ( majorsDict[major], major ) )

    # sort the list, then reverse it
    List.sort()
    List.reverse() # put most frequent first
    
    # list by most popular to least popular
    for count, major in List:
        print( count, major )
        

main()

streetCarWithDictionaries.py

# StreetCarWithDictionaries.py
# D. Thiebaut
# This program uses a dictionary of dictionaries
# to count how many times the three characters
# Stanley, Stella, and Blanche refer to each other
# in the play Street Car Named Desire, by Tennessy
# Williams

PLAY = "streetCar.txt"
characterCounters =   { "STANLEY": {"BLANCHE":0, "STELLA":0, "STANLEY":0 },
                        "BLANCHE": {"STANLEY":0, "STELLA":0, "BLANCHE":0 },
                        "STELLA":  {"STANLEY":0, "BLANCHE":0,"STELLA":0  }
                      }

def getLinesFromPlay( fileName ):
    '''opens the file given by its name, and
    returns all the text lines it contains.'''
    file = open( fileName, 'r' )
    lines = file.read()
    lines = lines.split( '\n' )
    file.close()
    return lines

def main():
    global PLAY, characterCounters
    
    lines = getLinesFromPlay( PLAY )
    for line in lines:
        # find lines that start with uppercase and contain a ':'
        if len(line) > 0 and 'A' <= line[0] <= 'Z' and line.find( ':' ) != -1:           
            # split the line at the first ':'            
            character, tirade = line.split( ':', 1 )

            # skip lines where character is not a key in dictionary
            if character not in characterCounters:
                continue

            # make tirade uppercase so all character names are uppercase
            tirade = tirade.upper().strip()

            # for each of the characters who are keys in dictionary...
            for otherCharacter in characterCounters:

                # count how many times each appears in tirade
                count = tirade.count( otherCharacter )
                if count != 0:
                    # update counter for character mentionning otherCharacter
                    characterCounters[ character ][ otherCharacter ] += count
                    
    # display the resulting counts
    for character in characterCounters:
        print( character )
        
        # get the dictionary of counters for that character
        dico = characterCounters[ character ]
        
        # go through each other-character in the dictionary, and display
        # associated counts
        for otherCharacter in dico:
            print( "   refers to", otherCharacter,
                   dico[otherCharacter ], "times" )
                           
            
main()

factorial.py

# factorial.py
# D. Thiebaut
# Demonstrates how the recursive
# factorial function operates.

def fact( n ):
    # stopping condition
    if n<=1: 
        return 1

    # recursive step
    result = n * fact( n-1 )
    return result


def main():
    n = int( input( "> " ) )
    x = fact( n )
    print( "{0:3}! = {1:20}".format( n , x ) )

main()

4/27/18

minionFindBananas.py

# find banana(s) recursively
# D. Thiebaut
# Here are several recursive functions developed 
# in class after we played the role of Dave and
# Gru passing along a bag of "bananas"
# NOTE: find the largest and the smallest item
# in a list is much better suited for the min()
# and max() function.  We only used the approaches
# illustrated here to better understand recursion.
# Definitely, if you have a list of items L and want
# to find the largest, use min( L ).
#

def minionFindMinMax( bananas ):
    # stopping condition
    if len( bananas ) == 2:
        return min( bananas ), max( bananas )

    # keep first one
    pick = bananas[0]

    # ask another minion to find the min & max in
    # the remaining bananas (except for the one at
    # Index 0, and which we kept)
    min1, max1 = minionFindMinMax( bananas[1: ] )

    # create a list of the min and max returned, and
    # the one we picked.
    smallBunch = [ min1, max1, pick ]

    # return the min and max of these 3
    return min( smallBunch ), max( smallBunch )    


'''        
def minionFindMinMaxEven( bananas ):
    # assume len( bananas ) always even
    if len( bananas ) == 2:
        return min( bananas ), max( bananas )

    pick1 = bananas[0]
    pick2 = bananas[1]

    min1, max1 = minionFindMinMaxEven( bananas[2: ] )
    smallBunch = [ min1, max1, pick1, pick2 ]
    return min( smallBunch ), max( smallBunch )
'''
    
def minionFind( bananas, keyBanana ):
    # stopping condition
    if len( bananas ) == 0:
        return False
    else:
        # do some work
        pick = bananas[0]
        if pick == keyBanana:
            #if found, we're successful, pass True back
            return True

        # see if key might be in the remaining bunch [1: ],
        # and whatever is returned from this search, pass it on
        success = minionFind( bananas[1: ], keyBanana )
        return success


def main():
    bananas = [ 100, 118, 5, 10, 200, -1, 0, 78, 77, 200, 300 ]

    m1, M1 = minionFindMinMax( bananas )
    print( m1, M1 )
    
main()

4/30/18

graphicsVisitMaze.py

# graphicsVisitMaze.py
# D. Thiebaut
# Generates a maze and displays it in a graphics window.
# The maze is defined as a collection of lines of text.
# MazeText is the variable containing the raw definition.
# MazeText is split into lines and the list of lines is kept
# in the variable maze.
# Each line in mazeText contains # or . characters.  A #-character
# indicates a wall, while a . indicates an empty space.
# MazeText is cleaned up and all the dots are replaced by spaces.
# Then the maze is displayed in the graphic window.
# The program maintains the status of the visit in the variable
# maze.  A '.' will represent a breadcrumb, i.e. a place that has
# been visited and that is potentially on the path to the exit.  A
# 'v' character indicates a visited place that leads to an impass.
# The program starts by visiting location STARTi (line number)
# and STARTj (column number).
# 
import time
import os
from graphics import *


# Dimensions of the graphics window
WIDTH  = 600
HEIGHT = 600

mazeText = """
#########################
........................#
##############.##########
#.#.#........#.#........#
#.#.#.########.########.#
#.#.#.................#.#
#.#.###.#####.#####.#...#
#...........#.#.#.#.#####
#.#########.#.#.#.#...#.#
#.#.#.#.#.#.#.#.#######.#
#.#.........#.#.......#..
#.###############.#####.#
#...............#.......#
#.###########.#########.#
#........#..............#
#########################
"""

mazeText1 = """
#########################
........................#
#.......................#
#.......................#
#.......................#
#.......................#
#.......................#
........................#
#.......................#
#.......................#
#.......................#
#.......................#
#.......................#
#.......................#
........................#
#########################
"""

mazeText2 = """
#########################
........................#
#.......................#
#.......................#
#.......................#
#######################.#
#.......................#
#.......................#
#.......................#
#.......................#
#.#######################
#.......................#
#.......................#
#.......................#
#........................
#########################
""" 
mazeText3 = """
#########################
........................#
#.......................#
#.......................#
#.......................#
###########.#############
#.......................#
#.......................#
#.......................#
#.......................#
#.#######################
#.......................#
#.......................#
#.......................#
#........................
#########################
""" 
#
STARTi = 1   # line number
STARTj = 0   # column number

NOLINES = len( mazeText.strip().split("\n") )
NOCHARS = len( mazeText.strip().split("\n")[1] )
BLOCKWIDTH  = WIDTH // NOCHARS  # width in pixels of block on graphics window
BLOCKHEIGHT = HEIGHT / NOLINES  # height in pixels of block on graphics window

 
def getMazeFromFile( fileName ):
    """reads the definition of the maze from a file"""
 
    try:
        lines = open( fileName, 'r' ).read()
    except:
        print( "I/O Error: could not open", fileName )
        return None
 
    return getMaze( lines )
 
def getMaze( mazeText ):
    """take the string representing the maze and
    break it down into an array of lines"""
    maze=[]
    for i, line in enumerate( mazeText.split( '\n' ) ):
        line = line.strip()
        #print( "%d [%s]" % (i, line ) )
        if len( line ) < 2:
            continue
        line = line.replace( '.', ' ' )
        maze.append( line )
    return maze
 
def setBreadCrumb( i, j, win ):
    """draw a circle where the walker has just landed, in
    the maze."""
    global BLOCKWIDTH
    global BLOCKHEIGHT
    radius = BLOCKWIDTH // 4
    brd = Circle( Point( (j+0.5)*BLOCKWIDTH, (i+0.5)*BLOCKHEIGHT ), radius )
    brd.setFill( "red" )
    brd.draw( win )
    
    # rest a tiny bit to slow down the program
    time.sleep( 0.1 )

def setImpass( i, j, win ):
    """mark a block as not leading to an exit.  Set its color
    to grey"""
    global BLOCKWIDTH
    global BLOCKHEIGHT
    radius = BLOCKWIDTH // 4
    blk = Rectangle( Point( j*BLOCKWIDTH, i*BLOCKHEIGHT ),
                  Point( (j+1)*BLOCKWIDTH, (i+1)*BLOCKHEIGHT ) )
    blk.setFill( "lightgrey" )
    blk.setOutline( "lightgrey" )
    blk.draw( win )
    
    # rest a tiny bit to slow down the program
    time.sleep( 0.1 )


def displayMaze( maze, win ):
    """ display the maze and wait for some amount of time"""
    global BLOCKWIDTH
    global BLOCKHEIGHT
    global NOLINES
    global NOCHARS
    
    blocks = []
    for i in range (NOLINES ):
       for j in range( NOCHARS ):
          if maze[i][j]=="#":
             r = Rectangle( Point( j*BLOCKWIDTH, i*BLOCKHEIGHT ),
                        Point( (j+1)*BLOCKWIDTH, (i+1)*BLOCKHEIGHT ) )
             r.setFill( "blue" )
             r.setOutline( "blue" )
             r.draw( win )
             blocks.append( r )
    
    return blocks

def setChar( maze, i, j, char ):
    """puts the character char at position i, j in the maze"""
    line = maze[i]
    letters = []
    for letter in line:
        letters.append( letter )
    letters[j] = char
    maze[i] = ''.join( letters )
    
def visitMaze( maze, i, j, win ):
    """recursive visit of the maze.  Returns True when it
    has found the exit, False otherwise"""

    # put a breadcrumb where we just landed.
    setBreadCrumb( i, j, win )
    setChar( maze, i, j, '.' )

    # stopping condition: we landed on the Exit...        
    if ( i != STARTi or j != STARTj ) \
        and ( (i==0 or i==len( maze )-1 ) or (j==0 or j==len( maze[0] )-1 ) ):
        return True
 
    #--- try the four directions around where we are ---
    #--- to the right? ---
    if j+1< len( maze[0] ) and maze[i][j+1]==' ':
        if visitMaze( maze, i, j+1, win ) == True:
                return True # found an exit by going right!
 
    #--- down? ---
    if i+1< len( maze ) and maze[i+1][j]==' ':
        if visitMaze( maze, i+1, j, win ) == True:
                return True # found an exit by going down!
 
    #--- up? ---
    if i-1>=0 and maze[i-1][j]==' ':
        if visitMaze( maze, i-1, j, win ) == True:
                return True # found an exit by going up!
 
    #--- to the left? ---
    if j-1>=0 and maze[i][j-1]==' ':
         if  visitMaze( maze, i, j-1, win ) == True:
                return True # found an exit by going left!
 
    #--- if we're here, none of the 4 directions was successful ---
    #--- in bringing us to an exit, we have to mark our cell with--
    #--- a v, and return false to our caller, indicating that we---
    #--- couldn't find a path                                   ---

    setImpass( i, j, win )
    setChar( maze, i, j, 'v' )
    #printMaze( maze )
    return False
 
 
def main():
    """gets the maze, visit and display it"""
    #maze = getMazeFromFile( 'largemaze.txt' )
    win = GraphWin("Maze", WIDTH, HEIGHT )
    win.getMouse()
    
    maze = getMaze( mazeText3 ) # <-- change maze here!

    #printMaze( maze )
    blocks = displayMaze( maze, win )
    
    success = visitMaze( maze, STARTi, STARTj, win )
 
    #--- print the maze without the v-characters ---
    #printMazeNoVs( maze )
 
    if success:
        print( "A path was found!" )
    else:
        print( "No path to an exit found..." )

    win.getMouse()
    win.close()
    
main()

Fractal Tree

# fractalTree.py
# D. Thiebaut
# Code taken from http://openbookproject.net/thinkcs/python/english3e/recursion.html
# and adapted to work with graphics111.py.
#
# Draws a fractal tree on the graphic window.
#
from graphics import *
import math
import time
import random

# dimensions of the window
MAXWIDTH = 800
MAXHEIGHT = 800

# recursive tree-drawing function
# 
def draw_tree(win   ,       # the canvas
              order,        # the level of recursion.  Starts positive.
              theta,        # angle of new branch leaving this trunk
              sz,           # size of this branch
              x, y,         # coordinates of base of this branch
              heading,      # angle of direction of this branch
              color         # color
              ):    

   trunk_ratio = 0.29       # How big is the trunk relative to whole tree?
   trunk = sz * trunk_ratio # length of trunk

   # compute x, y of end of the current branch
   delta_x = trunk * math.cos(heading)
   delta_y = trunk * math.sin(heading)
   x2, y2 = x + delta_x, y + delta_y

   
   # draw current branch
   branch = Line( Point( x, y), Point( x2, y2 ) )
   branch.setFill( color )
   branch.setWidth( 2 )
   branch.setOutline( color )
   branch.draw( win )

   # if this branch has sub-branches, then recurse
   if order > 0:    
       
      # make the recursive calls to draw the two subtrees
      newsz = sz*(1 - trunk_ratio)
      draw_tree(win,
                order-1, theta, newsz, x2, y2, heading-theta,
                color )
      draw_tree(win,
                order-1, theta, newsz, x2, y2, heading+theta,
                color )
      

# draw 1 tree in the middle of the screen, shooting straight up.
def main():
    win = GraphWin("Fractal Tree", MAXWIDTH, MAXHEIGHT )
    theta = 0.65      # use 0.02 for tall skinny trees, 0.7 for fat trees
    draw_tree(win,
              9,            # order
              theta,        # angle of new branch
              MAXWIDTH*0.9, # height of tree
              MAXWIDTH//2,  # x
              MAXHEIGHT-50, # y
              -math.pi/2,   # angle of direction
              "brown" )     # color of this branch
        
    win.getMouse()
    win.close()

main()

Yellow-Blue Fractal Tree

# fractalTreeYellowBlue.py
# D. Thiebaut
# Code taken from http://openbookproject.net/thinkcs/python/english3e/recursion.html
# and adapted to work with graphics111.py.
#
# Draws a fractal tree on the graphic window.
#
from graphics import *
import math
import time
import random

# dimensions of the window
MAXWIDTH = 800
MAXHEIGHT = 800

# recursive tree-drawing function
# 
def draw_tree(win   ,       # the canvas
              order,        # the level of recursion.  Starts positive.
              theta,        # angle of new branch leaving this trunk
              sz,           # size of this branch
              x, y,         # coordinates of base of this branch
              heading,      # angle of direction of this branch
              color         # color
              ):    

   trunk_ratio = 0.29       # How big is the trunk relative to whole tree?
   trunk = sz * trunk_ratio # length of trunk

   # compute x, y of end of the current branch (trunk)
   delta_x = trunk * math.cos(heading)
   delta_y = trunk * math.sin(heading)
   x2, y2 = x + delta_x, y + delta_y

   
   # draw current branch (trunk)
   branch = Line( Point( x, y), Point( x2, y2 ) )
   branch.setFill( color )
   branch.setWidth( 30*order )
   branch.setOutline( color_rgb( 25*order, 25*order, 255-25*order ) )
   branch.draw( win )

   # if this branch has sub-branches, then recurse
   if order > 0:    
       
      # make the recursive calls to draw the two subtrees
      newsz = sz*(1 - trunk_ratio)
      ratio = 1.0 # random.randrange( 80, 120 )/100.0
      if random.randrange(100) < 100:
         draw_tree(win,
                order-1, theta, newsz, x2, y2, heading-theta*ratio,
                color )
      if random.randrange(100) < 100:
         draw_tree(win,
                order-1, theta, newsz, x2, y2, heading+theta*ratio,
                color )
      

# draw 1 tree in the middle of the screen, shooting straight up.
def main():
    win = GraphWin("Fractal Tree", MAXWIDTH, MAXHEIGHT )
    theta = 0.5      # use 0.02 for tall skinny trees, 0.7 for fat trees
    draw_tree(win,
              12,
              theta,
              MAXWIDTH*0.9,
              MAXWIDTH//2,
              MAXHEIGHT-50,
              -math.pi/2,
              "brown" )
        
    win.getMouse()
    win.close()

main()

5/2/18

Final Exam: Find2ConsecutiveInts.py (iterative version, not recursive)

This is the iterative version of the program given on the Final Exam. For the final exam, though, the recursive version is required.

# Find2ConsecutiveInts.py
# D. Thiebaut
# This is the nonrecursive, iterative version of a program
# that finds out if there are two consecutive ints in a given list.
#
def find2Consecutive( L ):
    '''iterative function that loops through L, if it can,
    to see if two consecutive items have the same value.'''
    # start with the 2nd item, and compare it with the one
    # before, if possible.  If the same, we've found 2 consecutive
    # if the loop finishes, then we never found 2 similar items,
    # and we can safely return False.
    for i in range( 1, len( L ) ):
        if L[i]==L[i-1]:
            return True
    return False


def main():
    '''main program that keeps on prompting the user for a list
    of ints, and applies the find2Consecutive( ) function on the
    list.  You must enter the [ brackets ] when inputting the list.
    '''

    while True:
        # infinite loop.  Use Control-C to break out of it.
        L = eval( input( "> " ) )
        print( find2Consecutive( L ) )
        print()


main()

Hanoi.py

See this page for more information on the Towers of Hanoi problem.

# Hanoi.py
# D. Thiebaut

def moveDisks( N, src, dest, extra ):
    '''moves N disks from the src peg to the dest pet,
    using the extra peg as needed.'''

    # stopping condition: only 1 disk: we can do it!
    if N==1:
        print( src, dest )
        return

    # otherwise, if there's more than 1, we call ourselves
    # to move N-1 from src to extra, then move 1 from src
    # to dest, then move the N-1 on extra to dest, and we're
    # done

    # move N-1 to extra
    moveDisks( N-1, src, extra, dest )
    moveDisks( 1, src, dest, extra )
    moveDisks( N-1, extra, dest, src )

def main():
    N = eval( input( "Number of disks? " ) )
    moveDisks( N, 'A', 'C', 'B' )

main()