IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 14 - Midterm Review

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 Sequences
Concatenation Operator
Boolean Expression
Relational Operators
Precedence of Relational Operators
Control Structures
Code Blocks
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 it is due Sunday, October 29th.

This is to give you time to study for the midterm.

And to give me time to score it.

Midterm

The Midterm exam for this course will be held on Tuesday, October 24th.

The exam will be given in this room.

It will consist of questions like those on the quizzes along with questions asking you to write short segments of Python code.

60% of the points on this exam will consist of questions from the Ungraded Class Quizzes.

There will be 15 of these questions worth 4 points each.

The other 40% will come from four questions that ask you to write a short segment of code.

Each of the code questions is worth 10 points each.

To study for the code questions you should be able to

Write an if/elif/else statement
Write a while loop
Write a for loop using range
Write a function that does not return a value

A good way to study for the code questions is to review the Class Exercises and homework solutions.

If for some reason you cannot take the exam on the date mentioned above you must contact me to make alternate arrangements.

Today's will be a review session.

You will only be responsible for the material in the Class Notes for today on the exam.

The Midterm is given on paper.

I scan each exam paper and upload the scans to Gradescope.

I score the exam on Gradescope.

You will get an email from Gradescope with your score when I am done.

The Midterm is a closed book exam.

You are not allowed to any resource other than what is in your head while taking the exam.

Cheating on the exam will result in a score of 0 and will be reported to the Administration.

Remember your Oath of Honesty.

To prevent cheating, certain rules will be enforced during the exam.

Quiz 5

Let's look at the answers to Quiz 5.

No Class Exercise or Class Quiz

Today is a review session.

There will no Class Exercise or Class Quiz today.

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 of the world's writing systems

Comments

A comment is text written inside a program
That is not read by the interpreter
Comments describe how the program works
Any text on a line after a hash mark, #, is ignored by the interpreter
```
>>> print("Hello") # but ignore this text
Hello
```

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 with operators
- 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

Python recognizes two types of numbers
- Integers (int)
- Decimals ( float)
The integers are the whole numbers
They can be positive and negative
Decimals can also be positive and negative
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 gets a value from the user
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 you want the value to be a number
You must 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 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
```
/ always returns a float
// division always return a whole number (int)
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 rules 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 Sequences

The non printing characters
- Space
- Tab
- Newline (Return or Enter)
Are called whitespace characters
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 literal you need a special way to represent them
You do this using two characters
The first is a \
Followed by another character
Such combinations are called escape sequences

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 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
Depending on the conditions when the code is run
All control structures use code blocks
A code block is a series of statements that are only executed under certain conditions
All the statements in a code block are indented the same amount
Using the same characters

Code Blocks

A group of statements that are only executed under certain conditions is called a code block
All control structures use code blocks
A code block in Python is created by indenting a group of statements
All statements in a code block must be indented the same amount

`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 in the code block will be executed
Otherwise the statements will be skipped

Attendance

`if`-`else` Statements

An if statement will only run the statements in the code block
If the boolean expression is True
If the expression is not True, the interpreter skips over the indented statements
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 expression is True
The statements in the code block following the if clause are executed
Otherwise the statements in the code block 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
An if-else statement has two clauses
- An if clause
- An else clause
Both clauses must be indented the same amount
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 valuess
And produce a boolean result
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	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
not	Logical NOT
and	Logical AND
or	Logical OR

Loops

A loop repeats the statements in its code block
There are two types of loops
- Loops controlled by counting
- Loops controlled by some condition
Counted loops repeat a certain number of times
Conditional loops repeat 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 is evaluated before entering the loop
So 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 one, two or three arguments
With one argument the list goes from 0 to one less than the argument
```
>>> for number in range(5):
...    print(number)
...
0
1
2
3
4
```
With two arguments, the first gives the starting value

And the second argument is one more than the last number

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

The third 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 is a bank balance
Your bank balance is the running total of all deposits and withdrawals from your account
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
The accumulator must be set to 0
Before you enter the loop

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

Often we need to change the value of a variable by a specific 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 multiplication 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
The parameter list might be empty
But the header must still have parentheses
Following the function header is a code block
The statements in the code block 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
The values inside the parentheses are called arguments
The value of each argument is assigned the the corresponding parameter
You must always have parentheses, (), after the function name
Even if the function takes no arguments

Local Variables

A variable created inside a function is a local variable
Local variables only exists while the function runs
A local 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
The section of a script where a variable is defined is called its scope
The scope of a local variable is the code block 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 when the function ends

Review

Homework 7

Midterm

Quiz 5

No Class Exercise or Class Quiz

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 Sequences

Concatenation Operator

Boolean Expression

Relational Operators

Precedence of Relational Operators

Control Structures

Code Blocks

if Statements

Attendance

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