IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 14

Today's Topics

Review

Strings and String Literals
Characters
Comments
Variables
Creating Variables with Assignment Statements
Expressions
Variable Naming Rules
Numeric Data Types and Literals
The input Function
Performing Calculations
Decimal and Integer Division
Exponent Operator
Remainder Operator
Operator Precedence
Grouping with Parentheses
Escape Characters
Concatenation Operator
Boolean Expression
Relational Operators
Precedence of Relational Operators
Control Structures
if Statements
if-else Statements
Indentation in the if-else Statement
Nested if Statements
if-elif-else Statements
Logical Operators
Precedence of Logical Operators
Loops
While Loops
Infinite Loops
for Loops
The range Function
Running Totals
Augmented Assignment Operators
Nested Loops
Functions
Two Types of Functions
Defining a Function
Calling a Function
Local Variables
Parameters

Homework 7

I have posted homework 7 here.

It is not due this coming Sunday.

Instead is due on the Sunday of the following week, October 27th.

This is to allow you time this weekend to study for the mid-term.

Mid-term

Review

Strings and String Literals

Whenever we write a value directly inside a Python script it is called a literal
Here are some examples
```
5
6.47
True
```
In programming, text values are called strings
A string is just a sequence of characters
When we write something like
```
    print("Hello world!")
```
we have created a string literal
In Python, string literals are enclosed in either single quotes, ' or double quotes, "
```
>>> team = "Red Sox"
>>> name = 'Glenn Hoffman'
```

Characters

Everything in a computer's memory is a binary number
Binary number are written in powers of 2 and use a string of 1s and 0s
To represent a character we need a table of numbers and the character they represent
Nowadays we use a character table called Unicode
Unicode represents all the characters in most world languages

Comments

A comment is text written inside a program, that is not read by the interpreter
Comments describe how the program works
In Python, any text on a line after a hash mark, # is ignored by the interpreter
```
>>> print("Hello") # but ignore this text
Hello
```
If you want to write a multiline comment, each line must begin with a #

Variables

A variable is a place in memory with a name that stores a value
A variable in Python can hold a value of any type

Creating Variables with Assignment Statements

You create a variable by giving it its first value
This is done with an assignment statement
An assignment statement has the general form
```
VARIABLE_NAME  =  EXPRESSION
```
Here is an example
```
name = "Glenn Hoffman"
```

Expressions

An expression is anything that can be turned into a value
There are four different kinds of expressions
- Literal
- Variables
- Calculations
- Function calls
Expressions are used on the right hand side of an assignment statement
And as arguments in a function call

Variable Naming Rules

Variable names in Python must follow certain rules
- You cannot use words that have special meaning to Python as variable names
- Variable names cannot have spaces
- The first character of a variable name must be a letter, a-z or A-Z, or an underscore, _
- After the first character you can use letters, digits or the underscore
- Uppercase and lowercase letters are distinct
Words that have special meaning to Python are called keywords
Python is case sensitive
That means that uppercase letters and lowercase letters are completely different

Numeric Data Types and Literals

A Python variable can hold many different types of values
- Strings
- Integers
- Floats
- Booleans
Values of each type ares stored in the computer's memory in a different format
The technical term for each of these different representations is a data type

The `input` Function

The input function is used to ask the user for a value
When the interpreter comes across input in a script it stops running
Then it prints the text in its argument as a prompt
input waits for the user to type some text
When the user hits Enter or Return, input returns the string to the function call
```
>>> name = input("Name: ")
Name: Glenn
>>> name
'Glenn'
```
The value returned by input is always a string
If we want the value to be some other data type we have to use a conversion function
To convert the variable number to an integer we can use the int function
```
>>>  number = int(number)
>>>  type(number)
<class 'int'>
```

Performing Calculations

Operators are special characters that act upon one or more values and perform some action
Usually the action is to creates a new value
The values that the operators work on are called operands

Python has operators for basic arithmetic

Character	Operation	Description
+	Addition	Adds two numbers
−	Subtraction	Subtracts one number from another
*	Multiplication	Multiplies one number by another
/	Division	Divides one number by another and gives the result as a decimal number
//	Integer division	Divides one number by another and gives the result as an integer
%	Remainder	Divides one number by another and gives the remainder
**	Exponent	Raises a number to a power

Decimal and Integer Division

Python has two division operators
- /
- //
/ works like ordinary division
```
>>> 4 / 2
2.0
>>> 4 / 5
0.8
```
// division always gives a whole number, throwing away the decimal part
```
>>> 10 // 3
3
```

Exponent Operator

** is the exponent operator
The first operand is raised to the power of the second operand
```
>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 3 ** 4
81
```

Remainder Operator

When we perform long division we get two results
- A quotient
- A remainder
If we divide 17 by 5 we get a quotient of 3 and a remainder of 2
Integer division, //, gives us the quotient
```
>>> 17 // 5
3
```
and we can get the remainder with %
```
>>> 17 % 5
2
```

Operator Precedence

Sometimes the order in which you use operators affects the result
Python needs rule to decide which operators to use first
The order in which operators are evaluated are called the rules of operator precedence
The operator with the highest precedence is used first
The precedence for Python's arithmetic operators is

** Exponentiation

* / // % Multiplication, division and remainder

+ - Addition and subtraction

Grouping with Parentheses

When we write
```
2 + 3 * 5
```
Python will multiply 3 times 5, before it adds 2
If you want addition to be done first, you use parentheses
```
>>> 2 + 3 * 5
17
>>> (2 + 3) * 5
25
```

Escape Characters

The non printing characters
- Space
- Tab
- Newline (Return or Enter)
are called whitespacecharacters
You can add a space to a string just by hitting the space bar
But how do you add a Tab?
To include such characters in a string you need a special way to represent them
You do this using two characters, where the first is a \
Such combinations are called escape characters

The most commonly used escape characters in Python are

Escape Character	Effect
\n	Causes output to be advanced to the next line
\t	Causes output to skip over to the next horizontal tab position
\'	Causes a single quote mark to be printed
\"	Causes a double quote mark to be printed
\\	Causes a backslash character to be printed

Concatenation Operator

Different data types use different operators
Dividing two numbers make sense, but not dividing two strings
The basic operation performed on strings is to join two strings into one
This is called concatenation

The concatenation operator in Python is +

>>> team = "Red Sox"
>>> cheer = "Let's go " + team
>>> print(cheer)
Let's go Red Sox

Boolean Expression

A value that can only be true or false is a data type called a boolean
Python refers to this data type as bool
A boolean expression is an expression whose only possible values are true and false
There are two boolean literals
- True
- False
Notice the capitalization

Relational Operators

Boolean expressions are often created using relational operators
Relational operators compare two values and return true or false depending on their relationship

Here are the relational operators

Operator	Meaning
>	Greater than
<	Less than
>=	Greater than or equal to
<=	Less than or equal to
==	Equal to
!=	Not equal to

Notice that we test for equality using == not =

Precedence of Relational Operators

All the relational operators have lower precedence than the arithmetic operators
So + will be evaluated before >

The order of precedence is

**	Exponentiation
* / // %	Multiplication, division and remainder
+ -	Addition and subtraction
> < >= <= == !=	Relational Operators

Control Structures

Control structures are features of a language that allow the interpreter to take different paths through the code

`if` Statements

The if statement evaluates a boolean expression
If it is true, the following code block will be executed

It has the following format

if BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

If the boolean expression is true all the indented statements below it will be executed
Otherwise the statements will be skipped

`if`-`else` Statements

An if statement will only run the code block o if the boolean expression is true
If the expression is not true, the interpreter skips over the indented statements
If you wanted to write a Python statement that did one thing if the expression were true
And something else if it were false, you would use an if-else statement

It has the following format

if BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...
else:
    STATEMENT
    STATEMENT
    ...

If the boolean expression is true the indented statements following the if clause are executed
Otherwise the indented statements after the else clause are executed

Indentation in the `if`-`else` Statement

Both an if statement and and if-else statement must be indented properly
In an if-else statement both the if and else clauses must be aligned
All the statements under these two clause headings must be intended one tab stop

If all the statements after the if and else are not exactly aligned, you will get an error

>>> if 4 > 3:
...   print("4 is ")
...     print("greater than 3")
  File "<stdin>", line 3
    print("greater than 3")
    ^

Nested `if` Statements

You a have and if statement inside another if statement
This is called a nested if statement

For example, the following code will tell you whether you can take IT 443

$ cat it443.py 
# determines whether a student can take IT 443
# demonstrates nested if statements

print("This program will tell you if you can take IT 443")
answer = input("Have you taken IT 244 (y/n)? ")
if answer == "y":
    answer = input("Have you taken IT 341 (y/n)? ")
    if answer == "y":
        print("You can take IT 443")
    else:
        print("You must take IT 341 before you can take IT 443")
else:
    print("You must take IT 244 before you can take IT 443")

$ python3 it443.py 
This program will tell you if you can take IT 443
Have you taken IT 244 (y/n)? y
Have you taken IT 341 (y/n)? y
You can take IT 443

`if`-`elif`-`else` Statements

An if-elif-else statement lets you test for many conditions

Here is the format

if BOOLEAN_EXPRESSION_1:
    STATEMENT
    ...
elif BOOLEAN_EXPRESSION_2:
    STATEMENT
    ...
elif BOOLEAN_EXPRESSION_3
    STATEMENT
    ...
...
[else:
    STATEMENT
    ...]

The [ ] around the else clause means that it is optional
The keyword elif is short for "else if"
Notice that all the conditions line up vertically

Logical Operators

Each data type has its own set of operators
Logical operators work on boolean values and produce boolean results
The logical operators are
- and
- or
- not
The and operator returns true if both its operands are true
```
>>> 5 > 4 and 4 > 2
True
```
If either of its two operands are false, and returns false
```
>>> 5 > 4 and 4 < 2
False
```
It also returns false if both its operands are false
```
>>> 5 < 4 and 4 < 2
False
```
The or operator returns true if either of its operands are true
```
>>> 5 > 4 or 4 < 2
True
```
It only returns false if both of its operands are false
```
>>> 5 < 4 or 4 < 2
False
```
The not operator takes only one operand and reverses its value
So true becomes false
```
>>> not 5 > 4
False
```
and false becomes true
```
>>> not 5 < 4
True
```
To show how the logical operators work we use truth tables
Here is the truth table for and

p q p and q

true true true

true false false

false true false

false false false
The truth table for or

p q p or q

true true true

true false true

false true true

false false false
And the truth table for not

p not p

true false

false true

p	q	p and q
true	true	true
true	false	false
false	true	false
false	false	false

p	q	p or q
true	true	true
true	false	true
false	true	true
false	false	false

p	not p
true	false
false	true

Precedence of Logical Operators

The logical operators, and, or and not have lower precedence than arthmetic operators

They are also lower than the relational operators

**	Exponentiation
* / // %	Multiplication, division and remainder
+ -	Addition and subtraction
> < >= <= == !=	Relational Operators
and or not	Logical per Operators

Loops

A loop repeats a number of statements
There are two types of loops
- Loops controlled by counting
- Loops controlled by some con dition
In loops that are controlled by counting, the loop repeat a certain number of times
In loops controlled by a condition the code will keep looping as long as some condition is true

While Loops

A while loop has the following format

while BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

The loop runs as long as the boolean expression is true
The boolean expression in a while loop is evaluated before entering the loop
This means it is possible that the statements in the code block will never be executed

Infinite Loops

If the boolean expression in a while loop does not become false ..
the loop will go on forever
This is called an infinite loop
On Unix, you stop an infinite loop by hitting Control C

`for` Loops

The for loop has the following format

for VARIABLE_NAME in LIST
    STATEMENT
    STATEMENT
    ...

The first value in the list is assigned to the loop variable
The variable keeps that value while passing through the code block
When execution of the code block ends, the next value in the list is assigned to the variable
This continues until all values are used

The `range` Function

The range function is used to create a list of integers in a for loop
It can take 1, two or three arguments
With 1 argument the list goes from 0 to one lessthan the argument
```
>>> for number in range(5):
... print(number)
...
0
1
2
3
4
```
With two arguments, the 1st gives the starting value

And the 2nd argument is one more than the last number

>>> for number in range(1, 5):
... print(number)
...
1
2
3
4

The 3rd argument is the step value

It is what is added to each number to get the next

>>> for number in range(2, 11, 2):
...  print(number)
... 
2
4
6
8
10

Running Totals

A total that is updated as new numbers are encountered is called a running total
A good example of a running total in everyday life is a bank balance
Your bank balance is the running total of all deposits and withdrawals from your account
In programming, running totals are calculated using a variable called an accumulator
This is followed by a loop in which new numbers are added to the accumulator
Before you enter the loop, the accumulator must be set to 0

Running totals are used when you calculate averages

$ cat average.py 
# this program asks the user how many numbers
# they have to enter, then performs a running
# total and computes the average

entries = int(input("How many entries? "))
total = 0
for entry_no in range(entries):
    number = int(input("number: "))
    total +=  number
average = total / entries
print("Average", average)

$ python3 average.py 
How many entries? 10
number: 10
number: 9
number: 8
number: 7
number: 6
number: 5
number: 4
number: 3
number: 2
number: 1
Average 5.5

Augmented Assignment Operators

we often have to change the value of a variable by some amount
If we wanted to add 5 to the variable num we could write
```
number = number + 5
```
Statements like this happen all the time, so most computer languages have a special operator for this
Instead of writing the statement above we could write
```
number += 5
```
This operator works as follows
- Get the current value of the variable on the left
- Get the current value of the expression on the right
- Add the two values
- Assign this new value to the variable
An operator like this is called an augmented assignment operator

Python has an augmented assignment operator for every arithmetic operator

Operator	Example	Equivalent To
+=	numb += 5	numb = num + 5
-=	num -= 5	num = num - 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
//=	x //= 5	x = x // 5
%=	x %= 5	x = x % 5
**=	x **= 5	x = x ** 5

Nested Loops

You can nest any type of loop inside another loop
But nested for loops are the most common

Here is a nested for loop that creates a times table

$ cat times_table.py 
# This script creates a times table using nested for loops

for row in range(1, 11):
    for column in range(1, 11):
        entry  = row * column
        print(entry, end="\t")
    print()

$ python3 times_table.py 
1       2       3       4       5       6       7       8       9       10
2       4       6       8       10      12      14      16      18      20
3       6       9       12      15      18      21      24      27      30
4       8       12      16      20      24      28      32      36      40
5       10      15      20      25      30      35      40      45      50
6       12      18      24      30      36      42      48      54      60
7       14      21      28      35      42      49      56      63      70
8       16      24      32      40      48      56      64      72      80
9       18      27      36      45      54      63      72      81      90
10      20      30      40      50      60      70      80      90     100

With each pass through the outer loop, the loop variable row gets a new value
It keeps that value while the inner loop variable column changes from 1 to 10

Functions

A function is a group of statements that has a name and performs a specific task
Some functions are written inside the Python interpreter
- print
- int
- round
They are called built-in functions
But you can define your own Python functions
You can also create files called modules that contain a number of functions
You can then use an import statement to bring these functions into any Python script

Two Types of Functions

There are two types of functions
- Functions that return a value
- Functions that do not return a value
The textbook calls the second type of function a void function
The conversion functions like str, int and float return a value
print does not return a value

Defining a Function

A function definition has the following format

def FUNCTION_NAME([PARAMETER, ...]):
    STATEMENT
    STATEMENT
    ...

The first line of a function definition is called the function header
There are four parts to the function header
- The keyword def
- The function name
- The parameter list enclosed in parentheses
- A colon, :, at the end of the line
All of these must be present though the parameter list might be empty
Even if the function has no parameters it must still have parentheses
Following the function header is a series of indented statements that form a code block
These statements are executed when the function is called

Calling a Function

To run a function you make a function call function call
A function call has two parts
- The function name
- A list of arguments enclosed in parentheses
You must follow the function name with parentheses even if the function takes no arguments

Local Variables

Any time you create a variable inside a function you are creating a local variable
A local variable created inside a function can only be used inside that function
The variable only exists while the function runs
This means the variable is invisible outside the function
Outside the function, the local variable does not exist
Local variables defined in one function are invisible to other functions
This means we can use the same variable name in more than one function
Another way of saying this is that the scope of a local variable is the function in which it is defined

Parameters

Parameters are a special kind of local variable
They are defined in the function header inside the parentheses
Parameters get their value from the corresponding argument in the function call
Like other local variables, they disappear after the function ends

Today's Topics

Review

Homework 7

Mid-term

Review

Strings and String Literals

Characters

Comments

Variables

Creating Variables with Assignment Statements

Expressions

Variable Naming Rules

Numeric Data Types and Literals

The input Function

Performing Calculations

Decimal and Integer Division

Exponent Operator

Remainder Operator

Operator Precedence

Grouping with Parentheses

Escape Characters

Concatenation Operator

Boolean Expression

Relational Operators

Precedence of Relational Operators

Control Structures

if Statements

if-else Statements

Indentation in the if-else Statement

Nested if Statements

if-elif-else Statements

Logical Operators

Precedence of Logical Operators

Loops

While Loops

Infinite Loops

for Loops

The range Function

Running Totals

Augmented Assignment Operators

Nested Loops

Functions

Two Types of Functions

Defining a Function

Calling a Function

Local Variables

Parameters

The `input` Function

`if` Statements

`if`-`else` Statements

Indentation in the `if`-`else` Statement

Nested `if` Statements

`if`-`elif`-`else` Statements

`for` Loops

The `range` Function