Python for Kids: Python 3 – Project 10

Using Python 3 in Project 10 of Python For Kids For Dummies

In this post I talk about the changes that need to be made to the code of Project 10 of my book Python for Kids for Dummies in order for it to work with Python 3. The main difference between the Python 2.7 and Python 3 code for this project is that Python 3 uses raw_input and that has been renamed to input in Python 3. Most of the code in project 10 will work with this one change. However, in a lot of cases what Python outputs in Python 3 is different from the output in Python 2.7. This project has a lot of code. In order to shorten the length of this post I am only showing the Python 3 versions of the longer pieces (rather than both Python 2.7 (from the book) and Python 3). Look at the book to see the Python 2.7 code (it’s very similar).

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3. I am working through the code in the existing book, highlighting changes from Python 2 to Python 3 and providing code that will work in Python 3. If you are using Python 2.7 you can ignore this post. This post is only for people who want to take the code in my book Python for Kids for Dummies and run it in Python 3.

######## Page 283

The code on this page uses raw_input, which has been renamed to input in Python 3. You can either replace all occurrences of raw_input with input or add a line:

raw_input = input 

at the start of the relevant code. In order to reduce the amount of code being repeated, I am adding raw_input = input to the Constants section of the code. You will need to remember that all of the later code assumes that this line has been added.

  
"""
Python 2.7
math_trainer.py
Train your times tables.
Initial Features:
* Print out times table for a given number.
* Limit tables to a lower number (default is 1)
and an upper number (default is 12).
* Pose test questions to the user
* Check whether the user is right or wrong
* Track the user's score.
Brendan Scott
February 2015
"""
#### Constants Section
TEST_QUESTION = (4, 6)
QUESTION_TEMPLATE = "What is %sx%s? "
#### Function Section
#### Testing Section
question = TEST_QUESTION
prompt = QUESTION_TEMPLATE%question
correct_answer = question[0]*question[1] # indexes start from 0
answer = raw_input(prompt)
if int(answer)== correct_answer:
    print("Correct!")
else:
    print("Incorrect")

>>> ================================ RESTART ================================
>>>
What is 4x6? 24
Correct!
>>> ================================ RESTART ================================
>>>
What is 4x6? 25
Incorrect

     

"""
Python 3
math_trainer.py
Train your times tables.
Initial Features:
* Print out times table for a given number.
* Limit tables to a lower number (default is 1)
and an upper number (default is 12).
* Pose test questions to the user
* Check whether the user is right or wrong
* Track the user's score.
Brendan Scott
February 2015
"""
#### Constants Section
raw_input = input # this line added
TEST_QUESTION = (4, 6)
QUESTION_TEMPLATE = "What is %sx%s? "

#### Function Section

#### Testing Section
question = TEST_QUESTION
prompt = QUESTION_TEMPLATE%question
correct_answer = question[0]*question[1] # indexes start from 0
answer = raw_input(prompt)
if int(answer)== correct_answer:
    print("Correct!")
else:
    print("Incorrect")

>>> ================================ RESTART ================================
>>>
What is 4x6? 24
Correct!
>>> ================================ RESTART ================================
>>>
What is 4x6? 25
Incorrect

######## Page 286-296

All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
Remember that for the code to work in Python 3 code an additional line

raw_input = input

as added in the Constants section of the code.

######## Page 297

All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.

######## Page 298
The code in this section is different in Python 2.7 v Python 3.
The Python 2.7 code assumed that there was a list and that a while loop repeatedly removed things from that list. When everything was removed then the loop stopped. This was achieved by a test

batch != []

that is, stop when the variable batch is an empty list.
Ultimately, what is in batch comes from a call to the range builtin:

tables_to_print = range(1, upper+1)

In Python 2.7 this is a list which is generated in full and stored in tables_to_print. In Python 3 it’s not. Rather the range builtin generates the values that are needed at the time they are needed – not before. In Python 3 batch is a “range object”, not a list. And, while batch gets shorter and shorter, it’s never going to be an empty list (it would need to stop being a range and start being a list), no matter how long the program runs. To get this code working in Python 2.7 you can either:
(A) explicitly make batch a list by changing the line:

tables_to_print = range(1, upper+1)

to

tables_to_print = list(range(1, upper+1))

this changes all the relevant variables (and, in particular batch) into lists so the condition in the while loop will evaluate as you expect; or

(B) change the condition in the while loop to check the length of batch rather than whether or not it is an empty list. That is change:

 
    while batch != []: # stop when there's no more to print

to

 
    while len(batch) > 0: # stop when there's no more to print

That is, once the length is 0 (ie no more elements to display), stop the loop. I think this is the better of the two options because it makes the test independent of the type of variable used to keep track of batches.

Remember that the Python 3 code has an additional line

 
raw_input = input

in the Constants section of the code.

 
#Python 2.7

TIMES_TABLE_ENTRY = "%2i x %2i = %3i "

def display_times_tables(upper=UPPER):
    """
    Display the times tables up to UPPER
    """
    tables_per_line = 5
    tables_to_print = range(1, upper+1)
    # get a batch of 5 to print
    batch = tables_to_print[:tables_per_line]
    # remove them from the list
    tables_to_print = tables_to_print[tables_per_line:]
    while batch != []: # stop when there's no more to print
        for x in range(1, upper+1):
            # this goes from 1 to 12 and is the rows
            accumulator = []
            for y in batch:
                # this covers only the tables in the batch
                # it builds the columns
                accumulator.append(TIMES_TABLE_ENTRY%(y, x, x*y))
            print("".join(accumulator)) # print one row
        print("\n") # vertical separation between blocks of tables.
        # now get another batch and repeat.
        batch = tables_to_print[:tables_per_line]
        tables_to_print = tables_to_print[tables_per_line:]

     

#Python 3                            
TIMES_TABLE_ENTRY = "%2i x %2i = %3i "

def display_times_tables(upper=UPPER):
    """
    Display the times tables up to UPPER
    """
    tables_per_line = 5
    tables_to_print = list(range(1, upper+1))
    # get a batch of 5 to print
    batch = tables_to_print[:tables_per_line]
    # remove them from the list
    tables_to_print = tables_to_print[tables_per_line:]
    while len(batch)>0: # stop when there's no more to print
        for x in range(1, upper+1):
            # this goes from 1 to 12 and is the rows
            accumulator = []
            for y in batch:
                # this covers only the tables in the batch
                # it builds the columns
                accumulator.append(TIMES_TABLE_ENTRY%(y, x, x*y))
            print("".join(accumulator)) # print one row
        print("\n") # vertical separation between blocks of tables.
        # now get another batch and repeat.
        batch = tables_to_print[:tables_per_line]
        tables_to_print = tables_to_print[tables_per_line:]
        

######## Page 302, 304
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
Remember that the Python 3 code has an additional line

   
raw_input = input 

in the Constants section of the code.

######## Page 305-306

All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.

######## Page 307
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
Remember that the Python 3 code has an additional line

   
raw_input = input

in the Constants section of the code.

#########################################
### Full Code:
#########################################

The code in this section is different in Python 2.7 v Python 3.
The Python 3 code has an additional line
raw_input = input
in the Constants section of the code and the line

   
    while batch != []: # stop when there's no more to print

has been changed to

   
    while len(batch) > 0: # stop when there's no more to print
     
"""
math_trainer.py
Train your times tables.
Initial Features:
* Print out times table for a given number.
* Limit tables to a lower number (default is 1) and
an upper number (default is 12).
* Pose test questions to the user
* Check whether the user is right or wrong
* Track the user's score.
Brendan Scott
February 2015
"""

#### Imports Section
import random
import sys
import time

#### Constants Section
TEST_QUESTION = (4, 6)
QUESTION_TEMPLATE = "What is %sx%s? "
LOWER = 1
UPPER = 12
MAX_QUESTIONS = 10 # for testing, you can increase it later
TIMES_TABLE_ENTRY = "%2i x %2i = %3i "

INSTRUCTIONS = """Welcome to Math Trainer
This application will train you on your times tables.
It can either print one or more of the tables for you
so that you can revise (training) or you it can test
you on your times tables.
"""
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '
SCORE_TEMPLATE = "You scored %s (%i%%) in %.1f seconds"

#### Function Section
def make_question_list(lower=LOWER, upper=UPPER, random_order=True):
    """ prepare a list of questions in the form (x,y)
    where x and y are in the range from LOWER to UPPER inclusive
    If random_order is true, rearrange the questions in a random
    order
    """
    spam = [(x+1, y+1) for x in range(lower-1, upper)
                       for y in range(lower-1, upper)]
    if random_order:
        random.shuffle(spam)
    return spam

def display_times_tables(upper=UPPER):
    """
    Display the times tables up to UPPER
    """
    tables_per_line = 5
    tables_to_print = range(1, upper+1)
    # get a batch of 5 to print
    batch = tables_to_print[:tables_per_line]
    # remove them from the list 
    tables_to_print = tables_to_print[tables_per_line:]
    while batch != []: # stop when there's no more to print
        for x in range(1, upper+1):
            # this goes from 1 to 12 and is the rows 
            accumulator = []
            for y in batch:
                # this covers only the tables in the batch
                # it builds the columns
                accumulator.append(TIMES_TABLE_ENTRY%(y, x, x*y))
            print("".join(accumulator)) # print one row
        print("\n") # vertical separation between blocks of tables.
        # now get another batch and repeat. 
        batch = tables_to_print[:tables_per_line]
        tables_to_print = tables_to_print[tables_per_line:]

    
def do_testing():
    """ conduct a round of testing """
    question_list = make_question_list()
    score = 0
    start_time = time.time()
    for i, question in enumerate(question_list):
        if i >= MAX_QUESTIONS:
            break
        prompt = QUESTION_TEMPLATE%question
        correct_answer = question[0]*question[1]
        # indexes start from 0
        answer = raw_input(prompt)

        if int(answer) == correct_answer:
            print("Correct!")
            score = score+1
        else:
            print("Incorrect, should have "+\
                  "been %s"%(correct_answer))

    end_time = time.time()
    time_taken = end_time-start_time
    percent_correct = int(score/float(MAX_QUESTIONS)*100)
    print(SCORE_TEMPLATE%(score, percent_correct, time_taken))

def do_quit():
    """ quit the application"""
    if confirm_quit():
        sys.exit()
    print("In quit (not quitting, returning)")

def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes 
    Return True (yes, quit) or False (no, don't quit) """
    spam = raw_input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True    


#### Testing Section

#do_testing()
##display_times_tables()

#### Main Section

if __name__ == "__main__":
    while True:
        print(INSTRUCTIONS)
        raw_input_prompt = "Press: 1 for training,"+\
                           " 2 for testing, 3 to quit.\n"
        selection = raw_input(raw_input_prompt)
        selection = selection.strip()
        while selection not in ["1", "2", "3"]:
            selection = raw_input("Please type either 1, 2, or 3: ")
            selection = selection.strip()

        if selection == "1":
            display_times_tables()
        elif selection == "2":
            do_testing()
        else:  # has to be 1, 2 or 3 so must be 3 (quit)
            do_quit()

     

"""
math_trainer.py (Python 3)
Train your times tables.
Initial Features:
* Print out times table for a given number.
* Limit tables to a lower number (default is 1) and
an upper number (default is 12).
* Pose test questions to the user
* Check whether the user is right or wrong
* Track the user's score.
Brendan Scott
February 2015
"""

#### Imports Section
import random
import sys
import time

#### Constants Section
raw_input = input
TEST_QUESTION = (4, 6)
QUESTION_TEMPLATE = "What is %sx%s? "
LOWER = 1
UPPER = 12
MAX_QUESTIONS = 10 # for testing, you can increase it later
TIMES_TABLE_ENTRY = "%2i x %2i = %3i "

INSTRUCTIONS = """Welcome to Math Trainer
This application will train you on your times tables.
It can either print one or more of the tables for you
so that you can revise (training) or you it can test
you on your times tables.
"""
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '
SCORE_TEMPLATE = "You scored %s (%i%%) in %.1f seconds"

#### Function Section
def make_question_list(lower=LOWER, upper=UPPER, random_order=True):
    """ prepare a list of questions in the form (x,y)
    where x and y are in the range from LOWER to UPPER inclusive
    If random_order is true, rearrange the questions in a random
    order
    """
    spam = [(x+1, y+1) for x in range(lower-1, upper)
                       for y in range(lower-1, upper)]
    if random_order:
        random.shuffle(spam)
    return spam

def display_times_tables(upper=UPPER):
    """
    Display the times tables up to UPPER
    """
    tables_per_line = 5
    tables_to_print = range(1, upper+1)
    # get a batch of 5 to print
    batch = tables_to_print[:tables_per_line]
    # remove them from the list 
    tables_to_print = tables_to_print[tables_per_line:]
    while len(batch) > 0: # stop when there's no more to print
        for x in range(1, upper+1):
            # this goes from 1 to 12 and is the rows 
            accumulator = []
            for y in batch:
                # this covers only the tables in the batch
                # it builds the columns
                accumulator.append(TIMES_TABLE_ENTRY%(y, x, x*y))
            print("".join(accumulator)) # print one row
        print("\n") # vertical separation between blocks of tables.
        # now get another batch and repeat. 
        batch = tables_to_print[:tables_per_line]
        tables_to_print = tables_to_print[tables_per_line:]

    
def do_testing():
    """ conduct a round of testing """
    question_list = make_question_list()
    score = 0
    start_time = time.time()
    for i, question in enumerate(question_list):
        if i >= MAX_QUESTIONS:
            break
        prompt = QUESTION_TEMPLATE%question
        correct_answer = question[0]*question[1]
        # indexes start from 0
        answer = raw_input(prompt)

        if int(answer) == correct_answer:
            print("Correct!")
            score = score+1
        else:
            print("Incorrect, should have "+\
                  "been %s"%(correct_answer))

    end_time = time.time()
    time_taken = end_time-start_time
    percent_correct = int(score/float(MAX_QUESTIONS)*100)
    print(SCORE_TEMPLATE%(score, percent_correct, time_taken))

def do_quit():
    """ quit the application"""
    if confirm_quit():
        sys.exit()
    print("In quit (not quitting, returning)")

def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes 
    Return True (yes, quit) or False (no, don't quit) """
    spam = raw_input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True    


#### Testing Section

#do_testing()
##display_times_tables()

#### Main Section

if __name__ == "__main__":
    while True:
        print(INSTRUCTIONS)
        raw_input_prompt = "Press: 1 for training,"+\
                           " 2 for testing, 3 to quit.\n"
        selection = raw_input(raw_input_prompt)
        selection = selection.strip()
        while selection not in ["1", "2", "3"]:
            selection = raw_input("Please type either 1, 2, or 3: ")
            selection = selection.strip()

        if selection == "1":
            display_times_tables()
        elif selection == "2":
            do_testing()
        else:  # has to be 1, 2 or 3 so must be 3 (quit)
            do_quit()

Python for Kids: Python 3 – Project 9

Using Python 3 in Project 9 of Python For Kids For Dummies

In this post I talk about the changes that need to be made to the code of
Project 9 in order for it to work with Python 3. Most of the code in project 9 will work without changes.
However, in a lot of cases what Python outputs in Python 3 is different from the output in Python 2.7.
This project has a lot of code. To shorten the length of this post I am only showing the Python 3 versions of
the longer pieces, rather than both Python 2.7 (from the book) and Python 3.

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3.
I am working through the code in the existing book, highlighting changes from Python 2 to Python 3
and providing code that will work in Python 3. If you are using Python 2.7 you can ignore this post.
This post is only for people who want to take the code in my book Python for Kids for Dummies and
run it in Python 3.

Page 240
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice. For example, on this page a class is defined
using class AddressEntry(object): (in Python 2.7). In Python 3 it’s just class AddressEntry:

    

>>> class AddressEntry(object):
        """
        AddressEntry instances hold and manage details of a person
        """
        pass
        
       
>>> AddressEntry # without parentheses
<class '__main__.AddressEntry'>
>>>
                            
                            
>>> AddressEntry() # parentheses create an instance
<__main__.AddressEntry object at 0x7f9309751590>


>>> address_entry = AddressEntry()
                         
                         
# Python 3 
>>> class AddressEntry: # note: no (object)
        """
        AddressEntry instances hold and manage details of a person
        """
        pass
        
       
>>> AddressEntry # without parentheses
<class '__main__.AddressEntry'>
>>>
                            
                            
>>> AddressEntry() # parentheses create an instance
<__main__.AddressEntry object at 0x7f9309751590>


>>> address_entry = AddressEntry()

Page 241
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 242
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
You still need to use () when creating instances of an object. That is, making an instance of a class, rather than
defining the class.

Page 244
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice.

    
Python 2.7
"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name
family name
email address
date of birth
[other stuff]
Brendan Scott
Feb 2015
"""
##### Classes Section
class AddressBook(object):
    """
    AddressBook instances hold and manage a list of people
    """
    pass
    
    
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    
    
##### Main Section
if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry()

    
# Python3
"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name
family name
email address
date of birth
[other stuff]
Brendan Scott
Feb 2015
"""
##### Classes Section
class AddressBook:
    """
    AddressBook instances hold and manage a list of people
    """
    pass
    
    
class AddressEntry:
    """
    AddressEntry instances hold and manage details of a person
    """
    
    
##### Main Section
if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry()
    

Page 245
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 246
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice.

    
#Python2.7
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                  email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        
        
#Python3
class AddressEntry:
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                  email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        

Page 248
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice.

    
############Python 2.7
##### Classes Section
class AddressBook(object):
    """
    AddressBook instances hold and manage a list of people
    """
    pass
    
    
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                 email_address=None, date_of_birth=None):
          """Initialize attributes first_name,
          family_name and date_of_birth.
          Each argument should be a string.
          date_of_birth should be of the form "MM DD, YYYY"
          """
          self.first_name = first_name
          self.family_name = family_name
          self.email_address = email_address
          self.date_of_birth = date_of_birth
          
          
##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)
    
    
                     
############Python 3
##### Classes Section
class AddressBook:
    """
    AddressBook instances hold and manage a list of people
    """
    pass
    
    
class AddressEntry:
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                 email_address=None, date_of_birth=None):
          """Initialize attributes first_name,
          family_name and date_of_birth.
          Each argument should be a string.
          date_of_birth should be of the form "MM DD, YYYY"
          """
          self.first_name = first_name
          self.family_name = family_name
          self.email_address = email_address
          self.date_of_birth = date_of_birth
          
          
##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)

Page 250
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 252-253
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice.

        
#################Python2.7
    
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                  email_address=None, date_of_birth=None):
        """initialize attributes first_name, family_name
            and date_of_birth
        each argument should be a string
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                   "family_name='%s',"+\
                   " email_address='%s', "+\
                   "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                          self.email_address, self.date_of_birth)
                          
##### Functions Section

##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)
    
    
#################Python3    
class AddressEntry:
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                  email_address=None, date_of_birth=None):
        """initialize attributes first_name, family_name
            and date_of_birth
        each argument should be a string
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                   "family_name='%s',"+\
                   " email_address='%s', "+\
                   "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                          self.email_address, self.date_of_birth)
                          
##### Functions Section

##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)

Page 254-256
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.
However, in Python 3 you don’t need to add “(object)” when defining a class – it is assumed.
It is not an error to add (object) in Python 3, it just doesn’t look as nice.

    
"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name
family name
email address
date of birth
[other stuff]
Brendan Scott
Feb 2015
"""


##### Classes Section
class AddressBook(object):
    """
    AddressBook instances hold and manage a list of people
    """
    def __init__(self):
        """ Set people attribute to an empty list"""
        self.people = []
    def add_entry(self, new_entry):
        """ Add a new entry to the list of people in the
        address book the new_entry should be an instance
        of the AddressEntry class"""
        self.people.append(new_entry)
        
        
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                  "family_name='%s',"+\
                  "email_address='%s', "+\
                  "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                         self.email_address, self.date_of_birth)
                         
##### Functions Section

##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)
    address_book.add_entry(person1)
    print(address_book.people)
                              

                              
#################Python3                              
                              
"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name
family name
email address
date of birth
[other stuff]
Brendan Scott
Feb 2015
"""


##### Classes Section
class AddressBook:
    """
    AddressBook instances hold and manage a list of people
    """
    def __init__(self):
        """ Set people attribute to an empty list"""
        self.people = []
    def add_entry(self, new_entry):
        """ Add a new entry to the list of people in the
        address book the new_entry should be an instance
        of the AddressEntry class"""
        self.people.append(new_entry)
        
        
class AddressEntry:
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                  "family_name='%s',"+\
                  "email_address='%s', "+\
                  "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                         self.email_address, self.date_of_birth)
                         
##### Functions Section

##### Main Section

if __name__ == "__main__":
    address_book = AddressBook()
    person1 = AddressEntry("Eric", "Idle", None, "March 29, 1943")
    print(person1)
    address_book.add_entry(person1)
    print(address_book.people)

Page 256

The code on this page is a little different. As explained in Project 7, the syntax for the open()
builtin is the same in Python 2.7 and Python 3, but Python 3 treats the files it opens differently
In code on this page, you are opening a file to write a “pickle” to. In Python 3 you need to open
the file with a “binary” modifier. That is, you need to use ‘wb’ rather than ‘w’. Similarly, to read
from a pickle file you need to open it using ‘rb’ rather than ‘r’.
When reading the pickle file, Python3 uses a different way of representing the data.
How it’s different is not relevant to the project, so you can ignore it. All you need
to do is notice that pickle has written something to the file and it’s encoded in some way.

    
#Python2.7
>>> import pickle
>>> FILENAME = "p4k_test.pickle"
>>>  dummy_list = [x*2 for x in range(10)]
>>>  dummy_list # confirm what it looks like
[0,  2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>  with open(FILENAME,'w') as file_object: #now dump it!
        pickle.dump(dummy_list,file_object)
        
>>> # open the raw file to look at what was written
>>> with open(FILENAME,'r') as file_object: # change w to r!!!
        print(file_object.read())
        
(lp0
I0
aI2
aI4
aI6
aI8
aI10
aI12
aI14
aI16
aI18
a.

#Python3
>>> import pickle
>>> FILENAME = "p4k_test.pickle"
>>>  dummy_list = [x*2 for x in range(10)]
>>>  dummy_list # confirm what it looks like
[0,  2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>  with open(FILENAME,'wb') as file_object: #now dump it!
        pickle.dump(dummy_list,file_object)

>>> # open the raw file to look at what was written
>>> with open(FILENAME,'rb') as file_object: # change w to r!!!
        print(file_object.read())        

b'\x80\x03]q\x00(K\x00K\x02K\x04K\x06K\x08K\nK\x0cK\x0eK\x10K\x12e.'
>>>         

Page 258
Code is slightly different. As explained above, use ‘rb’ to open the file, rather than ‘r’

    
## Python2.7
Python 2.7.3 (default, Apr 14 2012, 08:58:41) [GCC] on linux2
Type "copyright", "credits" or "license()" for more information.
>>> import pickle
>>> FILENAME = "p4k_test.pickle"
>>> with open(FILENAME,'r') as file_object:
          dummy_copy = pickle.load(file_object)
          
>>> dummy_copy
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

## Python3
Python 3.3.5 (default, Mar 27 2014, 17:16:46) [GCC] on linux
Type "copyright", "credits" or "license()" for more information.
>>> import pickle
>>> FILENAME = "p4k_test.pickle"
>>> with open(FILENAME,'rb') as file_object:
          dummy_copy = pickle.load(file_object)

          
>>> dummy_copy
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> 

Page 260
Python3 now uses cPickle when you import pickle. If it can’t find cPickle
then it falls back to using the old pickle. So don’t worry about cPickle if you’re using Python 3.
As explained above, also use ‘wb’ to open the file, rather than ‘w’

    
# Python 2.7
#### Imports
import cPickle as pickle

#### Constants
SAVE_FILE_NAME = "address_book.pickle"

                          
    def save(self):
        with open(SAVE_FILE_NAME, 'w') as file_object:
              pickle.dump(self, file_object)
              
# Python 3
#### Imports
import pickle

#### Constants
SAVE_FILE_NAME = "address_book.pickle"

                          
    def save(self):
        with open(SAVE_FILE_NAME, 'wb') as file_object:
              pickle.dump(self, file_object)

Page 261
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 262
Code is different:
* As explained above, use ‘rb’ to open the file, rather than ‘r’

    
#Python 2.7

    def load(self):
        """
        Load a pickled address book from the standard save file
        """
        with open(SAVE_FILE_NAME, 'r') as file_object:
            self.address_book = pickle.load(file_object)
            
#Python 3

    def load(self):
        """
        Load a pickled address book from the standard save file
        """
        with open(SAVE_FILE_NAME, 'rb') as file_object:
            self.address_book = pickle.load(file_object)
#Python 3
    
"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name
family name
email address
date of birth
[other stuff]

Brendan Scott
Feb 2015
"""

#### Imports
import pickle

#### Constants
SAVE_FILE_NAME = "address_book.pickle"

##### Classes Section
class AddressBook(object):
    """
    AddressBook instances hold and manage a list of people
    """
    def __init__(self):
        """ Set people attribute to an empty list"""
        self.people = []
        
    def add_entry(self, new_entry):
        """ Add a new entry to the list of people in the
        address book the new_entry should be an instance
        of the AddressEntry class"""
        self.people.append(new_entry)
        
    def save(self):
        """ save a copy of self into a pickle file"""
        with open(SAVE_FILE_NAME, 'wb') as file_object:
            pickle.dump(self, file_object)
            
            
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                  email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                    "family_name='%s',"+\
                    "email_address='%s', "+\
                    "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                          self.email_address, self.date_of_birth)
                          
                          
class Controller(object):
    """
    Controller acts as a way of managing the data stored in
    an instance of AddressBook and the user, as well as managing
    loading of stored data
    """
    def __init__(self):
        """
        Initialise controller. Look for a saved address book
        If one is found,load it, otherwise create an empty
        address book.
        """
        self.address_book = AddressBook()
        person1 = AddressEntry("Eric", "Idle", "March 29, 1943")
        self.address_book.add_entry(person1)
        
    def load(self):
        """
        Load a pickled address book from the standard save file
        """
        with open(SAVE_FILE_NAME, 'rb') as file_object:
            self.address_book = pickle.load(file_object)
                    
##### Functions Section

##### Main Section
if __name__ == "__main__":
    controller = Controller()
    print(controller.address_book.people)

Page 266
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 267
Code is different:
* import pickle (not import cPickle as pickle)
* As explained above, use ‘rb’ to open the file, rather than ‘r’

           
#Python 3
#### Imports
import pickle
import os.path


#### Constants
SAVE_FILE_NAME = "address_book.pickle"


class Controller(object):
    """
    Controller acts as a way of managing the data stored in
    an instance of AddressBook and the user, as well as managing
    loading of stored data
    """
    def __init__(self):
        """
        Initialize controller. Look for a saved address book
        If one is found,load it, otherwise create an empty
        address book.
        """
        self.address_book = self.load()
        if self.address_book is None:
            self.address_book = AddressBook()
              
    def load(self):
        """
        Load a pickled address book from the standard save file
        """
        #TODO: Test this method
        if os.path.exists(SAVE_FILE_NAME):
            with open(SAVE_FILE_NAME, 'rb') as file_object:
                return pickle.load(file_object)
        else:
            return None

Page 270-272
This code uses raw_input. As explained in Python 3/Project 3 you need to either replace
all references to raw_input with just input or add new line raw_input = input
in the Constants section

            
#Python 3

#### Constants
raw_input = input
SAVE_FILE_NAME = "address_book.pickle"
INSTRUCTIONS = """Address Book Application
(Python For Kids For Dummies Project 9)
Press:
a to add an entry
d to display a list of all entries in summary form.
i to print these instructions again
q to quit.
"""
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '


    def __init__(self):
        """
        Initialize controller. Look for a saved address book
        If one is found,load it, otherwise create an empty
        address book.
        """
        self.address_book = self.load()
        if self.address_book is None:
            self.address_book = AddressBook()
        self.run_interface()

    def run_interface(self):
        """ Application's main loop.
        Get user input and respond accordingly"""
        print(INSTRUCTIONS)
        while True:
            command = raw_input("What would you like to do? ")
            if command == "a":
                self.add_entry()
            elif command == "q":
                if confirm_quit():
                    print("Saving")
                    self.address_book.save()
                    print("Exiting the application")
                    break
            elif command == "i":
                print(INSTRUCTIONS)
            elif command == "d":
                self.display_summaries()
            else:
                template = "I don't recognise that instruction (%s)"
                print(template%command)
                
    def add_entry(self):
        """query user for values to add a new entry"""
        print("In add_entry")

    def display_summaries(self):
        """ display summary information for each entry in
        address book"""
        print("In display_summaries")

Page 274
Changes necessary for the code to work in Python 3:
* imports cPickle – just import pickle
* uses raw_input – Need to add a line raw_input = input in the Constants section
* uses ‘r’ and ‘w’ when opening files for pickle – need to use ‘rb’ and ‘wb’

#Python 3

"""
Addressbook.py
An address book program to store details of people I know.
Stuff I'm storing is:
first name

family name
email address
date of birth
[other stuff]
Brendan Scott
Feb 2015
"""


#### Imports
import pickle
import os.path


#### Constants
raw_input = input
SAVE_FILE_NAME = "address_book.pickle"
INSTRUCTIONS = """Address Book Application
(Python For Kids For Dummies Project 9)
Press:
a to add an entry
d to display a list of all entries in summary form.
i to print these instructions again
q to quit.
"""
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '
SUMMARY_TEMPLATE = "%s %s DOB: %s email: %s"

##### Classes Section
class AddressBook(object):
    """
    AddressBook instances hold and manage a list of people
    """
    def __init__(self):
        """ Set people attribute to an empty list"""
        self.people = []
        
    def add_entry(self, new_entry):
        """ Add a new entry to the list of people in the
        address book the new_entry should be an instance                                      
        of the AddressEntry class"""
        self.people.append(new_entry)
        
    def save(self):
        """ save a copy of self into a pickle file"""
        with open(SAVE_FILE_NAME, 'wb') as file_object:
              pickle.dump(self, file_object)
              
              
class AddressEntry(object):
    """
    AddressEntry instances hold and manage details of a person
    """
    def __init__(self, first_name=None, family_name=None,
                    email_address=None, date_of_birth=None):
        """Initialize attributes first_name,
        family_name and date_of_birth.
        Each argument should be a string.
        date_of_birth should be of the form "MM DD, YYYY"
        """
        self.first_name = first_name
        self.family_name = family_name
        self.email_address = email_address
        self.date_of_birth = date_of_birth
        
    def __repr__(self):
        """
        Given an AddressEntry object self return
        a readable string representation
        """
        template = "AddressEntry(first_name='%s', "+\
                      "family_name='%s',"+\
                      " email_address='%s', "+\
                      "date_of_birth='%s')"
        return template%(self.first_name, self.family_name,
                          self.email_address, self.date_of_birth)
                            
                            
class Controller(object):
    """
    Controller acts as a way of managing the data stored in
    an instance of AddressBook and the user, as well as managing
    loading of stored data
    """
    def __init__(self):
        """
        Initialize controller. Look for a saved address book
        If one is found,load it, otherwise create an empty
        address book.
        """
        self.address_book = self.load()
        if self.address_book is None:
            self.address_book = AddressBook()
        self.run_interface()
        
    def load(self):
        """
        Load a pickled address book from the standard save file
        """
        if os.path.exists(SAVE_FILE_NAME):
            with open(SAVE_FILE_NAME, 'rb') as file_object:
                address_book = pickle.load(file_object)
            return address_book
        else:
            return None
            
    def run_interface(self):
        """ Application's main loop.
        Get user input and respond accordingly"""
        print(INSTRUCTIONS)
        while True:
            command = raw_input("What would you like to do? ")
            if command == "a":
                self.add_entry()
            elif command == "q":
                if confirm_quit():
                    print("Saving")
                    self.address_book.save()
                    print("Exiting the application")
                    break
            elif command == "i":
                print(INSTRUCTIONS)
            elif command == "d":
                self.display_summaries()
            else:
                template = "I don't recognise that instruction (%s)"
                print(template%command)
                
    def add_entry(self):
        """query user for values to add a new entry"""
        print("Adding a new person to the address book")
        print("What is the person's:")
        first_name = raw_input("First Name? ")
        if first_name == "q":
            print("Not Adding")
            return
        family_name = raw_input("Family Name? ")
        if family_name == "q":
            print("Not Adding")
            return
        email_address = raw_input("Email Address? ")
        if email_address == "q":
            print("Not Adding")
            return
        DOB_PROMPT = "Date of Birth (Month day, year)? "
        date_of_birth = raw_input(DOB_PROMPT)
        if date_of_birth == "q":
            print("Not Adding ")
            return
        entry = AddressEntry(first_name, family_name,
                             email_address, date_of_birth)
        self.address_book.add_entry(entry)
        values = (first_name, family_name)
        print("Added address entry for %s %s\n"%values)
            
    def display_summaries(self):
        """ display summary information for each entry in
        address book"""
        print("Displaying Summaries")
        for index, e in enumerate(self.address_book.people):
            values = (e.first_name, e.family_name,
                      e.date_of_birth, e.email_address)
            entry = SUMMARY_TEMPLATE%values
            print("%s: %s"%(index+1, entry))
            # start numbering at 1
           
           
##### Functions Section
def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes
    Return True (yes, quit) or False (no, don't quit) """
    spam = raw_input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True
        
        
##### Main Section
if __name__ == "__main__":
    controller = Controller()

Python for Kids: Python 3 – Project 8

Using Python 3 in Project 8 of Python For Kids For Dummies

In this post I talk about the changes that need to be made to the code of
Project 8 in order for it to work with Python 3. Most of the code in project 8 will work without changes.
However, in a lot of cases what Python outputs in Python 3 is different from the output in Python 2.7.

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3.
I am working through the code in the existing book, highlighting changes from Python 2 to Python 3
and providing code that will work in Python 3. If you are using Python 2.7 you can ignore this post.
This post is only for people who want to take the code in my book Python for Kids for Dummies and
run it in Python 3.

Page 220

All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 222

All code syntax on page is the same, but some outputs are different in Python 3 – different output from type().

  
#Python 2.7
>>> "%s %s"%(1,2)
'1 2'
                             
                             
"%s %s"%(1) #(two specifiers, one value)
"%s %s"%(1,2,3) #(two specifiers, three values)
                              
                              
>>> values = (1,2)
>>> "%s %s"%values
'1 2'
>>> # Snuck in a tuple:
>>> type(values)
<type 'tuple'>
                              
                    
#Python 3 
>>> "%s %s"%(1,2)
'1 2'
                             
                             
"%s %s"%(1) #(two specifiers, one value)
"%s %s"%(1,2,3) #(two specifiers, three values)
                              

>>> values = (1,2)
>>> "%s %s"%values
'1 2'
>>> type(values)
<class 'tuple'>
>>> 
 

Page 223 – 224
All code on this page is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Page 225
All code syntax on page is the same, but some outputs are different in Python 3 – different error messages.

  
#Python 2.7     
>>> def test_function():
        return (1,2,3) # returns a tuple with three elements
        
>>> a = test_function()
>>> a
(1, 2, 3)
>>> a,b,c = test_function()
>>> a
1
>>> b
2
>>> c
3
>>> a,b = test_function()

Traceback (most recent call last):
  File "<pyshell#59>", line 1, in <module>
    a,b = test_function()
ValueError: too many values to unpack
                            
                            
>>> a,b,c = (1,2,3) # unpack the tuple into a, b, c
>>> print("a: %s, b: %s, c: %s"%(a,b,c))
a: 1, b: 2, c: 3
>>> a,b = (1,2,3) # three values but only two variables.

Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    a,b = (1,2,3)
ValueError: too many values to unpack

#Python 3
>>> def test_function():
        return (1,2,3) # returns a tuple with three elements
        
>>> a = test_function()
>>> a
(1, 2, 3)
>>> a,b,c = test_function()
>>> a
1
>>> b
2
>>> c
3
>>> a,b = test_function()
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    a,b = test_function()
ValueError: too many values to unpack (expected 2)
                            
                            
>>> a,b,c = (1,2,3) # unpack the tuple into a, b, c
>>> print("a: %s, b: %s, c: %s"%(a,b,c))
a: 1, b: 2, c: 3
>>> a,b = (1,2,3) # three values but only two variables.
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    a,b = (1,2,3) # three values but only two variables.
ValueError: too many values to unpack (expected 2)

Page 227-232

All code on these pages is the same, and all outputs from the code are the same in Python 3 as in Python 2.7.

Python for Kids: Python 3 – Project 7

Using Python 3 in Project 7 of Python For Kids For Dummies

In this post I talk about the changes that need to be made to the code of
Project 7 in order for it to work with Python 3. Most of the code in project 7 will work without changes. However, in a lot of cases what Python outputs in Python 3 is different from the output in Python 2.7 and it’s those changes that I am mainly identifying below.

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3.
I am working through the code in the existing book, highlighting changes from Python 2 to Python 3 and providing code that will work in Python 3. If you are using Python 2.7 you can ignore this post. This post is only for people who want to take the code in my book Python for Kids for Dummies and run it in Python 3.

Page 178

All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 179-180
The code and syntax on these pages is the same, but the outputs are
different in Python 3. This is because, in Python 3,
the range builtin does not create a list as in Python 2.7 (see Python3/Project 5)

#Python 2.7 code: 

>>> test_string = '0123456789'
>>> test_string[0:1]
'0'
>>> test_string[1:3]
'12'
>>> # range(10) is a list of the numbers from 0 to 9 inclusive
>>> range(10)[0:1]
[0]
>>> range(10)[1:3]
[1, 2]
>>> test_string[:3]
'012'
>>> test_string[3:]
'3456789'
#Python 3 code:
>>> test_string = '0123456789'
>>> test_string[0:1]
'0'
>>> test_string[1:3]
'12'
>>> # range(10) is no longer a list. It's a.... errr... range 
>>> # so the [:] operator slices. You can use list()
>>> # to see what it corresponds to.
>>> range(10)[0:1]
range(0, 1)
>>> list(range(10)[0:1])
[0]
>>> # note same output as in Python 2.7 from range(10)[0:1]
>>> range(10)[1:3]
range(1, 3)
>>> list(range(10)[1:3])
[1, 2]
>>> test_string[:3]
'012'
>>> test_string[3:]
'3456789'
>>> 

Pages 180-196
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 199

The code on this page uses raw_input, which has been renamed to input in Python 3.
Either change all occurrences or add a line

raw_input = input 

at the start of the relevant code.

#Python 2.7 code: 
#### Input and Output Section
message = raw_input("Type the message to process below:\n")
ciphertext = encrypt_msg(message, ENCRYPTION_DICT)
plaintext = decrypt_msg(message, DECRYPTION_DICT)
print("This message encrypts to")
print(ciphertext)
print # just a blank line for readability
print("This message decrypts to")
print(plaintext)

#Python 3 code: 
#### Input and Output Section
message = input("Type the message to process below:\n")
ciphertext = encrypt_msg(message, ENCRYPTION_DICT)
plaintext = decrypt_msg(message, DECRYPTION_DICT)
print("This message encrypts to")
print(ciphertext)
print # just a blank line for readability
print("This message decrypts to")
print(plaintext)


>>> ================================== RESTART ================================
>>>
Type the message you'd like to encrypt below:
I love learning Python. And my teacher is smelly. And I shouldn't start a sentence with and.
This message encrypts to
F|ilsb|ib7okfkd|Mvqelk+|xka|jv|qb79ebo|fp|pjbiiv+||xka|F|pelriak$q|pq7oq|7|pbkqbk9b|tfqe|7ka+
This message decrypts to
L2oryh2ohduqlqj2SBwkrq;2Dqg2pB2whdfkhu2lv2vphooB;22Dqg2L2vkrxogq*w2vwduw2d2vhqwhqfh2zlwk2dqg;

                             
>>> ================================== RESTART ================================
>>>
Type the message you'd like to encrypt below:
F|ilsb|ib7okfkd|Mvqelk+|xka|jv|qb79ebo|fp|pjbiiv+||xka|F|pelriak$q|pq7oq|7|pbkqbk9b|tfqe|7ka+
This message encrypts to
C_fip8_f84lhcha_Jsnbih(_uh7_gs_n846b8l_cm_mg8ffs(__uh7_C_mbiof7h!n_mn4ln_4_m8hn8h68_qcnb_4h7(
This message decrypts to
I love learning Python. And my teacher is smelly.  And I shouldn't start a sentence with and.

Page 200

This code works as is in both Python 2.7 and Python 3. However, the way the open() builtin works has changed in Python 3 and this will cause some issues in later projects. In Python 3 open() has the same syntax as in Python 2.7, but uses a different way to get data out of the file and into your hands. As a practical matter this means that some Python 2.7 code will sometimes cause problems when run in Python 3. If you run into such a problem (open code that works in Python 2.7 but fails in Python 3), the first thing to try is to add the binary modifier. So,
instead of ‘r’ or ‘w’ for read and write use ‘rb’ or ‘wb’. This code doesn’t need it, but a later project will.

Page 201

The code on this page is the same, but the outputs are different in Python 3. Python 3 returns how much data has
been written (in this case, 36)

#Python 2.7 code: 
>>> file_object = open('p4k_test.py','w')
>>> text = "print('Hello from within the file')\n" # watch the " and '
>>> file_object.write(text) # writes it to the file
>>> file_object.write(text) # writes it to the file again!
>>> file_object.close() # finished with file, so close it
#Python 3 code:
>>> file_object = open('p4k_test.py','w')
>>> text = "print('Hello from within the file')\n" # watch the " and '
>>> file_object.write(text) # writes it to the file
36
>>> file_object.write(text) # writes it to the file again!
36
>>> file_object.close() # finished with file, so close it

Pages 202 and 203

All code on these page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 204

All code on this page is the same in Python 3 as in Python 2.7, but some of the outputs are different
A line has been added in the Python 3 code below to shown that the file_object has been closed after leaving the
with clause – this was explicit in the print out in Python 2.7.

>>> #Python 2.7
>>> with open('p4k_test.py','r') as file_object:
        print(file_object.read())
        
        
print('Hello from within the file')
print('Hello from within the file')

>>> file_object
<closed file 'p4k_test.py', mode 'r' at 0xf7fed0>
       
       
>>> #Python 3
>>> with open('p4k_test.py','r') as file_object:
        print(file_object.read())

        
print('Hello from within the file')
print('Hello from within the file')

>>> file_object  # output different from 2.7
<_io.TextIOWrapper name='p4k_test.py' mode='r' encoding='UTF-8'>

>>> file_object.closed # but the file is still closed
True

Page 205

All code on this page is the same in Python 3 as in Python 2.7, but some of the outputs are different
A line has been added in the Python 3 code below to shown that the file_object has been closed after leaving the
with clause – this was explicit in the print out in Python 2.7. Also, because Python 3 uses a different way
of getting information from a file it is identified differently. In Python 2.7 it’s call a file – pretty straight
forward. in Python 3 it’s called a _io.TextIOWrapper. Not as enlightening, but a student doesn’t need to worry about
this difference in detail.

>>> #Python 2.7
>>> with open('testfile2','w') as a:
        a.write('stuff')
        
>>> with open('testfile2','r') as a,
         open('p4k_test.py','r') as b:
        print(a.read())
        print(b.read())
        
stuff
print('Hello from within the file')
print('Hello from within the file')

>>> a
<closed file 'testfile2', mode 'r' at 0xf6e540>
>>> b
<closed file 'p4k_test.py', mode 'r' at 0xef4ed0>


       
>>> #Python 3
>>> with open('testfile2','r') as a, open('p4k_test.py','r') as b:
	print(a.read())
	print(b.read())

	
stuff
print('Hello from within the file')
print('Hello from within the file')

>>> a
<_io.TextIOWrapper name='testfile2' mode='r' encoding='UTF-8'>
>>> a.closed
True
>>> b
<_io.TextIOWrapper name='p4k_test.py' mode='r' encoding='UTF-8'>
>>> b.closed
True                                  

Page 207

All code on this page is the same in Python 3 as in Python 2.7, but some of the outputs are different
(the write method returns the amount of data written and this is output in the console in Python 3)

>>> #Python 2.7
>>> INPUT_FILE_NAME = "cryptopy_input.txt"
>>> with open(INPUT_FILE_NAME,'w') as input_file:
        input_file.write('This is some test text')

       
>>> #Python 3
>>> INPUT_FILE_NAME = "cryptopy_input.txt"
>>> with open(INPUT_FILE_NAME,'w') as input_file:
	input_file.write('This is some test text')

	
22

# this code is the same in Python 2.7 and Python 3:

INPUT_FILE_NAME = “cryptopy_input.txt”
OUTPUT_FILE_NAME = “cryptopy_output.txt”

Page 208-218
All code on this page is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Python for Kids: Python 3 – Project 6

Using Python 3 in Project 6 of Python For Kids For Dummies

In this post I talk about the changes that need to be made to the code of Project 6 in order for it to work with Python 3.  Most of the code in project 6 will work without changes. However, in a lot of cases what Python outputs in Python 3 is different from the output in Python 2.7.

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3. I am working through the code in the existing book, highlighting changes from Python 2 to Python 3 and providing code that will work in Python 3. If you are using Python 2.7 you can ignore this post. This post is only for people who want to take the code in my book Python for Kids for Dummies and run it in Python 3.

Page 144:

Code and outputs are the same.

Page 145: code same, outputs different:

# Python 2.7 output

>>> dir(my_message)
['__add__', '__class__', '__contains__', '__delattr__',
'__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__le__',
'__len__', '__lt__', '__mod__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmod__', '__rmul__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '_formatter_field_name_split',
'_formatter_parser', 'capitalize', 'center', 'count',
'decode', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower',
'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower',
'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust',
'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate',
'upper', 'zfill']

# Python 3 output

>>> dir(my_message)
['__add__', '__class__', '__contains__', '__delattr__', 
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__getnewargs__', 
'__gt__', '__hash__', '__init__', '__iter__', '__le__', 
'__len__', '__lt__', '__mod__', '__mul__', '__ne__', 
'__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', 
'__str__', '__subclasshook__', 'capitalize', 'casefold', 
'center', 'count', 'encode', 'endswith', 'expandtabs', 
'find', 'format', 'format_map', 'index', 'isalnum', 
'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 
'islower', 'isnumeric', 'isprintable', 'isspace', 
'istitle', 'isupper', 'join', 'ljust', 'lower', 
'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 
'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 
'split', 'splitlines', 'startswith', 'strip', 'swapcase', 
'title', 'translate', 'upper', 'zfill']

Page 146 – code same, outputs different:

# Python 2.7 output
>>> type('a string object')
<type 'str'>
>>> type([]) # that is, an empty list
<type 'list'>

# Python 3 output
>>> type('a string object')
<class 'str'>
>>> type([]) # that is, an empty list
<class 'list'>

# output for id() for both Python 2.7 and Python 3 is an integer

>>> id('a string object')
139900104204840

Page 147 – code same, outputs different

# Python 2.7 output

>>> help(my_message.upper) # spot the dot?
Help on built-in function upper:
upper(...)
    S.upper() -> string
    Return a copy of the string S converted to uppercase.
          

# Python 3 output          
>>> help(my_message.upper) # spot the dot?
Help on built-in function upper:

upper(...)
    S.upper() -> str
    
    Return a copy of S converted to uppercase.

Page 148 – code and outputs the same

Page 149 – Code the same, outputs different.
In Python 2.7 the range builtin creates a list. In Python 3 it creates a generator. The end result in this code is the same, but the way it is achieved is different.

# Python 2.7 
>>> range(3)
[0, 1, 2]
>>> for i in range(3):
        print(i)
0
1
2


# Python 3 output   
>>> range(3)
range(0, 3)
>>> for i in range(3):
        print(i)

        
0
1
2

Page 150 – Style error in the first code block on the page. Should have been print(i), otherwise code and outputs the same:

#Python 2.7
>>> for i in dir(my_message):
          print i
__add__
__class__
__contains__
[...]
# Python 3
>>> for i in dir(my_message):
          print(i)
__add__
__class__
__contains__
[...]          

Page 150 – balance of code – code same, outputs different

# Python 2.7

>>> string_object_attributes = dir(my_message)
>>> string_object_attributes
['__add__', '__class__', '__contains__', '__delattr__',
'__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__le__',
'__len__', '__lt__', '__mod__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmod__', '__rmul__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '_formatter_field_name_split',
'_formatter_parser', 'capitalize', 'center', 'count',
'decode', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower',
'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower',
'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust',
'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',
'startswith', 'strip', 'swapcase', 'title', 'translate',
'upper', 'zfill']


>>> dir(string_object_attributes)
['__add__', '__class__', '__contains__', '__delattr__',
'__delitem__', '__delslice__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__',
'__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__setslice__', '__sizeof__', '__str__',
'__subclasshook__', 'append', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']
   
# Python 3
>>> string_object_attributes = dir(my_message)
>>> string_object_attributes
['__add__', '__class__', '__contains__', '__delattr__', 
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__getnewargs__', 
'__gt__', '__hash__', '__init__', '__iter__', '__le__', 
'__len__', '__lt__', '__mod__', '__mul__', '__ne__', 
'__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', 
'__str__', '__subclasshook__', 'capitalize', 'casefold', 
'center', 'count', 'encode', 'endswith', 'expandtabs', 
'find', 'format', 'format_map', 'index', 'isalnum', 
'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 
'islower', 'isnumeric', 'isprintable', 'isspace', 
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 
'maketrans', 'partition', 'replace', 'rfind', 'rindex', 
'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 
'splitlines', 'startswith', 'strip', 'swapcase', 'title', 
'translate', 'upper', 'zfill']


>>> dir(string_object_attributes)
['__add__', '__class__', '__contains__', '__delattr__', 
'__delitem__', '__dir__', '__doc__', '__eq__', '__format__', 
'__ge__', '__getattribute__', '__getitem__', '__gt__', 
'__hash__', '__iadd__', '__imul__', '__init__', '__iter__', 
'__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', 
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__', 
'__rmul__', '__setattr__', '__setitem__', '__sizeof__', 
'__str__', '__subclasshook__', 'append', 'clear', 'copy', 
'count', 'extend', 'index', 'insert', 'pop', 'remove', 
'reverse', 'sort']
   

Page 152-154 – code and outputs are the same

Page 155 – up to the warning box the code and outputs are the same

Page 155 Warning box:
The warning box on page 155 relies on the fact that in Python 2.7 the range() builtin returns a list. However, in Python 3 it returns a generator, so it doesn’t have a reverse method. You can get the same behavior [sic] if you force it to be a list using the list() builtin:

## Python 3 code:
>>> a_list = list(range(10))
>>> a_list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> reversed_list = a_list.reverse()
>>> # reverse doesn't return a value!
>>> print(reversed_list)
None
>>> a_list
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Page 157-161 code and outputs the same

Page 162 – Code different
Change raw_input to input as explained in the Python 3 post for Project 5.

# Python 2.7
""" 1337.py
Given a message, convert it into 1337 sp34k
Brendan Scott
January 2015 """

TEST_MESSAGE = "Hello World!"
TEST_SUBSTITUTIONS = [['e','3']]
#### Function Section
def encode_message(message, substitutions):
    for s in substitutions:
        """Take a string message and apply each of the substitutions
        provided. Substitutions should be a list, the elements of
        substitutions need to be lists of length 2 of the form
        (old_string, new_string) """
        old = s[0]
        new = s[1]
        converted = message.replace(old,new)
    return converted
    
    
#### Testing Section
message = raw_input("Type the message to be encoded here: ")
converted_text = encode_message(message, TEST_SUBSTITUTIONS)
print(message)
print(converted_text)


# Python 3
""" 1337.py
Given a message, convert it into 1337 sp34k
Brendan Scott
January 2015 """

raw_input = input # this fixes raw_input!

TEST_MESSAGE = "Hello World!"
TEST_SUBSTITUTIONS = [['e','3']]
#### Function Section
def encode_message(message, substitutions):
    for s in substitutions:
        """Take a string message and apply each of the substitutions
        provided. Substitutions should be a list, the elements of
        substitutions need to be lists of length 2 of the form
        (old_string, new_string) """
        old = s[0]
        new = s[1]
        converted = message.replace(old,new)
    return converted
    
    
#### Testing Section
message = raw_input("Type the message to be encoded here: ")
converted_text = encode_message(message, TEST_SUBSTITUTIONS)
print(message)
print(converted_text)

Page 164 – Style error – should be print(s) not print s. With print(s) the code is the same in Python 2.7 and Python 3.

#Python 2.7 code: 
>>> substitutions = [['a','4'], ['e','3'], ['l','1'], ['o','0'], 
                     ['t','7']]
>>> for s in substitutions:
          print s
          
['a',  '4']
['e',  '3']
['l',  '1']
['o',  '0']
['t',  '7']
#Python 3 code:
>>> substitutions = [['a','4'], ['e','3'], ['l','1'], ['o','0'], 
                     ['t','7']]
>>> for s in substitutions:
          print(s)

          
['a', '4']
['e', '3']
['l', '1']
['o', '0']
['t', '7']

Page 166 Code different
Use input instead of raw_input as explained in the Python 3 post for Project 5. In this case, i have added raw_input = input after the docstring.

     
#Python 3 code:
""" 1337.py
Given a message, convert it into 1337 sp34k
Brendan Scott
January 2015 """

raw_input = input # this fixes raw_input!

TEST_MESSAGE = "Hello World!"
##TEST_SUBSTITUTIONS = [['e','3']]
SUBSTITUTIONS = [['a', '4'], ['e', '3'], ['l', '1'], ['o', '0'], 
                 ['t', '7']]
                 
#### Function Section
def encode_message(message, substitutions):
    """Take a string message and apply each of the substitutions
    provided. Substitutions should be a list, the elements of
    substitutions need to be lists of length 2 of the form
    (old_string, new_string) """
    for s in substitutions:
        old = s[0]
        new = s[1]
        converted = message.replace(old,new)
    return converted
    
#### Testing Section
message = raw_input("Type the message to be encoded here: ")
converted_text = encode_message(message, SUBSTITUTIONS)
print(message)
print(converted_text)

Page 168-169 Code different
Use input instead of raw_input as explained in the Python 3 post for Project 5. In this case, i have added raw_input = input after the docstring.


#Python 3 code:
""" 1337.py
Given a message, convert it into 1337 sp34k
Brendan Scott
January 2015 """

raw_input = input # this fixes raw_input!

TEST_MESSAGE = "Hello World!"
##TEST_SUBSTITUTIONS = [['e','3']]
SUBSTITUTIONS = [['a', '4'], ['e', '3'], ['l', '1'], ['o', '0'],
                 ['t', '7']]
                
#### Function Section
def encode_message(message, substitutions):
    """Take a string message and apply each of the substitutions
    provided. Substitutions should be a list, the elements of
    substitutions need to be lists of length 2 of the form
    (old_string, new_string) """
    for s in substitutions:
        old = s[0]
        new = s[1]
        converted = message.replace(old,new)
        print("converted text = "+converted) # Added
    print("Leaving encode_message") # Added
    
    return converted

#### Testing Section
message = raw_input("Type the message to be encoded here: ")
converted_text = encode_message(message, SUBSTITUTIONS)
print("started with "+message) # Changed
print("Converted to "+converted_text) # Changed

Page 170 Code different
Use input instead of raw_input as explained in the Python 3 post for Project 5. In this case, i have added raw_input = input after the docstring.


#Python 3 code:
""" 1337.py
Given a message, convert it into 1337 sp34k
Brendan Scott
January 2015 """

raw_input = input # this fixes raw_input!

TEST_MESSAGE = "Hello World!"
##TEST_SUBSTITUTIONS = [['e','3']]
SUBSTITUTIONS = [['a','4'], ['e','3'], ['l','1'], ['o','0'],
                 ['t','7']]
              
#### Function Section
def encode_message(message, substitutions):
    """Take a string message and apply each of the substitutions provided.
    Substitutions should be a list, the elements of substitutions need to
    be lists of length 2 of the form (old_string, new_string) """
    
    for s in substitutions:
        old = s[0]
        new = s[1]
        message = message.replace(old,new) # Changed
        print("converted text = "+message)
    print("Leaving encode_message") # Changed
    return message # Changed
    
#### Testing Section
message = raw_input("Type the message to be encoded here: ")
converted_text = encode_message(message, SUBSTITUTIONS)
print("started with "+message)
print("Converted to "+converted_text)


Python for Kids: Python 3 – Project 5

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3. I am working through the code in the existing book, highlighting changes from Python 2 to Python 3 and providing code that will work in Python 3.

If you are using Python 2.7 you can ignore this post. This post is only for people who want to take the code in my book Python for Kids for Dummies and run it in Python 3.

 

Using Python3 in Project 5 of Python For Kids For Dummies

Project 5 introduces the concept of using functions for performing repetitive work when you’re programming.  All of the keywords introduced in this Project are the same and have the same syntax in Python 3, so you really shouldn’t have any trouble with this code – except for the fact that some of the code has raw_input in it and that caused problems in earlier chapters.  As I mentioned in my earlier post you can either:

  • replace every reference to raw_input by plain old input; or
  • at the top of your file add the line raw_input = input.

If you’re cutting and pasting  from the code on the website this is probably the easiest thing to do.

Basically, everything in this project will work if you use one of the two strategies above. However, some of the code will give a different output when run under Python3 compared to Python2.7. There is also one place where the code in the book is redundant.  This is the use of the float() builtin – Python3 automatically calculates its results using decimals.

Page 105 – 110:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 111-112

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working.

#Python 2.7 code:
import random

computers_number = random.randint(1,100)
prompt = 'What is your guess? '

while True:
    players_guess = raw_input(prompt)
    if computers_number == int(players_guess):
        print('Correct!')
        break
    elif computers_number > int(players_guess):
        print('Too low')
    else:
        print('Too high')

#Python 3 code:
import random
raw_input = input # this fixes raw_input!

computers_number = random.randint(1,100)
prompt = 'What is your guess? '

while True:
    players_guess = raw_input(prompt)
    if computers_number == int(players_guess):
        print('Correct!')
        break
    elif computers_number > int(players_guess):
        print('Too low')
    else:
        print('Too high')

Page 113

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working.

#Python 2.7 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""

import random

computers_number = random.randint(1,100)
PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    while True:
        players_guess = raw_input(PROMPT)
        if computers_number == int(players_guess):
            print('Correct!')
            break
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

do_guess_round()
#Python 3 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""

import random
raw_input = input # this fixes raw_input!

computers_number = random.randint(1,100)
PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    while True:
        players_guess = raw_input(PROMPT)
        if computers_number == int(players_guess):
            print('Correct!')
            break
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

do_guess_round()

Pages 114 – 116:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 117

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working.

#Python 2.7 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""

import random

computers_number = random.randint(1,100)
PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    computers_number = random.randint(1,100) # Added
    while True:
        players_guess = raw_input(PROMPT)
        if computers_number == int(players_guess):
            print('Correct!')
            break
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

while True:
    # Print statements added:
    print("Starting a new Round!")
    print("The computer's number should be "+str(computers_number))
    print("Let the guessing begin!!!")
    do_guess_round()
    print("") # blank line

#Python 3 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""

import random
raw_input = input # this fixes raw_input!

computers_number = random.randint(1,100)
PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    computers_number = random.randint(1,100) # Added
    while True:
        players_guess = raw_input(PROMPT)
        if computers_number == int(players_guess):
            print('Correct!')
            break
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

while True:
    # Print statements added:
    print("Starting a new Round!")
    print("The computer's number should be "+str(computers_number))
    print("Let the guessing begin!!!")
    do_guess_round()
    print("") # blank line

Pages 118 – 129:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Pages 130-131:

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working.

#Python 2.7 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""
import random

PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    computers_number = random.randint(1, 100)
    number_of_guesses = 0 # Added

    while True:
        players_guess = raw_input(PROMPT)
        number_of_guesses = number_of_guesses+1 # Added
        if computers_number == int(players_guess):
            print('Correct!')
            return number_of_guesses # Changed
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

total_rounds = 0 # Added
total_guesses = 0 # Added

while True:
    total_rounds = total_rounds+1 # Added
    print("Starting round number: "+str(total_rounds)) # Changed
    print("Let the guessing begin!!!")
    this_round = do_guess_round() # Changed
    total_guesses = total_guesses+this_round # Added
    print("You took "+str(this_round)+" guesses") # Added
    avg = str(total_guesses/float(total_rounds)) # Added
    print("Your guessing average = "+avg) # Added
    print("") # blank line
#Python 3 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""
import random
raw_input = input # this fixes raw_input!

PROMPT = 'What is your guess? '

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    computers_number = random.randint(1, 100)
    number_of_guesses = 0 # Added

    while True:
        players_guess = raw_input(PROMPT)
        number_of_guesses = number_of_guesses+1 # Added
        if computers_number == int(players_guess):
            print('Correct!')
            return number_of_guesses # Changed
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

total_rounds = 0 # Added
total_guesses = 0 # Added

while True:
    total_rounds = total_rounds+1 # Added
    print("Starting round number: "+str(total_rounds)) # Changed
    print("Let the guessing begin!!!")
    this_round = do_guess_round() # Changed
    total_guesses = total_guesses+this_round # Added
    print("You took "+str(this_round)+" guesses") # Added
    avg = str(total_guesses/float(total_rounds)) # Added
    print("Your guessing average = "+avg) # Added
    print("") # blank line

Page 132:

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working. The code here is only a single side function. If you have the raw_input = input line earlier in the file you don’t need to add it again. I’m showing it here just for completeness.

#Python 2.7 code:
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '

def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes
    Return True (yes, quit) or False (no, don't quit) """
    spam = raw_input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True

#Python 3 code:
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '

def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes
    Return True (yes, quit) or False (no, don't quit) """
    spam = input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True        

Pages 133-134:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7

Page 135:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7. However:

  • see the errata on Project 5. The line avg = str(total_guesses/float(total_rounds)) needs to be moved; and
  • the use of float() is unnecessary. We did this because Python 2.7 thinks if you divide a whole number by a whole number you want a whole number as an answer. If you want a decimal you need to use float().  Python3 calculates using decimals by default so float() is unnecessary.

Here is the corrected code (works in both Python 2.7 and Python 3):


    # new if condition (and code block) to test against quit
    if this_round == QUIT:
        total_rounds = total_rounds - 1
        # removed line from here
        if total_rounds == 0:
            stats_message = 'You completed no rounds. '+\
                              'Please try again later.'
        else:
            avg = str(total_guesses/float(total_rounds)) # to here
            stats_message = 'You played ' + str(total_rounds) +\
                              ' rounds, with an average of '+\
                              str(avg)
        break

Page 136:

All code on these pages is the same, and all outputs from the code is the same in Python 3 as in Python 2.7.

Page 137:

This code has raw_input. Add a line raw_input = input # this fixes raw_input! at the top of the file to get it working. You also need to incorporate the fixes mentioned in relation to the code on page 135.

Here is the corrected code in Python 3:

#Working Python 3 code:
"""guess_game_fun
Guess Game with a Function
In this project the guess game is recast using a function"""

import random
raw_input = input # this fixes raw_input!
PROMPT = 'What is your guess? '

# New constants
QUIT = -1
QUIT_TEXT = 'q'
QUIT_MESSAGE = 'Thank you for playing'
CONFIRM_QUIT_MESSAGE = 'Are you sure you want to quit (Y/n)? '

# New confirm_quit function
def confirm_quit():
    """Ask user to confirm that they want to quit
    default to yes
    Return True (yes, quit) or False (no, don't quit) """
    spam = raw_input(CONFIRM_QUIT_MESSAGE)
    if spam == 'n':
        return False
    else:
        return True

def do_guess_round():
    """Choose a random number, ask the user for a guess
    check whether the guess is true
    and repeat until the user is correct"""
    computers_number = random.randint(1, 100)
    number_of_guesses = 0

    while True:
        players_guess = raw_input(PROMPT)
        # new if clause to test against quit
        if players_guess == QUIT_TEXT:
            if confirm_quit():
                  return QUIT
            else:
                  continue # that is, do next round of loop
        number_of_guesses = number_of_guesses+1
        if computers_number == int(players_guess):
            print('Correct!')
            return number_of_guesses
        elif computers_number > int(players_guess):
            print('Too low')
        else:
            print('Too high')

total_rounds = 0
total_guesses = 0

while True:
    total_rounds = total_rounds+1
    print("Starting round number: "+str(total_rounds))
    print("Let the guessing begin!!!")
    this_round = do_guess_round()

    # new if condition (and code block) to test against quit
    if this_round == QUIT:
        total_rounds = total_rounds - 1
        if total_rounds == 0:
            stats_message = 'You completed no rounds. '+\
                              'Please try again later.'
        else:
            avg = str(total_guesses/float(total_rounds))
            stats_message = 'You played ' + str(total_rounds) +\
                              ' rounds, with an average of '+\
                              str(avg)
        break
    total_guesses = total_guesses+this_round
    avg = str(total_guesses/float(total_rounds))
    print("You took "+str(this_round)+" guesses")
    print("Your guessing average = "+str(avg))
    print("")
# Added exit messages
print(stats_message)

Python for Kids: Python 3 – Project 4

Disclaimer

Some people want to use my book Python for Kids for Dummies to learn Python 3. I am working through the code in the existing book, highlighting changes from Python 2 to Python 3 and providing code that will work in Python 3.

If you are using Python 2.7 you can ignore this post. This post is only for people who want to take the code in my book Python for Kids for Dummies and run it in Python 3.

Using Python3 in Project 4 of Python For Kids For Dummies

Project 4 introduces the IDLE integrated development environment. When you download and install a version of Python 3 for Windows (I tested version 3.4.4)  you should get a folder called Python 3.4 (or whatever version you installed) in your Start Menu.  In that folder should be an entry called IDLE (Python 3.4 GUI – 32 bit).  If you run that you will be launched into the Python 3.4 equivalent of the IDLE mentioned in the book.

The good news is that pretty much everything in this project is the same for Python 3. That’s partly because the project is mainly concerned with introducing the IDLE environment and the concept of storing code in a file.  IDLE in Python 3 has all of the features listed in Project 4 as for Python 2.7:

Syntax highlighting (page 87)

Tab Completion (page 88/89)

Command history (page 90/91)

The IDLE Editor Window (page 92-95)

Comments (page 95-98)

Saving files (page 98)

Commenting out code (page 98-100) (the same commenting format -> # or triple quotes for docstrings “”” are the same in Python 3)

Indenting and dedenting code (page 101-102)

You should be able to breeze through Project 4 using Python 3.