Python for Everyone

Py

thon

for Everyone

An Introduction to Computer Science for Elementary Teachers and Students

Version 1.1.9

Py

thon

for Everyone

An Introduction to Computer Science for Elementary Teachers and Students

Version 1.1.9

Scott Durkin

Fort Collins, Colorado http://poudre.us/cs

Copyright © 2011, 2014 Scott Durkin

Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free

Documentation License, Version 1.1, or an later version published by the Free Software Foundation.

The GNU Free Documentation License is available from http://www.gnu.org

Preface

As a short "curriculum module" regarding an introduction to computer programming for children who are around eleven or twelve years old (and for teachers who may have never programmed before), this document has been fashioned to provide the reader (teacher and perhaps some motivated students of various ages) an elementary introduction to the topic of computer science.

For the instructor who has programmed before and is not yet familiar with the

Python language

, she or he will find it easy to glean an appropriately-paced series of lesson plans from this document either by following the outline provided, or devising one's own. Regardless of your experience with programming as a teacher, it is hoped that you will find this and/or other beginning tutorials/textbooks on this subject helpful in tailoring lessons for your situation.

This resource contains text, graphics, videos, code, documentation, and links to other resources, but it may not be worthwhile unless the learner, student and teacher alike, becomes physically and mentally involved by entering code and writing scripts in Python; and in the process, actively thinking about computer science and beginning on the path of becoming a programmer.

Learning how to program may significantly enhance a person's ability to read, think and solve problems in many areas of life and study. Many of the programs shown here support concepts related to grade-level mathematics standards.

This approach is driven by the current K-12 models for computer science instruction from

CSTA

of

ACM

and other entities, along with such landmark works as

Being Fluent in Information

Technology

from the

National Academy of Sciences

.

Of course, Python could be used with younger students, and as mentioned, multiple K-12 computer science curriculum models exist at many organizational levels in this and other nations.

For instance, a kindergarten teacher in the spring could encourage an able student to open Python and type,

print "Marissa " * 50

, for example, to witness her name instantly appear fifty times on the computer monitor as a stated or unstated example of repeated addition or multiplication. What could be the educational ramifications if as a matter of simple practice and no-cost benefit every student in this or any school district knew how to program in one or more professional open source and/or proprietary computer languages at a measurable level commensurate to or beyond many of the concepts associated with her or his grade-level mathematics standards?

Scott Durkin

Contents

PYTHON PROGRAMMING.................................................................................................................... 1

TEACHING OUTLINE ............................................................................................................................. 2

GETTING STARTED ............................................................................................................................... 3

Installing Python 2.2.3......................................................................................................................... 3

Something to Keep in Mind ................................................................................................................ 3

Python IDLE and the Hello, World! Test ........................................................................................ 4

The Hello, World! Program ................................................................................................................ 4

Keywords and Color-coded Text ...................................................................................................... 6

Documentation/Adding Comments ................................................................................................ 6

Errors ........................................................................................................................................................ 7

Opening Existing Scripts in Python ................................................................................................. 7

Python Help ............................................................................................................................................. 8

Glossary ................................................................................................................................................................ 8

THE BASICS .............................................................................................................................................. 9

Data Types and Variables ................................................................................................................... 9

Built-in Functions .................................................................................................................................. 9

Variables and Data Types – An Overview ................................................................................... 10

Using the IDLE Shell to Learn About Variables and Data Types ......................................... 11

How Python Handles Basic Math ................................................................................................... 12

Computer Science and 6 th Grade Mathematics Standards .................................................... 13

Glossary ............................................................................................................................................................. 14

SIMPLE APPLICATIONS ...................................................................................................................... 15

The Halt! Who Goes There? Program (halt.py) ........................................................................ 15

The raw_input Function .............................................................................................................................. 15

Type Coercion ................................................................................................................................................. 15

Conditional Statements and Indentation (White-space) ............................................................... 16

Code for the halt.py Program .................................................................................................................... 17

Glossary ............................................................................................................................................................. 19

Area and Perimeter Program (rectangle.py) ............................................................................ 21

The High/Low Guessing Game (guess.py) .................................................................................. 22

The while Loop ............................................................................................................................................... 22

Creating the High/Low Guessing Game ................................................................................................ 23

Developing the Initial Program ................................................................................................................ 23

The Initial Script ............................................................................................................................................ 24

Generating a Random Number ................................................................................................................ 25

Adding a Counter ........................................................................................................................................... 26

Adding Feedback ........................................................................................................................................... 27

Putting the Game in a Loop ....................................................................................................................... 28

How Fair is the Random Number Generator? ........................................................................... 29

The for Loop .................................................................................................................................................... 29

Computer Simulation ................................................................................................................................... 30

Glossary ............................................................................................................................................................. 32

The Least Common Multiple (LCM) Finder (lcm.py) ............................................................... 33

The input Function ....................................................................................................................................... 33

The Factors Finder Program (factorsFinder.py) ...................................................................... 35

The Change Maker (changeMaker1.py/changeMaker2.py)................................................. 36

Creating changeMaker1.py ........................................................................................................................ 37

Creating changeMaker2.py ........................................................................................................................ 38

The Greatest Common Denominator (GCD) Finder (gcd.py) ............................................... 39

Lists ..................................................................................................................................................................... 39

Creating and Using Your Own Functions ............................................................................................. 41

Creating the Program .................................................................................................................................. 43

Glossary ............................................................................................................................................................. 45

Other Simple Applications ............................................................................................................... 46

Careers in Computing ........................................................................................................................ 47

Python Programming

As most are already aware, a computer basically does four things with information: input, output, storage and processing. In the early 1800s, the term "computer" referred to a human being who did calculations for a living.

Later, this same term applied to the machinery that could do the same four things with information. Due in part to the pioneering work in computer software development by Ada Lovelace , Rear Admiral Grace Hopper and many others, computer programming languages have evolved along with computing machinery.

The ever-increasing ubiquitous nature of computing that has erupted over just the past few decades may be viewed by some as its own argument of the need for all citizens to possess a basic understanding of what a computer is and how it does what is does, even if only at the most fundamental levels. Learning how to program a computer may also improve some students' level of understanding of certain concepts associated with mathematics. Common sense may dictate that if a fourth-grader learns how to create a computer program that is able to identify all the factors of any positive integer, then she or he may enhance his or her understanding of the related grade level mathematical standards. Even though such program written in Python could be as short as four or five lines of code, from my own experience as an educator I have witnessed that for many students the process of composing and understanding what this code means enhances understanding.

Python 2 dividend = input ( "Enter any positive integer to view all the factors of that number: " ) for divisor in range(1,dividend+1): if dividend % divisor == 0: print divisor

Python 3 dividend = int( input ( "Enter any positive integer to view all the factors of that number: " )) for divisor in range(1,dividend+1): if dividend % divisor == 0:

print divisor

You may not currently understand all the code above designed to identify all the factors of any positive integer, but may soon see that Python is an easy language to learn as you go along.

Python is an open source language invented in the early 1990s by Guido van Rossum . It is currently used by hundreds of thousands of programmers around the world and the number of users tends to double every year.

Though this powerful object-oriented language is used by those at MIT, NASA, The Louis Pasteur Institute, Google,

Facebook and many other organizations and universities, it is also an effective introductory language to computer science for most anyone ten years older and up.

"As a first programming language, Python provides a lucid, interactive environment in which to explore procedural, functional and object oriented approaches to problem solving. Its high level data structures and clear syntax keep the forest in view through the trees." - Python in Education

This document is designed for any user new to programming, a teacher or able student in fourth grade or above. The version of Python used is 2.2; however, it could easily be adjusted to work with 3.x.

Computer Science for Everyone – A Handout for Elementary Students and Teachers http://poudre.us/cs April 13, 2020

1

Teaching Outline

As with anything like this to impart, the timing and pace of this "curriculum module" may vary from instructor to instructor, as progress may be a function of the students involved, the experience and comfort level the instructor has with the material, and other issues.

This document was designed mostly for teachers new to teaching programming. Obviously, an initial step for such a teacher is to learn how to program, and this document should help guide an instructor through that process. Later, it is then simply a matter of the instructor mapping out what she or he would like to accomplish each session with students. The content of this document is presented in several voices. Sometimes the content is directed to the instructor and other times it is directed to the student/learner.

Below is one general outline of a possible five-session sequence of the initial portion of the content provided in this document. The *.py programs below are detailed in this document.

Session 1 – IDLE, Hello, World Test, Variables and Data Types, Math

Session 2 – Hello, World Program, halt.py, rectangle.py

Session3 – guess.py

Session 4 – lcm.py, factorsFinder.py

Session 5 – changeMaker.py


2

Getting Started

The Python programming language software is free. It may be downloaded at http://python.org

. Many platforms and versions are available. This document uses a Microsoft Windows operating system for examples, but Python works with Macintosh and Linux systems as well. For the purpose of student learning, Windows version 2.2.3

is reliable and adequate. Teachers should see her or his Building Technology Coordinator for installation of Python on school computers, but, if willing, the instructor should also install Python on one or more home computers to get started.

Windows versions 2.3 to 2.6 may be used on the teacher workstation as the font size may be adjusted larger for projection; but there is a stability issue associated with the use of these versions, which is addressed in the next paragraph. Versions 3.x of Python have also been available since 2008, and it is not uncommon to have multiple versions of Python installed on a computer. Python is best installed by hand on each computer rather than being pushed out with network software, especially if multiple versions are to be installed. There are subtle yet significant changes in syntax and other aspects between versions 2 and 3 ( http://podure.us/balto14/diff.html

). Due to fact that Python 3.x is newer and does not yet have a vast amount of resources developed for it (compared to 2.x), this document will address the use of Python 2.2.3 within the Microsoft operating system. However, the programs in this document could be easily adjusted to work in Python 3.

A known issue with Python (2.3 and up) IDLE is a "subprocess error." This issue can be easily addressed in at least two ways. One way is to simply create a shortcut to IDLE on the desktop (all users) that directs to the path of the

IDLE program, but runs it without subprocess. Right-click on desktop, select New, then Shortcut. For example, if you installed Python 2.6, you would need to have the shortcut location set to: C:\Python26\Lib\idlelib\idle.pyw -n

The "< SPACE >-n" makes it run with subprocess. This works for any version of Python 2.3 and above. Another way is to alter a line in PyShell.py by going to the main function (def main) towards the bottom and changing the use_subprocess variable to "False."

Although 2.2.3 is used in this document, an effort has been made to introduce programming concepts in light of how things are done in Python 3.x, as that is the future of this language. Later, an experienced user of 2.2.3 will have no trouble migrating to 3.x. It is not uncommon to have multiple versions of Python installed on a single computer as many useful external libraries are written for specific versions of Python.

Installing Python 2.2.3

Anyone reading this document should also take the small amount of time to have Python 2.2.3 installed on her or his home computer(s). If nothing else, Python is a great and handy calculator. Python may be downloaded at http://python.org. Python is completely free and no registration or other requirement is needed. Simply accept all the defaults when installing and it will be inside All Programs/Applications | Python 2.2. Handout - http://poudre.us/balto14/installPython2.pdf

Something to Keep in Mind

If one would like to learn how to program, it is highly advised that as one progresses through this document to physically perform the examples using Python on a computer. It may also be helpful to print, in color , all or portions of this document.


3

Python IDLE and the Hello, World! Test

Many programming languages have what is known as an integrated development environment (IDE) , a user interface which allows a programmer to create programs. The IDE that comes with Python is called IDLE

(Integrated DeveLopment Environment) http://en.wikipedia.org/wiki/IDLE_(Python) . This name reflects how

Python may be used as an effective teaching language, and also plays on the last name of one of the performers in the Monty Python group, Eric Idle.

The Python IDLE includes an interactive mode – meaning it can provide immediate feedback to input, and may serve as a helpful way to learn about some programming concepts prior to applying them in programs. Though this document references use of the IDLE included in the Python installation, there are also commercial IDE's available for Python, such as WingIDE .

It is a good idea to read this document on or in front of a computer so you can try out the examples as you go.

To get to the Python IDLE, go to the Start menu and select Programs | Python 2.2 | IDLE (Python GUI). GUI stands for graphical user interface . Once IDLE opens, the user should see the interactive Python shell prompt , three greater than symbols >>>, or chevron.

Python shell prompt

In the IDLE, the user may conduct the "Hello, World!" test. The "Hello, World!" test is typically the first thing a programmer does in a new language to learn how difficult or easy it is to get the text, "Hello, World!" to display on the screen.

At the >>> prompt, type: print "Hello, World!" and press the Enter key. Here, the word "print" actually means display information to the screen.

>>> print "Hello, World!"

Hello, World!

>>>

As you can see, The Hello, World! Test doesn't get much easier than with Python.

For the sake of comparison, here is the same program in Java : class Hello {

public static void main (String[] args) {

System.out.println ("Hello, world.");

}

}

Here it is in C++ :

#include <iostream.h> void main ()

{

cout << "Hello, world." << endl;

return 0

}

The Hello, World! Program


4

When commands are entered in the Python shell the results are immediately displayed to the user, which again is advantageous when testing something out. Alternatively, a disadvantage is that the code is not preserved for future use. Most programmers usually like to save an actual program to a file, sometimes referred to as a script .

To save the "Hello, World!" test into a script, first highlight and copy the single line of code from the shell: print

"Hello, World!" . That way, you do not have to type it in again as you already know this code works.

From within the shell window, go to File – New Window . This will open a blank window in Python. This is a text editor window – not much unlike Notepad, for example. However, once you save it with a proper name (described in the next paragraphs), Python will display helpful information as you enter code along with color-coding text based on context.

Go to File – Save As and save the file into your school folder for this class with the name hello.py

. All Python program files should always end in .py.

Some general file name conventions include: use mostly lower case letters, do not begin a file name with a numeral, do not use spaces and it must end in .py. If at any time color-coding is not present in an IDLE script file, then it probably has an invalid file name.

Valid file names: halt.py guessingGame.py factors.py helloWorld.py

Invalid file names: hello world.py (contains a space)

2variables.py (starts with a numeral)

hello (doesn't end in .py)

hello.txt (same as above)

Paste the code content into the file.


5

Keywords and Color-coded Text

The word "print" is a keyword in Python. Keywords are words already reserved by a computer language for special purposes. Below is a list of reserved words , or keywords, in Python. Keywords may vary slightly among the various versions of Python that are available. There is no need to be overly concerned about all the items on this list at this time. It is just provided here so you know that such words exist and what they are. This list is also available at the >>> prompt in IDLE by entering: help()

and then keywords

. and as assert break def del elif else finally for in is class except if continue exec import or pass print raise from lambda return global not try while with yield

Formally, the command you typed in the Hello, World Test is known as a print statement. The keyword "print" is used to display text to the computer monitor/screen. In order for the text to appear, it must be encased in quotation marks (or apostrophes , just be consistent). As you may have noticed, such text is colored green. Python IDLE uses color-coded text to help the programmer read code. For instance in Python 2.2, the keyword "print" is colored orange and strings are colored green. Colors and when they are used may vary slightly among Python versions, but are adjustable within the application.

Documentation/Adding Comments

Take a few moments to document this and any program you write. This is done by adding comments in English to your computer program. When scripts are run by Python, anything on any line that appears after a hash '#' character is ignored by the interpreter. Below is the same file documented. Comments appear in red text.

Once the code and documentation are entered, save the changes to the file. Run the file by pressing the F5 key .

Upon running, the shell window should display and the output of the program should appear in the shell.

If the program ran successfully, simply close the shell window.


6

Errors

To error is human, to parse 1 2 divine. Parsing is going through your code line-by-line and part by part, to find problems. As an example, Python is case sensitive – meaning "Print" is not the same as "print".

Say a user entered this for the Hello, World! Test: Print "Hello, World!"

The shell would yield this:

IDLE 0.8 -- press F1 for help

>>> Print "Hello, World!

"

SyntaxError: invalid syntax

>>>

In a script file, the IDLE shell would return:

Traceback (most recent call last):

File "<string>", line 1, in ?

File "C:\Python22\howdy.py", line 1

Print "Hello, World!"

^

SyntaxError: invalid syntax

In either case, Python attempts to share with the programmer feedback regarding the error. In neither case however, does Python provide one with exactly what the problem is other than to highlight or point to the line that has the problem (great, there is just one line in the program!) and to report that there is a SyntaxError .

A beginner to programming may not readily notice her or his own errors – hence, the errors occurring in the first place. Also, as you can see, the built-in Python debugger can be less than completely helpful. Students! Parsing is a great group activity . Please help each other and encourage everyone to seek assistance in the classroom as you and others encounter errors! Helping others by sharing information, explaining problems and providing possible solutions with one other is a tremendously effective way to increase one's own understanding of computer science.

Over time this allows everyone in the room to progress at a faster rate as the teacher isn't the only one who can help students in the room. Under such conditions, more teaching and learning tends to occur during any given amount of time as academic engaged time is increased due to the timely cooperation which may occur simultaneously throughout the computer laboratory setting. Taken to the extreme, say if a teacher was challenged to get an entire roomful of non-programming elementary students ( each and every student) to understand and perform the Hello,

World test and program in only four minutes, she or he would be clever to ask for another roomful-worth of elementary programming students to help each non-programmer on a one-to-one basis as the instructor directs the class during initial and other pivotal portions of the four minutes.

Tip for teachers : whenever you explore a new feature, consider experimenting with common mistakes you think some students may make. For example, in the "Hello, World!" program, what happens if you leave out one of the quotation marks, or both? What if you misspell the word "print" or capitalize it? This approach may increase your understanding of code and debugging ability when with students, as over time you become more familiar with error messages and what they mean.

Opening Existing Scripts in Python

To open an existing Python script, it is best to launch Python IDLE and then use File – Open inside IDLE to navigate to the file you want to open. If one simply double-clicks on a Python script icon, it will likely attempt to run in a DOS command window and not display the content of the script itself.


7

Python Help

Python has a built-in help section accessible from the IDLE >>> prompt by typing: help()

Glossary bug: An error in the program. debugging: The process of finding and removing any of the three kinds of programming errors.

comment: Information in a program that is meant for other programmers (or anyone reading the source code) and has no effect on the execution of the program. (Same as documentation .) documentation: Information in a program that is meant for other programmers (or anyone reading the source code) and has no effect on the execution of the program. (Same as comment .) exception: An error that is detected while the program is running.

graphical user interface (GUI): A user interface based on graphics instead of text; uses a mouse as well as a keyboard as an input device. hash character: The "#" character, which is used to begin any line of comment/documentation. integrated development environment (IDE): A user interface which allows a programmer to create programs. integrated development learning environment (IDLE): The user interface that comes with Python which allows a programmer to create programs. interactive mode: A way of using the Python interpreter by typing commands and expressions at the prompt. interpret: To execute a program in a high-level computer language, such as Python, by translating it one line at a time. keyword: A reserved word that is used by the compiler to parse a program; you cannot use keywords like if, def, and while as variable names. parse: To examine a program and analyze the syntax and structure, often to identify possible errors. print statement: An instruction that causes the Python interpreter to display a value on the screen. program: A set of instructions that specifies a computation. prompt: Characters displayed by the interpreter to indicate that it is ready to take input from the user. The Python shell prompt is three greater than symbols >>>, or chevron. script: A program stored in a file. script mode: A way of using the Python interpreter to read and execute statements in a script. statement: A section of code that represents a command or action.

syntax: The structure of a program.


8

The Basics

This brief section describes three common data types: string, integer, and float. Also included is information regarding variables, assignment statement, assignment operator (=), and built-in functions. In addition to the text in these sections, be sure to read and understand the code and comments in the IDLE examples.

Data Types and Variables

Computers reference information such as a person's name, e-mail address and age in terms of variables . Variables are unique single characters or group of characters (often a word) identified by the programmer to store and refer to such possibly changing values. The value assigned to a variable needs to be associated with a particular data type , which is based on what kind of information is being stored and how it may be used in the future.

String data type is often used for normal text, such as a person's name, e-mail address, or city of residence. Integer data type is used for whole numbers. Float data type is used for decimal numbers. There are other data types in

Python, but just these three can get a novice programmer started.

Three common data types in Python

Data type Use

String <str>

Integer <int>

Text

Whole numbers

Float <float> Decimal numbers

Variables hold values . For instance, say the word "price" is to be used as a variable to hold the value 19.99. To make this happen, one uses an assignment statement , which assigns a certain value to a variable. Below is an example of an assignment statement in the Python shell.

>>> price = 19.99

The " = " symbol in the line above is known as an assignment operator . It can be said that the variable "price" is assigned the value of 19.99. (Since the symbol "=" is reserved as the assignment operator, similar to some other languages, Python uses "==" to represent equality .)

In a following section, the IDLE shell is employed to show how characters may be specified as variables to store values by using assignment statements. Also see the flyer, Variables and Data Types , which appears after the next section.

Built-in Functions

In programming, a function is a named sequence of statements that performs a computation and returns a result, often referred to as a return value . Python has many built-in functions , ones that are available whenever Python is run. You have already used a built-in function in Python, the print function. The print function is designed to receive content to be displayed to the screen. This content, such as the string "Hello, World!", follows the function name. In functions, what follows the function name is referred to as the argument . Stated another way, it is said that the string "Hello, World" is the argument passed to the function print .

Unlike the print function, other Python function calls (anytime a function is used in program) tend to follow the format below, one where the function name is followed by the argument encased in parentheses.*

Typical format of a function call functionName( argument )

As you will see in the next section, the built-in type function may be used to learn of three basic kinds of data types : string , integer and float . The argument passed to the type function is an object , such as a variable. Later, you will learn how to import other functions and even create your own.

* In Python 3.x, the print function also uses parentheses to encase the argument: print ( "Hello, World!" ) .


9

A

variable

is a single letter (a character) or groups of characters (such as a word) specified by the programmer. This is a way to easily refer to a certain piece of information. For instance, it is easier and more meaningful for a programmer to refer to the cost of something with the variable the ever-changing actual value of 19.99, 22.99, 23.99, etc.

price

Variables

hold

values.

The

variable price

could be used to hold the

value 19.99

. Another variable could be

name

used to hold the value of the string of alphabetical characters that make up a person’s first name, such as "Biff". Values vary by

Python are: string, integer and float.

The information that needs to be stored

A person’s name

A person’s age

The price of something

Variables and Data Types – An Overview data type

The variable name specified name age price

.

Three common data types in

The value assigned to the variable

"Bob"

10

19.99

The data type of that value

rather than

String (text)

Integer (whole numbers)

Float (decimal numbers)


10

Using the IDLE Shell to Learn About Variables and Data Types

If one would like to learn how to program, it is highly advised to print this document (if possible, in color) or have it open side-by-side the Python IDLE and actually perform the examples in Python on a computer as one progresses through this document. It makes a significant difference in understanding, and is what is asked of the student in the computer laboratory.

Type the following in the IDLE to see how variables may be created, referenced and have its data type identified.

IDLE 1.1.1

>>> name = "Biff"

>>> print name

Biff

>>> type (name)

<type 'str'>

>>> age = 11

>>> type (age)

<type 'int'>

>>> price = 19.99

>>> type (price)

<type 'float'>

Here is the same information with comments.

IDLE 1.1.1

>>> name = "Biff" # 'name' is a VARIABLE created by the programmer.

# The '=' symbol is an ASSIGNMENT OPERATOR .

# It is said, the VARIABLE "name" is ASSIGNED the VALUE of "Biff".

# This single line of code may be referred to as an ASSIGNMENT STATEMENT.

>>> print name # Here the variable is referenced, and the VALUE is RETURNED.

Biff

>>> type (name) # This is a FUNCTION CALL.

# 'type' is a built-in FUNCTION, the ARGUMENT passed to it is an OBJECT .

# In this case, the object is the variable name.

<type 'str'> # The type function returns the data type of the variable--in this case, STRING.

>>> age = 11 # The variable 'age' is assigned the value of 11.

>>> type (age)

<type 'int'> # The data type INTEGER is returned, which is for whole numbers.

>>> price = 19.99

>>> type (price)

<type 'float'> # The data type FLOAT is for decimal numbers.


11

How Python Handles Basic Math

Math operators in Python include the symbols below.

+ Addition * Multiplication

- Subtraction / Division (integer or float)

** Exponentiation % Modulo division (remainder)

Again use the IDLE to see examples of mathematics in Python. Particular attention should be paid to how Python handles different types of division problems.

>>> 2 + 2

4

>>> 3-9

-6

>>> 5 * 2

10

>>> 15 / 2

7

>>> 15.0 / 2

7.5

>>> 15 % 2

1

>>> 14 % 2

0

>>> 17 % 5

2

>>> 5**2

25

>>> 2**3

8

Integer, remainder/modulo (or modulus) and regular division in Python 2.x

Integer division: 15 / 2 returns 7

Remainder division: 15 % 2 returns 1

Float division: 15.0 / 2 returns 7.5

quotient divisor dividend remainder

Here is that same code with clarifying comments.

>>> 2 + 2

4

# Enter this math problem and it will return the answer.

>>> 3-9 # Spaces are optional.

-6

>>> 5 * 2

10

>>> 15 / 2

7

# The multiplication symbol is the asterisk.

# When both the DIVIDEND and DIVISOR are INTEGERS

# then what is returned the WHOLE NUMBER QUOTIENT

# WITHOUT the REMAINDER.

>>> 15.0 / 2 # If the dividend is of float data type, then

7.5

# the answer returned is the exact float answer.

# Note: simply adding the '.0' to the '15' makes it a float.

>>> 15 % 2 # To find the REMAINDER of an integer division problem,

1

0

>>> 14 % 2

# use the MODULO (%) OPERATOR.

>>> 17 % 5

2

>>> 5**2

25

>>> 2**3

8

# The representation for EXPONENTIATION is two asterisks.

Comparison operators in Python include the symbols below.

== Equal to != Not equal to

> Greater than < Less than

>= Greater than or equal to <= Less than or equal to

Python will respond to comparison statements by returning the integer 1 (one) as true and 0 (zero) as false.

>>> 15 == 3 * 5

1

>>> 15 == 3 * 4

0


12

Please view the video below for more information regarding Python IDLE, basic mathematics, and simple data types.

Some Python Basics - 4:46

http://youtu.be/ScYu7CtSxtc

As you can see, the Python IDLE could serve as a handy calculator for homework, and unlike a typical hand-held calculator the shell session will allow you scroll back to view earlier calculations. Try typing in 2**10000, which is

2 10000 . Can your average hand-held calculator do that?



Computer Science and Mathematics Standards

Many aspects of introductory computer science may be explored in the context of mathematics standards. By creating programs that support and reflect mathematics standards, students can enhance understanding of the concepts related to those standards.

Common Core State Standards for Mathematics - http://www.corestandards.org/wpcontent/uploads/Math_Standards.pdf


13

Glossary argument: A value provided to a function when the function is called. assignment: A statement that assigns a value to a variable. assignment operator: The "=" symbol, which allows a value to be assigned to a variable. built-in function: Functions which come ready to use with Python, such as print and raw_input. comparison operators: The symbols used in Python for mathematical comparison. These equals (==), not equals

(!=), less than (<), greater than (>), less than or equal (<=), and greater than or equal (>=). data type ( or just type): A category of values. The types addressed so far are integers (type int), floating-poing numbers (type float) and strings (type str).

dividend: In the expression a/b = c, a is the dividend. divisor: In the expression a/b = c, b is the divisor. expression: A combination of variables, operators and values that represents a single result value. float: A data type that represents numbers with fractional parts. function: A named sequence of statements that performs a computation.

function call: A statement that executes a function. It consists of a function name followed by an argument list inside parentheses. integer: A data type that represents whole numbers. modulo operator: An operator, denoted with a percent sign (%), which works on integers and yields the remainder when one number is divided by another.

operand: One of the values on which an operator operates. operator: A special symbol that represents a simple computation such as addition or multiplication.

Operators in

Python include -,+,/,* and %. quotient: In the expression a/b = c, c is the quotient.

remainder: return value: The result of a function. statement: A section of code that represents a command or action. string: A data type that represents sequences of characters. user-defined: Something created by the programmer, such as a variable name used in a program.

value: One of the basic units of data, such as a number or string, that a program manipulates. variable: A user-defined name that refers to a value. Variables may not have spaces and are case sensitive.


14

Simple Applications

The Halt! Who Goes There? Program (halt.py)

The first simple program, halt.py, will have the user enter her or his name and age, and the computer program will provide responses based on that input. For fans of Monty Python, think of the bridge keeper scene in Holy Grail.

Some of the concepts in this program include: sending prompts to the user and receiving keyboard input using the built-in raw_input function, type coercion, concatenate operator (+), conditional statements: if statement and if-else statement, indentation, blocks of code, modulo division, equality and inequality.

The concepts listed above are described in the documentation of the code for this program provided a few sections later in this document. However, the following sections involve a few concepts to consider prior to tackling the program.

The raw_input Function

The built-in raw_input function is a way Python can accept input from the keyboard during a program. The object passed to this function is a string that serves as the prompt to the user for the input. For instance, to store a user's last name into a variable , the code below could be used in the Python shell. (Python 2 also has an input function, which takes in integers and floats. In Python 3, there is only the input function and it only takes in strings, much like raw_input function does in Python 2. Sort of confusing. In this document, raw_input in Python 2 tends to be used because it operates similar to input in version 3, but a teacher could easily decide to also use input in Python 2.)

>>> lastName = raw_input( "Please enter your last name: " )

Please enter your last name: Biff

>>> print lastName

Biff

>>>

Below is the basic format of a raw_input function used to store keyboard input into a variable.

variableName = raw_input( prompt )

Type Coercion

All information received by a raw_input statement is defaulted to string data type.

This is fine when you are taking in a person's name. However, if you ever need to take in someone's age, for example, the data should be converted from a string to an integer. A person's age is an integer, and this is probably how you would want that value stored in the variable. This would be particularly important if you ever planned on conducting mathematical calculations with this variable.

This can be done with a procedure known as type coercion , where as or after the data is received from the user it is converted from one data type to another . Type coercion is also known as type casting .

Try the following in the shell, but do not enter the comments.

>>> age = raw_input( "How old are you? " ) # raw_input defaults to string type

How old are you?

11

>>> print age

11

>>> type(age)

<type 'str'> # The type string is confirmed.

>>> age * 2 # The value in the variable age behaves as a string.

'1111'

>>> age = int(age) # TYPE COERCION: age is re-assigned to integer type using the int function.

>>> type(age)

<type 'int'> # The type integer is confirmed.

>>> age * 2 # Now, the value in the variable age behaves as an integer.

22

You will see an example of type coercion in the upcoming halt.py program.


15

Conditional Statements and Indentation (White-space)

It is possible to have a single line of code or a block of code (a group or set of lines of code) execute only under certain circumstances. This is done with a conditional statement . Conditional statements are able to direct the flow of execution in a program based on whether or not they are true or false at any given time.

True and False are special data types in Python called boolean. True is represented with the integer 1 (one) and

False is represented by 0 (zero).

Below a comparison operator is used in the shell to display True and False expressions.

>> 5 == 4 + 1

1

>>> 7 == 4 + 2

0

In Python, if a conditional statement is true, then the code below it (indented four spaces or Tab key) will execute.

If the conditional statement is false, then the indented code below it will not execute.

For instance, say one wanted a banking program to ask a user to open a savings account when the checking account balance goes over $1,000 dollars. (This is assuming the user does not already have a savings account.) The conditional statement could look like the code below. if checkingBalance > 1000:

openSavings = raw_input ( "Would you like to open a savings account? y/n " )

The first line of code above is a conditional statement, specifically an if statement . Notice that A CONDITIONAL

STATEMENT ENDS IN A COLON (:) !

This is important because after the programmer types in the Enter key after the colon, the Python IDLE will automatically indent the code below it four spaces.

The indented code will only execute if the conditional statement is true.

If the conditional statement is false , then the indented code is skipped and the Python interpreter looks below the indented code for the next line of code that is not indented. This indentation is extremely important in Python as it controls the flow of execution.

This is sometimes known in programming as white-space , and in Python this white space takes the place of "{}" used in so many other languages, such as Java, C++, and others.

Try typing the three lines of code below in the shell.

>>> students = 40

>>> if students > 38: print "We need another teacher!"

To see the output, press the Enter key twice after completing the print statement.

We need another teacher!

>>>

Be very careful with indentations in Python, being off just by one space may cause an error in the program . Try to ALWAYS remember the colon at the end of any conditional statement. If you do remember the colon, you will be fine as Python will then take care of the indentation for you. Just so you know, by default Python indents four white spaces per level of indentation. The tab key in Python also indents four spaces. The size of the indentation is adjustable in the IDLE settings. The key is to just be consistent with indentation.

Indentation is a concept some students can struggle with in the beginning so be on the lookout for this when helping others parse code.

The following is from the Help section in IDLE. Automatic indentation: After a block-opening statement, the next line is indented by 4 spaces (in the Python Shell window by one tab). After certain keywords (break, return etc.) the next line is dedented. In leading indentation, Backspace deletes up to 4 spaces, if they are there. Tab inserts 1-4 spaces (in the Python Shell window one tab). See also the indent/dedent region commands in the edit menu.


16

Code for the halt.py Program

Below is the code for the halt.py program. This initial program is important in that addresses many basic concepts of computer programming. Open a new script window in Python. Save the file as halt.py

.

The code below is heavily documented. A teacher who may be a novice programmer may find this a little confusing at first, but just know that the red text is just comments. Below there are only four lines of code, and that is all the students need to see and enter. It is not necessary for you to type in the comments, but do read them here! At the end of this program, the code appears again undocumented, in just 15 lines. You may elect to view that code first to see how it all goes together, and then come back here and see each line explained via comments.

# halt.py

# Biff B.

# 02.12.2008 Python 2.2

# Concepts in this program include: input, output, assignment operator, variables,

# conditional statements: if and if-else, modulo division, and concatenate operator

# taking input and producing output

# Encase strings in either quotation marks or apostrophes, just be consistent. name = raw_input( "Halt! Who goes there? " ) # The built-in raw_input function accepts keyboard input and this information

# is stored in the VARIABLE, which in this case is the word "name".

# The argument passed in this function is a prompt in the form of a string. print "You may pass" , name # The COMMA allows the print output to continue on the same line.

# If the comma was not there, the program would return an error.

# Save the above and run.

# The program should ask for a name, accept it, and return it.

##############################################################

## Although, there is a punctuation problem with the output. No period. One could add a period the following way: print "You may pass," , name, "." # However, there is still an output problem when the program is run.

# The period has a space in front of it as a comma imposes a space before and after itself.

# Here is the fix. print "You may pass," , name + "." # When the '+' sign is used with two strings it "adds" (concatenates) the two strings.

# Therefore, in such cases, the '+' sign is said to be a CONCATENATE operator.

# Save the above and run until working properly. The program continues in the next section.


17

##############################################################

# Practice taking input and producing output

# Now have the "bridge keeper" ask the user her or his age, and say back to the user, "It must be nice to

# be xx years old." - the xx being 11 or whatever the user types in

# Students should know/learn that a variable is needed to store the input, and that a raw_input function could be used

# to take in the information. A logical variable name would be "age".

# Students should have an opportunity to attempt a solution without being first shown. age = raw_input( "What is your age, " + name + "? " ) # Note how the name is incorporated into the prompt.

age = int(age) # Coerce the variable "age" to integer (int) data type.

print "It must be nice to be" ,age, "years old," ,name+ "." # if both operands are strings, then "+" is a concatenate operator

# Save the above and run until working properly.

##############################################################

# Conditional statements: if if-else

# Now ask the students to report to the user if her or his age is an even or odd integer.

# Ask the students how one would normally determine this - express it in mathematical terms using English.

# An even number (integer) is one that divides evenly by two (with no remainder).

# Therefore, modulo division by two of the age should reveal if the number is even or odd. If there is no remainder,

# then it is even.

# Show the students:

# The double equals signs (==) in Python represents "EQUALS TO". if age % 2 == 0: # This is a CONDITIONAL STATEMENT. ALL CONDITIONAL STATEMENTS END WITH A COLON : print name + ", your age is an even number." # INDENTATION will automatically occur due to the colon above.

# The indentation is how Python keeps track of what to do in conditional statements.

# As long as the conditional statement is TRUE, the INDENTED BLOCK OF CODE below

# the conditional statement will be EXECUTED. If not, the entire indented block is

# merely skipped. else : # An ELSE statement may be added to the IF statement to express odd numbers.

print "Your age is an odd number," , name + "." # Note how ELSE is lined up with IF, ends in a colon and has indented code below.

# Save and test with both odd and even numbers.

##############################################################

# Optional twists: if age == 11: print "Your age is the same as the author of this program when it was created." if age > 50: print "You have been on the planet for over a half century." if age != 11: # The symbols != represent INEQUALITY. print "You are not the same age as the author when this program was created."


18

Below is the same halt.py program with less comments.

# halt.py

# Biff B.

# 02.12.2008 Python 2.2 name = raw_input ("Halt! Who goes there? " ) print "You may pass," , name + "." age = raw_input( "What is your age " + name + "? " ) age = int(age) print "It must be nice to be" , age, "years old," , name + "." if age % 2 == 0: print name + ", your age is an even number." else : print "Your age is an odd number," , name + "." if age == 11: print "Your age is the same as the author of this program when it was created." if age > 50: print "You have been on the planet for over a half century." if age != 11: print "You are not the same age as the author when this program was created."

Glossary raw_input: A built-in function which allows a program to receive keyboard input as a string data type. type casting/coercion: The act of changing data from one type to another. indentation: The process of arranging code in levels of indenting to control the flow of execution. indent: To go in one level of indentation, or four spaces towards the right margin. dedent: To go out one level of indentation, or four spaces towards the left margin. body: The sequence of statements within a compound statement.

Boolean expression: An expression whose value is either True or False. branch: One of the alternative sequences of statements in a conditional statement.


19

concatenate: To join two string operands end-to-end. The "+" is the concatenate operator when both operands are strings. condition: The Boolean expression in a conditional statement that determines which branch is executed. conditional statement: A statement that controls the flow of execution depending on some condition. comparison operator: One of the operators that compares its operands: ==, !=, >, <, >=, and <=. compound statement: A statement that consists of a header and a body. The header ends with a colon (:). The body is indented relative to the header. flow of execution: The order in which statements are executed during a program run. if statement: A conditional statement that only executes if the Boolean expression is True. If it is False, the body of the code is not executed. logical operator: One of the operators that combines boolean expressions: and, or, and not.


20

Area and Perimeter Program (rectangle.py)

Say a fence and turf company often needs to know the area and perimeter of a rectangular field. Applying what you now know how to do in Python, create a program called rectangle.py

, which can take in the length and width of any rectangle and return the area and perimeter of that shape. Below is the code for such a program.

However, you may decide to challenge yourself by first attempting the program on your own.

# rectangle.py

# 02.02.2009

# Biff B.

# Python 2.2.3

# SPECIFICATIONS: The program takes in length and width of any rectangle and returns the area and perimeter of that shape.

# input: length and width of any rectangle

# output: the area and perimeter of that shape

# processing: formula for area: length * width with answer expressed in units SQUARED

# formula(s) for perimeter: length * 2 + width * 2 with answer expressed in units

# (length * 2) + (width * 2) parentheses clarify, but not needed (PEMDAS)

# length+length+width+width alternative formula

# storage: none, just display results to screen

# welcome/instructions print """ # Three quotation marks may be used to encase multiple lines of output.

********************************************************

Welcome to the Area and Perimeter Finder for Rectangles

********************************************************

Enter the length and width of any rectangle and you will be returned the area and perimeter.

********************************************************

""" # Three quotation marks denote the end of the multi-line output.

# input length = raw_input("Enter the length of rectangle: ") width = raw_input("Enter the width of rectangle: ")

# assign a data type (float may used to handle both integers and decimals) length = float(length) width = float(width)

# processing area = length * width perimeter = length+length+width+width

# output print "A rectangle" , length, "by" , str(width)+ ":" print "\nArea:" , area, "units squared" print "Perimeter:" , perimeter, "units"

Area and Perimeter - 8:41 (narrated) Area and Perimeter - 8:13 (unnarrated)

http://youtu.be/qOlRhpPxbBI http://youtu.be/dt5fIBLqjq8


21

The High/Low Guessing Game (guess.py)

In this program, a random number from 1 to 100 will be generated. The player of the game will continually try to guess what that "secret number" is until it is identified. The program will respond by informing the user if each guess is too low, too high or correct. At the end of the game, the user is also to be informed of how many guesses it took to identify the number.

The while Loop

In order to make it easier for a computer program to repeatedly do something, such as ask the user what the secret number is and provide feedback each time, a programmer long ago invented what is commonly referred to as a loop.

A loop in computer science is a structure that allows for something to repeat. Attaching a loop to a condition is a very useful programming concept. For the guessing game, it would be helpful to create a loop that repeats as long as any of the user's guesses do not equal the secret number. In Python, a while loop may be used to achieve this effect.

Before creating the guessing game, open the Python shell in the IDLE and type the following in to see how typical while loops behave. Do not enter the comments to the right of each line. They are just there to contribute to the reader's ongoing education in computer science. After the last line of x = x + 1 press the Enter key twice to see the output.

>>> x = 1 # Assign the variable x the integer value of one.

>>> while x < 10: # As long as x is less than 10, execute the indented block of code.

print x, # The comma at the end keeps all output on one line.

x = x + 1 # Each time through the loop x will be INCREMENTED by one.

# This last line of the indented code above is very important.

# The variable x is increased by one each ITERATION.

# Iteration is a word used in computer science, meaning each

# time through a loop.

# Leave this last line of code out and you would have an INFINITE LOOP.

# See the video for an example of an infinite loop.

# The output of the code appears below.

1 2 3 4 5 6 7 8 9

Try this loop in the Python shell.

>>> x = 10 # INITIALIZE the variable x to the integer value of ten.

>>> while x > 0: # This loop will TERMINATE whenever x becomes zero or less.

print x # Without the comma, the output of each iteration appears on a new line.

x = x - 1 # Instead of incrementing the variable, here it is DECREMENTED by one.

10

9

8

7

6

5

4

3

2

1

>>>

Computer Science for Everyone –Sixth Grade (Non-programmers) http://poudre.us/cs April 13, 2020

22

Creating the High/Low Guessing Game

"There is more than one way to do it" (TIMTOWTDI) is a common phrase in programming. The code below is just one approach of many that could generate this type of guessing game. Other approaches could be far more elegant, such as ones which contain fewer lines of code and/or offer a more efficient approach. The program development of the guessing game is arranged in phases.

Developing the Initial Program

As stated before, a while loop may be used to compare the player's guesses to the secret number. As long as a guess is not the secret number, the game continues. However, when the user guesses correctly the while loop should terminate.

A program development technique called pseudocode involves writing out in English what you want a program to do before you actually begin to code it. Once the pseudocode is written, then it is only a matter of translating it to the Python language. This approach allows the programmer to first focus on the programming concepts and flow of the program, and then later focus on the actual code involved.

Below is an example of pseudocode for the basic parts of guessing game. This is just one approach to this program.

Others are possible.

Generate a secret random number between 1 and 100

Start the program by purposely setting the value for the user's guess to be incorrect

This way, the loop below will execute the first time

While the player's guess does not equal secret number

Ask the user for a guess, assign the data type to integer

If the guess is greater than the secret number,

inform the player the guess is too high

If the guess is less than the secret number,

inform the player the guess is too low

The above while loop will terminate when the guess is correct

At that point, the player should be informed that the secret number has been identified


23

The Initial Script

Save a new script file as guess.py

. It is not necessary to show or have the students write the comments, but do explain to them the concepts associated with each line of code.

# guess.py

# 02.02.2009

# Biff B.

# Python 2.2.3

# High/Low Guessing Game

# The player tries to guess a secret number between 1 and 100.

# Every guess the player makes receives feedback of either too high, too low or correct.

secret = 76 # Initially, have the students supply the secret

# number. Programmer's do this so they *know*

# the answer while testing the program during development.

# Later, we will have Python generate the random number. guess = -99 # This sets the guess to be wrong so the while

# loop will initially execute. Why –99? Why not? It works! :) while guess != secret: # != means NOT equal

guess = raw_input ("What is the secret number?" )

guess = int(guess) # Set the data type to integer.

if guess > secret: print "The number" , guess, "is too high."

if guess < secret: print "The number" , guess, "is too low." print "Yes, the secret number was:" , secret # Note that this line is DEDENTED back to the left

# and will execute only when the while loop above it

# terminates. Pressing the Backspace key at blocked code will dedent the cursor four spaces,

# or a single indent.

Students should test and validate the program by putting in a number they know is too low, then too high, and then just right.


24

Generating a Random Number

Now that the program is working have Python generate the "secret" random number. This may be done by importing the random module and using the randrange function inside it to create a random number between 1 and

100. Once this is done, even the programmer will be able to play the game without already knowing what the random number is. (Of course, a programmer could insert a print statement after the secret number is generated in order to see what that number is as she or he continues to test the game.)

Also please note how the line of code containing the raw_input function has been altered so as to make the line below it no longer necessary.*

# guess.py import random # This statement imports a module called random. This and other modules were

# installed with Python, and more may also be added by the programmer.

# MODULES often contain groups of code, called FUNCTIONS, which are designed to perform

# commonly-needed actions. For instance, the random module contains a RANDRANGE function,

# which generates a random number between a specified range of numbers.

# Before a program may make use of any function inside a module, the module must

# first be imported, as it is here in the single line of code above.

############################################################################################

## secret = 67 This "old" code is commented out/or replace "67" with the function call below. secret = random.randrange(1,101) # This generates a random number between 1 and 100 inclusive.

# randrange is a function inside the random module.

# The function randrange takes two arguments, which are separated by a comma.

# Note how the second argument must actually be one higher than the range needed.

# If the argument passed was (1,100), only numbers between 1 and 99 would be created.

guess = -99 while guess != secret:

guess = int(raw_input ("What is the secret number?" )) # * Note how this line has been altered

##guess = int(guess) <-- so that this line is no longer needed.


if guess < secret: print "The number" , guess, "is too low." print "Yes, the secret number was:" , secret

Save and test the program, a game that you now as a programmer can play yourself.

* This style is more in line with how things are done in Python 3.x. For those interested, there is more information below.

The only difference is Python 3.x uses the word input instead of raw_input . The keyboard input in each case defaults to string data type. Python 3.x only uses the input function, which makes for the kind of format seen in this line of code – one where the entire keyboard input function exists within a type coercion function, in this case, int .

Python 2.x happens to use two keyboard input functions: input and raw_input . However, opposite to Python 3.x, Python

2.x uses the term input to take in integer and float data types. As you have seen, the Python 2.x raw_input function defaults data to string type.

To reduce confusion (and mimic how things are done in Python 3.x), only raw_input has been used so far in this document since it is that function that serves the same purpose as the input function in Python 3.x. However, the input function in 2.x may be used in other 2.x programs referenced later in this document and can take in either integers or floats.


25

Adding a Counter

Now add a counter , a variable to keep track of how many times something happens, to the program so that it will report how many tries the player needed to identify the secret number. This involves creating a variable to keep track of the number of attempts and incrementing it by one every time the user guesses. After the while loop terminates, the variable may then be used to report how many tries it took the player to guess the secret word.

Observe the new code along with the comments below to alter your existing program so as to inform the player how many attempts were needed to identify the secret number.

# guess.py import random secret = random.randrange(1,101) guess = -99 attempts = 0 #1. The variable is initialized with the value zero.

# Of course, any appropriate variable name would do: count,tries,guesses,etc. while guess != secret:

guess = int(raw_input( "What is the secret number?" ))

attempts += 1 #2. The variable is incremented by one each iteration.

#### Notice the shorthand code compared to the longer: attempts = attempts + 1


if guess < secret: print "The number" , guess, "is too low." print "Yes, the secret number was:" , secret print "It took you this many tries:" , attempts #3. The counter variable is used to report out.


26

Adding Feedback

Add feedback to the player during and/or after the game. See the comments to the right that is along side the added code.

# guess.py import random secret = random.randrange(1,101) guess = -99 attempts = 0 while guess != secret: if attempts == 8: # Help out the player print "Eight tries so far. Keep trying!" # when it may be needed.

if attempts == 9: #

hint = raw_input ( "Do you want a hint? y/n " ) # if hint == "y" : # if secret > 1: # print "The secret number is less than:" , secret + 1 # else : # print "The secret number is less than: 2" #

guess = int(raw_input ("What is the secret number?" ))

attempts += 1


if guess < secret: print "The number" , guess, "is too low." print "Yes, the secret number was:" , secret print "It took you this many tries:" , attempts if attempts < 6: # Provide a compliment print "Five or less tries reflect some skill and/or luck!" # when appropriate.


27

Putting the Game in a Loop

Now that the game works, the code may be indented and placed in a while loop.

Below are the documentation and code for placing the game in a loop so a user may play the game as many times as desired. import random

#1. Highlight all the code except for the first line (above) that imports the random module,

# and then press the Tab key. This will indent the highlighted code one level to the right,

# as it now appears in this code here.

while 1: #2. All the way to the left, add this while loop ABOVE the indented block of code.

# The '1' means TRUE. Therefore, the loop executes forever, unless it is broken (#5).

#3. Add a prompt to see if the user would like to play the game.

play = raw_input( "Would you like to play the High/Low Guessing Game? y/n " )

if play == "n" : #4. This condition allows the user to exit the program.

print "Goodbye!" break #5. The keyword 'break' terminates the outer 'while 1' loop.

# The Python interpreter then skips down to the next line

# of code at the same level (#6) of the terminated 'while 1' loop.

secret = random.randrange(1,101)

guess = -99

attempts = 0

while guess != secret: if attempts == 8: print "Eight tries so far. Keep trying!" if attempts == 9:

hint = raw_input ( "Do you want a hint? y/n " ) if hint == "y" : if secret > 1: print "The secret number is less than:" , secret + 1 else : print "The secret number is less than: 2"

guess = int(raw_input ("What is the secret number?" ))

attempts += 1


if guess < secret: print "The number" , guess, "is too low."

print "Yes, the secret number was:" , secret

print "It took you this many tries:" , attempts

if attempts < 6: print "Five or less tries reflect some skill and/or luck!" print "End of program." #6. Here is where the program skips to once the outer loop is broken.


28

How Fair is the Random Number Generator?

The for Loop

Another loop available in Python is the for loop. You will use it to generate a very large amount of random numbers, and analyze how often certain ranges of numbers appear. This may provide some insight as to how equitable the distribution of random numbers is across the range.

First, enter the code examples below (without the comments) in the shell to see how a for loop operates.

>>> for x in range(1,10): # The first argument in the built-in range function is the

print x, # beginning of the range, and the second argument is the end

# of the range, but note what the output goes to – nine!

# Press Enter twice after the comma to see the output below in blue.

1 2 3 4 5 6 7 8 9

As you may have noticed, as soon as you type in the opening bracket for a function call a small box will pop up below the current line giving you a "tip" with regards to the arguments that are expected. The tip continues to display until the closing bracket is entered.

Now press the Alt-p keys. This will repeat the previous code. Edit the second argument to be 11. Since the value of the second argument is exclusive , this will get the loop to count to ten. Place the cursor back to just after the comma and press the Enter key twice to see the output of this adjusted code.

>>> for x in range(1,11): # To count to ten, the second argument must be one more.

print x,

1 2 3 4 5 6 7 8 9 10

Again, press Alt-p and remove the first argument. As you observe, when left out it is assumed to be 0, which does yield 11 iterations.

>>> for x in range(11): print x,

0 1 2 3 4 5 6 7 8 9 10

Lastly, use a for loop to generate 25 random numbers between 1 and 100.

>>> import random

>>> for x in range(25): print random.randrange(1,101),

76 13 62 42 46 79 28 15 91 47 58 18 44 46 33 29 13 43 24 53 26 64 18 64 67 30

Of course, for loops can do other things, but what we have seen is enough to get started using a for loop to help with the analysis of the fairness of the randrange function in the random module.


29

Computer Simulation

How could one assess the randomness of the randrange function? Say you had Python create a million random numbers and each one was printed onto a paper 3"x5" note card. You were then asked to take each card and place it into one of four large bins: the first bin is to be used for numbers 1 to 25, the second is for numbers 26 through 50, the third bin for 51 to 75 and the fourth bin for 76 to 100. If the random number generator was fair, after every card was processed would not each bin contain roughly an equal amount of random numbers, around a quarter of a million? Obviously, it would be impractical to physically perform such an analysis as at a pace of one second per card it would take a person over ten days non-stop, but with a computer it is very quick and easy to simulate .

Use Python to create a million random numbers, and as each number is created increment one of four counters, each designed to represent one-fourth of the range of possible numbers.

Before going on in this document, please consider trying to write some or all of the pseudocode for this program and even parts of the program itself. You may surprise yourself, and will enhance your ability to think like a computer scientist.


30

Open a new script in Python and save the file as randomAnalysis.py

.

Below is some pseudocode.

Import the random function

Create four counters, or buckets, if you will: one each for 1-25, 26-50, 51-75, and 76-100

Ask how many numbers should be generated

Use a for loop to generate random numbers

During each iteration, increment the appropriate bucket

At the end, report the amount of each bucket

# randomAnalysis.py import random bucket1 = 0 # for numbers 1-25 bucket2 = 0 # 26-50 bucket3 = 0 # 51-75 bucket4 = 0 # 76-100 times = int ( raw_input ( "How many random numbers should be generated?" )) for x in range(1,times+1):

x = random.randrange(1,101) # The variable x is used to represent the random number.

if x <= 25:

bucket1 += 1 elif 26 <= x <= 50: # These are elif (else-if) statements, which allows multiple conditions

bucket2 += 1 # to be considered.

elif 50 < x < 76: # <-- Also notice how x is represented to be within a range.

bucket3 += 1 # Here, x is both greater than 50 AND less than 76 (or 51-75) . else : # An else statement is required as the final condition.

bucket4 += 1 print "Bucket 1:" , bucket1 print "Bucket 2:" , bucket2 print "Bucket 3:" , bucket3 print "Bucket 4:" , bucket4 print "\nTotal:" , bucket1+bucket2+bucket3+bucket4 # Just in case something fishy is going on. :)

Save the script and run the program.

Below is sample output based on a generation of one million random numbers. As you can see, each bucket is roughly the same. So one could assume the random number generator is fair enough for friendly games. The kind of random numbers generated by Python are referred to as pseudorandom numbers.

Bucket 1: 249794

Bucket 2: 249860

Bucket 3: 250597

Bucket 4: 249749

Total: 1000000

The students should see that generally the buckets come out even. However, if a small amount of random numbers

(say, 20) are generated, the results may be far less evenly distributed.


31

Glossary loop: To repeat something over and over. while loop: A loop that repeats as long as a certain condition is true. increment: To increase. iteration: Each time through a loop.

decrement: To decrease. terminate: To end or break out of a loop.

initialize: To create a variable and set it's value. pseudocode: A description of how a program works using English, or a combination of code and English. module: A file that contains functions that may be used when imported in a program. counter: A variable used to keep track of how many times something happens. for loop: A loop that runs for a specific number of times. exclusive: This means "not included" when talking about a range of numbers. When someone says, "1 through 10 exclusive," that person means the numbers 2, 3, 4, 5, 6, 7, 8 and 9, but not 1 or 10.


32

The Least Common Multiple (LCM) Finder (lcm.py)

The input Function

For the first time in this document, the input function in Python 2.x will be used. The input function in Python 2.x takes in float and integer data. Python 3.x does not have an input function, but only a raw_input function. The input function also allows multiple variable assignments in one statement. Please read all the comments below as you create this program.

Students are to make a program that can take in any two integers and output the least common multiple.

# lcm.py

# 02.02.2009

# input is two integers

# output is the least common multiple

# Review with the students what the lcm of two integers is and the brute force algorithm of

# simply increasing the smaller integer by its multiple and repeating that process

# until the two are equal.

# Walk through the algorithm with the students. Find the LCM of 6 and 8.

# x = 6 y = 8

# 6 8 Which one is smaller? x Then increment it by its original multiple (6 becomes 12).

# 12 16 Which one is smaller now (12 or 8)? y Then increment it by its original multiple.

# 18 24 Which one is smaller now? x Then increment it by its original multiple.

# 24 <-- ^^ -- The lcm is identified when x and y are equal.

# This algorithm will work with any two positive integers, and very quickly with a computer.

# Pseudocode:

#

# Take in two integers, x and y.

# Create two more variables, multx and multy, which will be used as the original multiple values.

#

# Use a while loop to compare x and y as long as they remain unequal.

# Each iteration should increment the smaller variable by its original multiple.

# The loop terminates when x and y are equal, identifying the lcm.

x,y = input( "Enter two integers separated by a comma (for ex. 6,8): " ) print "You entered:" , x, "and" , y

##NOTE: The line of code above is the first in this document to use the INPUT function in Python

2.x. The input function may be used to take in float and integer data. Also, notice how in the statement above multiple variables may be assigned when a comma separates the keyboard input. multx = x # These two variables are created to preserve the original multiple values.

multy = y # Some students may need extra time and help in understanding when and how to create

# variables in order to solve problems. print "x\ty" # The escape character (\) followed by the letter "t" inserts a tab.

while x != y: # Once x and y are equal the lcm is identified, and the loop terminates. print x, "\t" , y # This will help one see the effects of the loop.

# This is an example of SCAFFOLDING, which is code that may be removed

# after the programmer uses it to confirm the program is working as

# desired and/or to help with the debugging process.

if x < y:

x += multx # Increase the smaller integer by its multiple.

else :

y += multy lcm = x # y could have also been used as both are equal at this point. print x, "\t" , y print "The LCM of" , multx, "and" , multy, "is" , str(lcm) + "."


33

Below is the same code with less documentation.

# lcm.py

# 02.02.2009

# input is two integers

# output is the least common multiple x,y = input( "Enter two integers separated by a comma (for ex. 6,8): " ) print "You entered:" , x, "and" , y multx = x multy = y print "x\ty" while x != y: print x, "\t" , y if x < y:

x += multx else :

y += multy lcm = x print x, "\t" , y print "The LCM of" , multx, "and" , multy, "is" , str(lcm) + "."


34

The Factors Finder Program (factorsFinder.py)

Create a Factor Finder program that can take in any positive integer and return all the factors of that number.

Include a counter so you may answer questions such as, how many factors are there in a million?

Pseudocode:

Take in any positive integer

Use a loop to divide that integer by every number from one to the integer itself

During each iteration, check to see if there is a remainder to the integer division

If there is no remainder, then that divisor is a factor of the integer

Print/display the factor, increment a counter

Use the counter to report how many factors were found

# factorsFinder.py fcount = 0 dividend = int(raw_input( "Enter any integer and be returned the factors of that number: " )) print "The factors of" , dividend, "are:" , for divisor in range(1, dividend+1): # Test every divisor from 1 to the integer itself.

if dividend % divisor == 0: # Modulo division: if there is no remainder, then that print divisor # divisor is a factor of the integer.

fcount += 1 print "\nThe integer" , dividend, "has" , fcount, "factors." # '\n' creates a new line of output

# The '\' backslash is known as an escape character.

# An escape character indicates that the character after it has special

# meaning. In this case, the 'n' stands for 'new line.'

Save the script and test it out. How many factors does the integer one million have? (When you enter a single number in Python, do NOT use comma separators. For instance, to enter a million type "1000000" instead of

"1,000,000".) Can you add code to this program that would tell the user if the integer entered was prime or not?

Can you get this program to run continually until the user enters zero? Is there any pattern to one million, two million, three million, and so on up to ten million?

The movies below use a while loop instead of a for loop, and take things a little further. factors.py (Part 1 of 2) - 10:45 factors.py (Part 2 of 2) - 7:00

http://youtu.be/ra7P9DeyuNU http://youtu.be/HwxwJvBQaB4


35

The Change Maker (changeMaker1.py/changeMaker2.py)

You are to make a program that can process information passed within a self-service retail register. The input will be how much the total bill is and how much money the customer has inserted into the register. Your program is to return the exact change that is needed, and indicate how many, if any, fifty-dollar bills, twenty-dollar bills, ten dollar bills, five dollar bills, one dollar bills, quarters, dimes, nickels and pennies should be dispensed to the customer.

(The register accepts one hundred dollar bills, but does not dispense them.) The program should run continuously until 0 is entered for the bill.

When creating a larger program sometimes it is helpful to start out small. Think about a machine that could only handle coins, like the ones used inside Wendy's Restaurants in Fort Collins. What if the program only had to deal with the input of the amount of change needed from 0.00 to 0.99? The program would just have to return the appropriate coinage. Start with this smaller program in mind. Once this is accomplished, it shouldn't be much of a leap to add the rest.

Yes, yes, the code follows, but if you haven't already, do you not think it is about time to start thinking on your own? Thinking about problems in computer science is an inherently beneficial activity, learning to program over time may increase one's ability to read, think and solve problems. The sense of accomplishment is great, and it is a way of thinking that may positively influence one's overall performance in whatever fields are pursued in the future.

As you learn a programming language, you can probably handle more complex ideas over time. Of course, some solutions do not have to be that complex. There are more elegant solutions to be sure, but as you will see the solution shared here just uses a simple idea, over and over again.

As long as the change needed to dispense is over 0.25, wouldn't you look at counting one or more quarters out until that is no longer the case, and then look at the next largest denomination? Think about it, and try to come up with some pseudocode.


36

Creating changeMaker1.py

#changeMaker1.py

# A simple change maker for coins

# input: The amount of change needed, ranges from 0.00 to 0.99

# output: The number of quarters, dimes, nickels and pennies to be dispensed

# initialize counters for all types of coins quarters = 0 dimes = 0 nickels = 0 pennies = 0 change = float(raw_input( "How much change is needed? " )) # Coerce the input to be of float type. print "Change to be dispensed:" , change #It is helpful to display the change that was requested.

while round(change,2) >= 0.25: # The built-in round function sets change to 2 decimals places. quarters += 1 # Increment the counter by one.

change -= 0.25 # Change gets DECREMENTED 0.25 each ITERATION.

while round(change,2) >= 0.1: # Look at other coinage in descending denomination ...

dimes += 1

change -= 0.1 while round(change,2) >= 0.05:

nickels += 1

change -= 0.05 while round(change,2) >= 0.01:

pennies += 1

change -= 0.01

# Once the above while loops terminate, use the counters to report the dispensation of coinage. print "Quarters:" , quarters print "Dimes:" , dimes print "Nickels:" , nickels print "Pennies:" , pennies

The next section involves adding features to handle the amount of the bill, the amount of money inserted, the change needed, and the ability to deal with currency. The video below shows the development of the entire program.


37

Creating changeMaker2.py

Below is an expanded version of changeMaker1.py, which includes input for the bill and money entered along with the ability to break the change needed from 99.99 to 0.00 into fifties, twenties, tens, fives, ones, quarters, dimes, nickels and pennies. The program also loops until the input for the bill is zero.

# changeMaker2.py

# The entire program loops until zero is entered for the amount of bill. while 1: # Indent all the code below and place it within a while loop.

bill = input( "What is the amount of the bill? " ) if bill == 0: break # If the bill is entered as zero, the program should terminate.

else :

inserted = input( "How much money was inserted by customer? " )

change = inserted - bill

### The above line assumes that the customer has inserted more than enough money. print "Change needed: " , change

fifties = 0 # Additional counters for currency are added in descending order.

twenties = 0

tens = 0

fives = 0

ones = 0

quarters = 0

dimes = 0

nickels = 0

pennies = 0 while change >= 50.00: # Again, the idea is to deal with denominations in descending order.

fifties = fifties + 1

change = change - 50.00 while change >= 20.00:

twenties = twenties + 1


tens = tens + 1


fives = fives + 1


ones = ones + 1


quarters = quarters + 1

change = round(change,2) - 0.25 while change >= 0.10:

dimes = dimes + 1


nickels = nickels + 1


pennies = pennies + 1

change = round(change,2) - 0.01 print "Fifties:" , fifties print "Twenties:" , twenties print "Tens:" , tens print "Fives:" , fives print "Ones:" , ones print "Quarters:" , quarters print "Dimes:" , dimes print "Nickels:", nickels print "Pennies:" , pennies print "Goodbye!" # This message appears once the while loop is terminated.


38

The Greatest Common Denominator (GCD) Finder (gcd.py)

This next section involves creating a program that can return the greatest common denominator of any two positive integers.

As far as a working algorithm goes, one way could be to find the factors of each positive integer and then compare the contents of those two lists of factors to identify the greatest common denominator. The students have already constructed a factors finder program and may just need a way to easily refer to that code since it will be needed more than once in this program, but they also now need a way to compare the contents of the two lists of factors.

The next section describes how to make use of the list data type in Python, and the section after that addresses how to wrap up the code from the Factors Finder program into a programmer-created function.

Lists

Python has a list data type that can help with the construction of the GCD program. A list is a sequence of values

(of any data type). Students will need to learn about lists in order to create the Greatest Common Denominator program. More times than not and especially when I work with younger students, I tend to just have them jump on the shell and have at it. However, for those who want to learn more formally about lists, please check out the 13 pages of Chapter 10 – Lists in Think Python - An Introduction to Software Design , an excellent open source textbook by Allen Downey designed for high school students.

As usual, the comments below are not to be entered in the shell, but here to provide context for what is being done.

As you see in the video, as I teach and have the students enter the code, I would basically state and expound upon the comments listed here.

IDLE 1.2

>>> beatles = [] # Initialize a list by using square brackets "[]", a variable and

# an assignment operator.

>>> beatles # Return the value of this list.

[] # It is an empty list, but a list!

>>> type(beatles) # Return the data type of the variable.

<type 'list' >

# Python provides METHODS, which operate on lists.

# For example, the APPEND method below adds a new ELEMENT to the end of a list.

# Each "thing" in a list is called an ELEMENT (ITEM is also another commonly-used term).

# Though in the examples below only strings are used, each element of a list may be of any

# data type. In the GCD project, the elements in the lists will be integers.

>>> beatles.append( "John" ) # Add an ELEMENT to the list using the APPEND method.

>>> beatles

[ 'John' ]

>>> beatles.append( "Paul" ) # The default is that new ITEMS are added to the end of the list.

>>> beatles

[ 'John', 'Paul' ]

>>> beatles = beatles + [ "George" ] # Here is another way to add an item to a list.

>>> beatles

[ 'John', 'Paul', 'George' ]

>>> beatles += [ "Ringo" ] # Of course, here is the shortcut for the previous way.

>>> beatles

[ 'John', 'Paul', 'George', 'Ringo' ] #########################################################

>>> beatles[0] ## Lists have elements/items which are accessible via an INDEX!

'John' ## However, the indexing begins at ZERO! <<<<<<<<<<<<<<<<<<<<<<<

>>> beatles[1] ###################################^^^^#########################

'Paul' ##

>>> beatles[2] ##

'George' #######################################################

>>> beatles[3] ## Therefore, even though Ringo is the fourth member, #

'Ringo' ## the index is 3 as indexing begins with 0. #

>>> beatles[4] #######################################################

Traceback (most recent call last): ## The index of 4 returns an "out of range"

File "<pyshell#16>", line 1, in ? ## error message similar to what appears here.

beatles[4] ###############################################

IndexError: list index out of range

(On paper, this shell session on lists continues on the next page.)


39

>>> len(beatles) # Here, the built-in len function returns the LENGTH of the list,

4 # which is the number of elements in the list.

>>> beatles[-1] # Note how the last item in the list may be accessed with the index –1.

'Ringo'

>>> length = len(beatles) # Here is another way to determine the last item.

>>> beatles[length-1]

'Ringo'

>>> for member in beatles: # A FOR loop may be used to TRAVERSE the elements of the list.

print member

'John'

'Paul'

'George'

'Ringo'

>>> x = len(beatles) - 1 # Here, WHILE loop is constructed to traverse a list

>>> while x >= 0: # in reverse order.

beatles[x] x -= 1

'Ringo'

'George'

'Paul'

'John'


40

Creating and Using Your Own Functions

Recall the factorsFinder.py program you made. In the GCD program, you will need to find the factors of two positive integers. Often, when the same operation needs to be repeated it is best to wrap the process, or algorithm, into a block of code that can be called upon whenever it is needed. Python allows a programmer to do this with what is known as a function . You have used many built-in functions already, such as type , int , print , raw_input and others. In the GCD program, you will wrap code from the factorsFinder program into a function that you can

"call" upon when you need to find the factors of the two positive integers.

Functions written by the programmer are to always be placed above the regular or main code of the program. A function definition is used by the programmer to specify the name of the new function and the sequence of statements that execute when the function is called.

For instance, say you were writing a computer game and there is a need to print out the same lyrics to a song at various instances throughout the program. Here is a way you could define that function and call upon it when it is needed. def printLyrics (): # The keyword def stands for definition and printLyrics is the function name.

print "I'm a lumberjack, and I'm okay." # Note the function HEADER above ends in a colon, print "I sleep all night, and I work all day." # and the BODY of the function is indented.

To call the function later during the program, the programmer would then use this function call . printLyrics() # Notice there is no argument in this particular function call,

# but the parentheses are needed.

Below is the same example in the shell.

>>> def printLyrics (): print "I'm a lumberjack, and I'm okay." print "I sleep all night, and I work all day."

>>> printLyrics()

I'm a lumberjack, and I'm okay.

I sleep all night, and I work all day.

>>>

Below is an example of a user-defined function call that contains an argument, which is a variable passed to the function. As you see, the function is defined to accept the argument by assigning it to a variable called a parameter , in this case called "bob". A parameter is just a variable name used in the function definition, and is designed to handle whatever argument was passed to it at the call. This way, the function may be used with different arguments throughout a program.

>>> def printThrice (bob): # This is a FUNCTION DEFINITION. The PARAMETER is "bob".

print bob * 3

>>> printThrice( "Spam! " ) # This is a FUNCTION CALL. The ARGUMENT is "Spam! ".

Spam! Spam! Spam! # The return value of the function appears.

>>> printThrice( "Hoy! " ) # This is another FUNCTION CALL. The ARGUMENT is "Hoy! ".

Hoy! Hoy! Hoy!


41

It may not be readily evident why it is worth the trouble to divide a program into functions. There are several reasons:

• Creating a new function gives you an opportunity to name a group of statements, which makes your program easier to read and debug.

• Functions can make a program smaller by eliminating repetitive code. Later, if you make a change, you only have to make it in one place.

• Dividing a long program into functions allows you to debug the parts one at a time and then assemble them into a working whole.

• Well-designed functions are often useful for many programs. Once you write and debug one, you can reuse it.


42

Creating the Program

Biff is often asked by his math teacher to identify the greatest common denominator of two positive integers so he decides to write a program called gcd.py that will help him check his work on such problems.

Biff wants the program to be able to take in two positive integers, place the factors of each integer into a list, and identify the greatest common denominator by comparing the contents of the two lists.

A sample of the program running would look like this:

Enter two integers separated by a comma to receive the GCD: 45,36

The factors of 45 are: [45, 15, 9, 5, 3, 1]

The factors of 36 are: [36, 18, 12, 9, 6, 4, 3, 2, 1]

The GCD of 45 and 36 is: 9

Done!

Biff writes some psuedocode.

Function(s)

Wrap code from factorsFinder.py into a function named factorsFinder, this function should be able to receive

any integer and return a list containing all the factors of that number

The list of factors returned should be in order from largest (the integer itself) to smallest (1)

Actual program

Receive the input of two integers: x and y

Call the factorsFinder function in two separate assignment statements, one with the argument of x and

the other of y, so variables may be used to reference each list of factors returned by the function calls

Traverse one list and identify the first element that is also present in the other list

This first "match" will be the GCD of the two integers, x and y, display the GCD to the computer monitor


43

# gcd.py

# input: Two positive integers

# output: The GREATEST COMMON DENOMINATOR (GCD) of those two integers.

# process: Populate two lists with the factors of each integer, largest to smallest.

# Compare the contents of one list to another. The first match is the GCD.

# function definition section – in this case, just one

# factorsFinder is the function name, and positiveInteger

# is the PARAMETER, the variable assigned to the ARGUMENT def factorsFinder (dividend): # (the integer) passed to it from the FUNCTION CALL.

factors = [] # An empty list is initialized.

divisor = dividend # divisor to test for factors while divisor >= 1: # The loop is set to terminate after the divisor of 1 is tested. if dividend % divisor == 0: # If there is no remainder, then it is a factor.

factors.append(x) # Populate the list with all the factors.

divisor -= 1 # DECREMENT the variable, divisor, by one each iteration.

return factors # This RETURN statement allows the variable assigned in the

# function call to be given the value of the list of factors.

# main <--The function definition area is above this line and the actual program is below. x,y = input( "Enter two integers separated by a comma to view GCD: " ) xfactors = factorsFinder(x) # These two FUNCTION CALLS are assigned to variables. yfactors = factorsFinder(y) print "The factors of" , x, "are:" , xfactors # Use print statements to verify print "The factors of" , y, "are:" , yfactors # the program is properly working.

for item in xfactors: # Traverse in order the content of one list to see which element if item in yfactors: # first also appears in the other list. That will be the GCD.

print "The GCD of" , x, "and" , y, "is" , str(item)+ "." # Display GCD. break # Terminate the loop as the GCD has been identified.

print "\nDone!"

Once working, submit the script in the body of an e-mail message with the subject "GCD" ALONG with the GCD of 576 and 384. Therefore, your subject should read:

GCD### (except the '#'s need to be replaced with the GCD of 576 and 384) You may copy this input: 576,384

Below is the same program undocumented.

# gcd.py def factorsFinder (dividend):

factors = []

divisor = dividend while divisor >= 1: if dividend % divisor == 0:

factors.append(x)

divisor -= 1 return factors

# main x,y = input( "Enter two integers separated by a comma to view GCD: " ) xfactors = factorsFinder(x) yfactors = factorsFinder(y) print "The factors of" , x, "are:" , xfactors print "The factors of" , y, "are:" , yfactors for item in xfactors: if item in yfactors: print "The GCD of" , x, "and" , y, "is" , str(item)+ "." break print "\nDone!"


44

Glossary list: A data type in Python which can contain items arranged in a sequence. The items may be of various type. element: One "thing" or entity in a list. item: One "thing" or entity in a list. traverse: To "go across" the items of a list in sequence. A for loop is often used to traverse the items of a list. append: To add an item to the end of an existing list. index: Items in a list are identifiable by numbers, which makes up the index. The first item is in the zero-th place.

The second in the one-th place, and so on. It can be a little confusing at first, but just know that numbering begins at zero and the index of the last item is "one less" than the length of the list, which is the number of items in the list. length function: The length (len) function returns the number of items in a list, or the number of characters in a string. function: A function is a predictable set of statements which, whenever called, acts upon one or more variables and returns a result . function definition: A set of statements which, whenever called, acts upon one or more variables and returns a result. A function definition has the following format: a header, which contains the keyword def followed by the function name and then the parameter(s), in any, in parentheses. Below the header is the body, an indented set of code designed to return a desired result. Unless stored in a module, user-created function definitions must be placed at the top of the script file, above the actual program code. function call: To evoke/use a function during a program. The format is the function name followed by the variable passed to it inside a set of parentheses. This variable is called the argument. The function called may be one that is built-in Python, imported from others elsewhere, or personally created by the programmer.

body: The indented code below the first line of a compound statement.

header: The first line of a compound statement. The code below it is indented.

argument: A value provided to a function when the function is called. This value is assigned to the corresponding parameter in the function. parameter: A variable name used inside a function to refer to the value that was passed as an argument at the function call. return statement: The expression of the return value of a function.

return value: The result returned to the point of the function call.


45

Other Simple Applications

Fibonnaci Sequence and the Golden Ratio – display the numbers in the sequence: a=0 b=1 and c = a + b, as well as how the golden ratio is present in the sequence by dividing each number found in the sequence by the previous number

Fractions – program can multiply and divide given pairs of fractions

Mean, Median, Mode – program can identify these values from a given data set

Finding the Distance Between Two Given Points on a Linear Plane – using the Pythorean Theorem

Penny Doubler – ask the user for how many days to double a penny and display findings

Using a Computer to Simulate the Results of a Chance Device – roll two dice a million times, find the sum of each roll, how many times does each sum appear, what is the percentage of occurrence for each sum

Math Facts Game – single-digit multiplication "flash card" game

Wrap all previous programs into a single program that has a menu interface


46

Careers in Computing

The Careers section of the Computer Science Teachers Association is a great resource for career posters, brochures and links.


47

Python for Everyone

Py

for Everyone

An Introduction to Computer Science for Elementary Teachers and Students

Py

for Everyone

An Introduction to Computer Science for Elementary Teachers and Students

Preface

Python language

CSTA

ACM

Being Fluent in Information

Technology

National Academy of Sciences

print "Marissa " * 50

Contents

Python Programming

Teaching Outline

Getting Started

The Basics

A

variable

price

Variables

hold

values.

The

variable price

could be used to hold the

value 19.99

. Another variable could be

name

used to hold the value of the string of alphabetical characters that make up a person’s first name, such as "Biff". Values vary by

Python are: string, integer and float.

The information that needs to be stored

A person’s name

A person’s age

The price of something

Variables and Data Types – An Overview data type

The variable name specified name age price

.

Three common data types in

The value assigned to the variable

"Bob"

10

19.99

The data type of that value

rather than

String (text)

Integer (whole numbers)

Float (decimal numbers)

http://youtu.be/ScYu7CtSxtc

Simple Applications

http://youtu.be/qOlRhpPxbBI http://youtu.be/dt5fIBLqjq8

http://youtu.be/ra7P9DeyuNU http://youtu.be/HwxwJvBQaB4

Careers in Computing

Related documents

Add this document to collection(s)

Add this document to saved

Suggest us how to improve StudyLib