IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 8

Microphone

Homework 4

I have posted homework 4 here.

It is due this coming Sunday at 11:59 PM.

Quiz 2

I have posted the answers to Quiz 2 here.

Questions

Are there any questions before I begin?

Tips and Examples

Use Tabs in a Code Block

A code block is a group of statements that are only executed under certain conditions
All control structures use code blocks
There are two ways to indent a code block
- Spaces
- Tabs
You a free to use either one
But you cannot mix tabs and spaces within a code block
If you do you will get an IndentationError
Why?
Because the Python interpreter checks each line in a code block
It wants to see some whitespace at the start of the line
If it does, it goes on to the next line ...
where it expects to see the same whitespace characters
If you mix tabs and spaces, it may look OK to you
But Tab and Space are different characters ...
because they have different Unicode numbers
To prevent indentation errors, follow a simple rule
Always use Tabs to indent code blocks

Look at the following code

num = int(input("Number: "))
if num % 2 == 0:
    print(num)
    print('This number is even')

It looks fine but when I run it I get

$ python3 indent_test.py
  File "indent_test.py", line 5
    print('This number is even')
                               ^
IndentationError: unindent does not match any outer indentation level

It looks like the both lines are indented the same amount
But that is not what the interpreter thinks
I used 4 Spaces to indent the first line in the code block
But I used one Tab in the second
This is the kind of error that can drive you crazy
Because the indentation looks good to our eyes
To avoid this problem you need to be consistent
You can indent with one Tab character
Or you can indent with many spaces
It is simpler to use Tabs

Misleading Error Messages

If your code violates the rules of Python you will get an error message
Errors of this type are called syntax errors
The interpreter is good at spotting these errors
But it isn't always good at telling you where the problem is
The most important thing an error message tells you ...
is that your code does not work
Interpreters run through your code expecting certain things
When the interpreter sees a " at the beginning of a string literal ...
it expects to see another " at the end
When the interpreter sees a ( ...
it expects a following )
If it does not see the character on one line, it looks at the next
This means that the error message sometimes give you the wrong line number
The error occurs on one line where you are missing a " or )
But the interpreter does not realize it until it gets to a following line
Here is an example from a student's homework script

When I ran the code I got the following

$ python3 hw4.py
  File "hw4.py", line 4
    print("Your score is ", score)
        ^

Line 4 of the code was
```
print("Your score is ", score)
```
There is nothing wrong with this line

But there is with the line above it

score = int(input("What is your score? ")

If you look carefully you will see that there are two left parentheses, ( ...
but only one right parenthesis, )
If you can't see the error on one line ...
look at the line above
Unclosed parentheses are often a problem
For every ( there should be a )
There is a trick for spotting this
You count the number of parentheses in a special way
Start with 0
Every time you come across a ( add 1
Every time you come across a ) subtract 1
Should should end up with 0

Review

Control Structures

Python, like most computer languages, has control structures
Control structures allow the interpreter to take different paths through the code ...
depending on certain conditions
The order in which the statements of a script are executed is called path of execution ...
or the flow of control
Without control structures programs could not do much
They could only start at the top of the scripts
And proceed line by line to the bottom

Two Types of Control Structures

There are two major types of control structure
- Conditionals
- Loops
Conditional are like a fork in the road
You come to a certain point and you have to decide which path to take
If you take one path ...
you do not take the others
Loops allow you repeat a number of statements many times
Both are very useful ...
and appear in most scripts

`if` Statements

The if statement allows certain statements to be executed
if a certain condition is true
That condition is represented by a boolean expression

A simple if statement has the following format

if BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

If the BOOLEAN_EXPRESSION is true the indented statements are executed
Otherwise the statements will be skipped

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 can only be true or false
There are two boolean literals
- True
- False
Notice the capitalization
The function bool will covert its argument to a boolean value
It will convert any number that is not 0 to True
It will convert the empty string to False
And any other string to True

Relational Operators

Boolean expressions are often created using relational operators
Relational operators compare two values ...
and return True or False depending on their relationship

The relational operators are

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 =
This is a common mistake that you will probably make many times

Precedence of Relational Operators

All the relational operators have lower precedence ...
than the arithmetic operators

The order of precedence is

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

`if`-`else` Statements

A simple if statement runs the code block statements ...
if the condition is True
It skips over the code block if the condition is False
An if-else statement executes one code block if the condition is True ...
and another code block if it is False

It has the following format

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

Indentation in the `if`-`else` Statement

Both an if statement and and if-else statement must be indented properly ...
or they will not work
All the statements in a code block must indented the same ...
using the same characters
It is best to indent with a Tab character

Comparing Strings

It is easy for a computer to compare two strings
The computer looks at the Unicode value for the first character in each string
If they are the same it keeps going until the numbers are different ...
or one string is shorter than the other
In that case the shorter string is less than the longer
```
>>> "mark" < "marker"
True
```
This is the way a dictionary works
But computers can sort on strings of any character
Not just letters

Nested `if` Statements

An if statement can contain another if statement
This is called a nested if statement
Situations that required nested if statements occur frequently

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

Testing a Series of Conditions

Sometimes you have test more than one condition
A program to turn scores into a letter grade is one example

Here is one such program

$ cat grade.py 
# this programs turns a score into a letter grade
# it demonstrates using nested if statements
# to test for many possible conditions

score = int(input("What is your score? "))
print("Grade", end=" ")
if score >= 90:
    print("A")
else:
    if score >= 80:
        print("B")
    else:
        if score >= 70:
            print("C")
        else:
            if score >= 60:
                print("D")
            else:
                print("F")

$ python3 grade.py 
What is your score? 80
Grade B

$ python3 grade.py 
What is your score? 60
Grade D

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

The code above will work
But it is a little hard to read
Notice how the code keeps shifting to the right of the page
Python has a different kind of if statement for these situations
It is the if-elif-else statement

It has this format

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

The [ ] around the else clause indicates that it is optional
The keyword elif is short for "else if"
Notice that all the conditions line up vertically
This makes is clear that each condition has the same level of importance

Here is the grade program rewritten to use the if-elif-else statement

$ cat grade2.py
# this program turns a score into a letter grade
# it demonstrates the if-elif-else statement

score = int(input("What is your score? "))
print("Grade", end=" ")
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
elif score >= 60:
    print("D")
else:
    print("F")

$ python3 grade2.py
What is your score? 50
Grade F

Attendance

New Material

Logical Operators

Each data type has its own set of operators
The arithmetic operators
- +
- -
- *
- /
- //
- %
work on numbers
The result is also a number
The relational operators
- >
- <
- >=
- <=
- ==
- !=
work on numbers and strings ...
but they give a boolean result
Logical operators are operators work on boolean values ...
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
Truth tables have multiple columns
The first one or two columns are values of boolean variables
The last column shows the boolean result of running the operator on the values

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`

Short-Circuit Evaluation

Let's say you your code has the boolean expression
```
a > b  and c > d
```
And say the a is not greater than b
Then the entire expression will be False ...
even if c is greater than d
Because both operands must be True for and to return True
Similarly, if we have the expression
```
a > b  or c > d
```
And a is greater than b ...
or will return True ...
no matter what the relationship between c and d
Because only one operand needs to be True for or to return True
In both cases the second operand cannot change the result
So Python will not evaluate the second expression ...
because it cannot change the result
This is called short-circuit evaluation
Also know as lazy evaluation
This makes the interpreter more efficient
But it can be helpful to a programmer under certain situations

Checking Numeric Ranges with Logical Operators

An important idea in programming is data validation
The idea is to check your data for problems before you use it
For example, a program might need to know a person's age ...
in order to calculate retirement benefits
The user should enter something like
```
35
```
Not
```
thirty-five
```
Similarly, the age could not be 3 or 200
The program should look for mistakes like these ...
In this case, we might want to make sure that the values were between 18 and 65
When we need to determine whether a value is inside a range
we use the and operator
```
if age >= 18 and age <= 65:
```
If we wanted to determine whether a value is outside a range
we use the or operator
```
if age < 18 or age > 65:
```
Python allows us to write the first condition in a much shorter way
```
if 18 <= age <= 65:
```
The boolean expression
```
18 <= age <= 65
```
Is the same as writing
```
18 <= age  and  age <= 65
```
In other words the and operator is implicit

Precedence of Logical Operators

When we write an expression like
```
a + b > c and c * d < a
```
there are three different kind of operators
- Arithmetic - +, *
- Relational - >, <
- Logical - and
operator precedence determines which operators are used first
The logical operators are and, or and not
They have lower precedence than arithmetic operators
They also have lower precedence than the relational operators

The order of precedence is

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

Notice that each logical operator has its own unique position ...
in the precedence hierarchy
So not has higher precedence than and
And and has higher precedence than or

Boolean Variables

A variable is a place in memory with a name ...
that holds a single value
If the value a variable holds is True or False
It is a boolean variable
Boolean variables are often used as flags
A flag represents a certain condition in a program
Flags can make a program much more readable

For example a program to compute the price of a ticket might look like this

if age < 18:
    minor = True
else:
    minor = False
if age >= 65:
    senior = True
else:
    senior = False

You could then use the flags minor and senior later in the program
Actually there is a shorter way to achieve the same results
```
minor  = age < 18
senior = age >= 65
```
The expressions on the right are both boolean expressions
Normally you would set a flag if you wanted to check a condition more than once
But even if you only use a flag once ...
it will make the code more readable

Compare these two versions of the a script that calculates ticket prices

$ cat tickets_1.py
# this program calculates ticket prices

age = int(input("What is your age? "))

if age < 18:
    print("Your ticket will cost $10")
elif age >= 65:
    print("Your ticket will cost $15")
else:
    print("Your ticket will cost $25")

$ cat tickets_2.py
# this program calculates ticket prices

age = int(input("What is your age? "))
minor  = age < 18
senior = age >= 65
if minor:
    print("Your ticket will cost $10")
elif senior:
    print("Your ticket will cost $15")
else:
    print("Your ticket will cost $25")

Keep Your Code Short

One of the rules of good writing is that shorter is better than longer
That's because a reader's attention is not infinite
People will only pay attention for so long ...
before turning away
The same is true with code
Look at the ticket script above

Notice that each if clause has the string "Your ticket will cost"

if minor:
    print("Your ticket will cost $10")
elif senior:
    print("Your ticket will cost $15")
else:
    print("Your ticket will cost $25")

If you think about it, the real work of the if statement is to set ticket price
Printing the message is a different task
We can make the code shorter by setting the variable price ...
inside an if-elif-else statement ...

then using the variable in a single print statement

age = int(input("What is your age? "))
minor  = age < 18
senior = age >= 65
if minor:
    price = 10
elif senior:
    price = 15
else:
    price = 25
print("Your ticket will cost $" + str(price))

Why did I use concatenation in the print statement instead of giving print two arguments?
With two arguments there would have been a space in the output
It would appear between $ and the price

Studying

Keep Each Study Period Short