IT 117: Intermediate Scripting

IT 117: Intermediate Scripting
Class 2

Course Work

Assignments
Submitting Assignments
Working on Assignments
Software for the Class

Python Review

Microphone

Homework 1

I have posted homework 1 here.

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

Unix Account and Class Directory

Some you have not created a class directory and a Unix account.

All work for this course MUST be copied to your class directory

A directory is what you probably call a "folder".

Without a class directory you cannot submit assignments.

If you do not have a Unix account go to http://www.cs.umb.edu/~ghoffman/linux/cs_portal.html#creating_unix_account.

If you do have a Unix account you still need a class directory for this course.

Go to https://portal.cs.umb.edu/accounts/login/ , log in, click the check box for my section of this course, and click submit.

Help with Creating a Unix Account

If you have difficulty creating an account must get help NOW!

You can see me after class or during office hours.

You can contact me on Zoom during office hours.

To see how to do this go here

Whatever it takes, you MUST create a Unix account and a class directory.

Review Classes

This class and the two classes next week will be review classes.

I will cover the material from IT 116 that you need to know for this class.

You should use this period to brush up on your knowledge of Python.

Class Page for IT 116

You may find it useful to look at my materials for IT 116.

I have a web site where I post most of the materials for my courses.

You will find the IT 116 materials at http://96.126.105.215/umb_classes_html/it116_html/class_page_it116.html

I have included this link on the class page for the course.

Go to the index for the Class Notes and search for a topic.

You will find the index here http://96.126.105.215/umb_classes_html/it116_html/class_notes_it116/class_notes_index_it116.html .

Questions

Are there any questions before I begin?

Course Work

Assignments

There are two types of assignments for this course
- Class Exercises
- Homework assignments
In the Class Exercise you simply copy some code into a script
The idea is to give you some practice writing and debugging Python code
For homework assignments you write your own code
There is a Class Exercise for each class
There is one homework assignment each week
All Class Exercises and homework assignments are due on the Sunday after they are assigned
If you miss the deadline you can still submit your scripts until the following Saturday
But you will lose 2 points for each day you are late

Submitting Assignments

You will create the scripts for assignments on your machine
But they must copied to your class directory on pe15.cs.umb.edu
I will only score assignments copied to your class directory on pe15.cs.umb.edu
You will find a link to your class directory in your Unix home directory
In today's Class Exercise you will create two directories in your class directory
- An hw for homework assignments
- An ex directory for Class Exercises
You must create a new directory under hw for each homework assignment
And you must create a new directory under ex or each Class Exercise
If a file is in the wrong directory or has the wrong name you will get a 0 for the assignment

Working on Assignments

Work on class assignments has two phases
In the first phase you will write, test and debug the script on your machine
In the second phase you will move the script to pe15.cs.umb.edu
You should also run your script on the Unix machine to make sure it works

Software for the Class

You need different software for each phase
For the first phase you need to download Python
You will find instructions here
Python comes with a program called IDLE
You can use IDLE to run Python statements and create scripts
The SSH client allows you to log in to a Unix machine
You will need it to make your script executable on the Unix machine
And to test the assignments to make sure they run correctly
If you have a Windows machine see Connecting to a Unix machine from Windows
If you have a Mac see Connecting to a Unix machine from MacOS
You will need FileZilla to copy your script to your class directory
You will find instructions here

Python Review

The Python Interpreter

Python scripts are run inside the Python interpreter
The interpreter reads the lines in a Python script statement by statement
And runs each statement
There are two versions of Python currently in use
- Python version 2
- Python version 3
We will be using Python version 3.5 or greater
It is significantly different from version 2
You can run the Python interpreter on the Unix command line like this
```
$ python3
```
When you do, you are using Python in interactive mode
This gives you a Python command line
On this command line you can enter Python statements

The statement will be run when you hit Enter

$ python3
Python 3.8.10 (default, Jun  2 2021, 10:49:15) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> name = "Glenn"
>>> print(name)
Glenn
>>>

The symbols >>> are a prompt
The prompt is the interpreter's way of telling you it is ready for the next Python statement
Noticed that the command I used to run the interpreter is python3

If you typed python instead you would get the following error message

$ python

Command 'python' not found, did you mean:

  command 'python3' from deb python3
  command 'python' from deb python-is-python3

To exit the interpreter enter
```
exit()
```
If you are running the interpreter on the Unix command line or on a Mac you have another option
Hold down the Control key and hit the D key to quit
We will not be using interactive mode much in this class
But it is useful for experimenting with Python

Python Scripts

All assignments for this class require you to write Python scripts
Python scripts are text files that contain Python statements
To create these files you must use a text editor

Rules for Scripts

Every week I have to score three assignments
- A weekly homework assignment
- Two Class Exercises
This is a great deal of work
In order to speed up the scoring your scripts must follow certain rules
You will find them here
If you do not follow them you will lose points
Read these rules and be sure to follow them

Variables

A variable is a location in the computer's memory that has a name
And stores a single value
In C and Java you must declare a variable before you use it
The declaration must specify what kind of value it can hold
If you try to put the wrong kind of value in a variable you will get an error
This is not true in Python
Or other scripting languages
You can store a string in a Python variable one moment
Then store an integer in it at some time later

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"
```
= is the assignment operator

Data Types

Data comes in different forms
Numbers represent quantities
And strings contain text
You can do different things with different types of data
You can divide numbers
But not strings
Everything inside the computer is a binary number
But each type of data has a different binary format
These different formats represent different data types
The data types we see most often are
- Integers
- Floats
- Strings
- Booleans
Python has functions to convert a value of one type into another
The conversion functions for the above data types are
- int
- float
- str
- bool

So int will try to convert its argument into as integer

>>> value = "5"
>>> type(value)
<class 'str'>
>>> numb  = int(value)
>>> numb
5
>>>  type(numb)
<class 'int'>

Integers and Floats

Computers recognizes two different kinds of of numbers
- Integers
- Floats
Integers are the counting numbers
```
1,2,3,4,5,...
```
Integers are both positive and negative
```
..., -3,-2,-1,0,1,2,3, ... 
```
Floats are decimal numbers
```
0.0, 1.0, 1.5, 1.6, ...
```
They can also be both positive and negative
We will mostly be using integers in this class

Characters

Everything inside a computer's memory is a binary number
To represent a character in memory we need a way to represent them as numbers
We do this with a table of values
Each entry in the table contains a character and the number that stands for that character
Nowadays we use a character table called Unicode
Unicode represents all the characters in most world writing systems
But the numbers in the Unicode table can be represented inside the computer in different formats
These formats are called encodings
And each encoding uses a different number of bits of to represent the number
The most commonly used Unicode encoding is UTF-8
You will find a listing here

Strings and String Literals

In programming, text values are called strings
A string is just a sequence of characters
Whenever we write out a value inside the code it is called a literal
In Python, string literals must be enclosed in either single quotes, ', or double quotes, "
```
>>> team = 'Red Sox'
>>> name = "Glenn Hoffman"
```
It does not matter which you use
As long as the quote at the start of the string is the same as that at the end

Expressions

There are are four ways that we can write a value
We can use a another variable that has already been defined
```
rate = old_rate
```
We can use a literal
```
rate = .04
```
We can use a calculation involving operators
```
rate = old_rate * 3
```
We can call a function that returns a value
```
rate = int(input("Rate: "))
```
The people who design computer languages have a term such things
They are called expressions
An expression is anything that can be turned into a value
There are four different kinds of expressions
- Literals
- Variables
- Calculations using operators
- Function calls

Comments

A comment is text written inside a script that is not read by the interpreter
Comments describe how the program works to people reading the code
In Python, any text on a line after a hash mark, #, is ignored by the interpreter
```
>>> print("Hello") # but ignore this text
Hello
```
Comments can also be useful when debugging code
You can temporarily remove a line of code from a script
All you do is put # in front of it
The line is still there so you can turn it back on by removing the #

Variable Naming Rules

Variable names in Python must follow certain rules
- You cannot use words that have special meaning to Python
- Variable names cannot have spaces
- The first character of a variable name must be a letter, a-z, A-Z, or an underscore, _
- After the first character you can use letters, digits or the underscore
- Uppercase and lowercase letters are different characters
Words that have special meaning to Python are called keywords
You will find a list of Python keywords here
Python is case sensitive
That means that uppercase letters and lowercase letters are completely different characters
So value and Value are the names of different variables
Here are examples of legal variable names
```
rate
rate_1
Rate_1
_rate
```

The following are examples of illegal variable names

guns&roses      # can't use symbols in variable names
guns and roses  # can't use spaces in variable names
1st_try         # can't start a variable name with a digit

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 this 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'>
```

Operators

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

Python has operators for basic arithmetic

Symbol	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	Gives the remainder when dividing one number by another
**	Exponent	Raises a number to a power

All these operators can be used with variables as well as numbers

>>> a = 2
>>> b = 4
>>> a + b
6
>>> a - b
-2
>>> a * b
8
>>> a / b
0.5

Decimal and Integer Division

Python has two division operators
- /
- //
The first works like ordinary division
```
>>> 4 / 2
2.0
>>> 4 / 5
0.8
```
Division with / always returns a float
This is true even if the result ends in .0
I call this decimal or normal division
Division using // division always gives an integer
When the result of the division is positive, any fraction is thrown away
```
>>> 4 // 2
2
>>> 5 // 2
2
```
When the result of the division is negative the result is rounded down to the next next negative integer
```
>>> -4 // 2
-2
>>> -5 // 2
-3
```

Remainder Operator

In long division when you divide one number by another 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
```
We can get the remainder with %
```
>>> 17 % 5
2
```
The remainder operator is sometimes called the modulus operator
You can use the remainder operator to determine whether a number is odd or even
If the remainder when dividing by 2 is 0, the number is even
If the remainder when dividing by 2 is 1, the number is odd

Exponent Operator

** is the exponent operator
The number before this operator is raised to the power of the second operator
```
>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 3 ** 4
81
```

Operator Precedence

What should Python do when you give it the following expression
```
2 + 3 * 5
```
Should it first add 2 to 3 and then multiply the result by 5?
Or multiply 3 by 5 and then add 2?
Python does multiplication first
```
>>> 2 + 3 * 5
17
```
It is doing the same thing that you were taught in arithmetic class
The rules of arithmetic say that certain operations should be performed before others
In computer languages the order in which operations are performed are know as rules of operator precedence
The operator with the highest precedence is always used first
The precedence for Python's arithmetic operators is

** Exponentiation

* / // % Multiplication, division and remainder

+ - Addition and subtraction

Grouping with Parentheses

But what if we wanted to add 2 to 3 and then multiply by 5?
We can do this by putting the expression 2 + 3 inside parentheses
```
>>> (2 + 3) * 5
25
```
Expressions inside parentheses are always evaluated first
Before the rules of precedence are applied

Mixed-Type Expressions and Data Type Conversion

If you multiply two integers, you get an integer
```
>>> 3 * 5
15
```
If you multiply two floats, you get a float
```
>>> 3.0 * 5.0
15.0
```
But what if you multiply an integer by a float?
In Python, you will get a float
```
>>> 3 * 5.0
15.0
```
Here are the rules
- When an operation is performed on two int values, the result will be an int
- When an operation is performed on two float values, the result will be a float
- When an operation is performed on an int and a float, the int value will be temporarily converted to a float and the result of the operation will be a float
An expression that uses operands of different data types is called a mixed-type expression

Escape Characters

Not all characters produce a mark on the screen or page
The following characters are used to put spacing between other characters
- Space
- Tab
- Newline
These characters are called whitespace
Each of these characters has its own key on the keyboard
You type a Newline character by hitting Enter
But what if you wanted to use these characters inside a string?

The space would be no problem

>>> name = "Glenn Hoffman"
>>> name
'Glenn Hoffman'

But if I tried to use a Tab instead of a space Python will object by beeping

Trying to use a Newline is even worse

>>> name = "Glenn
  File "<stdin>", line 1
    name = "Glenn
                ^
SyntaxError: EOL while scanning string literal

That's because these two character have special meaning in Python
We need a special way to include these two characters inside a string
In Python we do this by using escape characters
You type an escape character into a string by pressing two different keys
The first key is the backslash, \
The second is some other character

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

Addition, subtraction, multiplication and division aren't the only operations you can perform in Python
As a matter of fact, each data type has it's own set of operations
The most common operation you can perform between two string is joining them
This is called concatenation

The concatenation operator is +

>>> first = "Glenn"
>>> last  = "Hoffman"
>>> space = " "
>>> name  = first + space + last
>>> name
'Glenn Hoffman'

How does Python know what + means when you use it in an expression?
If both of the operands are numbers it means addition
If both are strings it means concatenation

If one is a string and the other a number you get an error

>>> "Hello" + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

You can't concatenate a string and a number
You need to convert the number into a string
Every data type has it's own set of operators

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
Essentially they answer a question about how two values relate to each other

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
You will probably make this mistake often
I still do

Comparing Strings

How do we compare strings?
The same way we sort words in a dictionary
To compare two strings, Python compares the number codes of the first character
If the two numbers are the same it looks at the next number
It stops when one number is bigger than another
Or one of the strings runs out of characters
In that case the shorter string is less than the longer string
```
>>> "mark" < "marker"
True
```
There is a difference between Python and the dictionary
Dictionaries only list words
Which are strings of letters
Python can compare strings of any characters

That includes digits and symbols

>>> "abc2"> "abc1"
True
>>> "abc@" < "abc#"
False

Uppercase and lowercase letters are represented by different numbers
So capitalization affects how strings are sorted
```
>>> "Sam" == "sam"
False
```

Control Structures

A program is a series of statements
As a program runs, the interpreter moves through the statements in a certain order
The order in which the statements are executed is call the flow of control
Or the path of execution
In simple program the path of execution starts at the first statement
And proceeds directly to the last statement
To allow other paths, languages have things called control structures
There are two types of control structures
- Conditionals
- Loops

`if` Statements

The simplest conditional in Python is the if statement

It has the following format

if BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

The statements following the first line are only run if the BOOLEAN_EXPRESSION is true
Otherwise they are skipped

Code Blocks

All control structures have code blocks
Code blocks are a series of statements that are only executed under certain conditions
In Python you write a code block by indenting the statements from the lines above
The statements in a code block must all be indented the same amount
It is best to use Tabs, not spaces, when indenting code blocks

`if`-`else` Statements

An if statement only provides one alternative path through the code
You either run the statements in the code block or you don't
if-else statements provide two alternative paths
The first code block is run if the boolean expression is true
The second code block is run if it is false

It has the following format

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

Nested `if` Statements

The code block inside an if statement consists of one or more statements
An if statement is a valid Python statement
So we can have one if statement inside another
This is called a nested if statement

Here is an example of a nested if statement

$ 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 to check more than one condition
Think of a program that will turn a score into a grade
You first check whether the score is an A
Then a B
And so on

Here is code that will do that

$ cat grade.py 
# this programs turns a score into a letter grade
# it demonstrates using  nested if statement
# 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
If the code checked for + and - grades the last clause would be way off to the right of the page
There is a third kind of if statement for situations like this
It is the if-elif-else statement

And has the following 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 elif keyword is short for "else if"
Notice that all the if and elif lines line up vertically
This is good because it 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

Logical Operators

Each data type has its own set of operators
Logical operators work on boolean values
And they give 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 ! 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	! p
true	false
false	true

Loops

A loop repeats the statements in its code block a certain number of times
The textbook calls loops repetition structures
There are two types of loops
- Loops controlled by counting
- Loops controlled by some condition
Counted loops stop after a certain number of iterations
Counted loops are sometimes called definite loops
Conditional loops keep going as long as a condition is true
Conditional loops are sometimes called indefinite loops

While Loops

The while loop keeps repeating as long as its boolean expression is true
It is a conditional loop

It has the following format

while BOOLEAN_EXPRESSION:
    STATEMENT
    STATEMENT
    ...

The boolean expression is evaluated before each pass through the loop
If its value is True, the statements in the code block are executed
Otherwise the loop ends
We use a while loop when we don't know the number of times the loop will run

Infinite Loops

A while loop stops when its boolean expression becomes false
If it never becomes false, the loop will go on forever
This is called an infinite loop
When your code goes into an infinite loop you have to abort the program
On Unix and the Mac you do this by hitting Control C

**	Exponentiation
* / // %	Multiplication, division and remainder
+ -	Addition and subtraction

Course Work

Python Review

Homework 1

Unix Account and Class Directory

Help with Creating a Unix Account

Review Classes

Class Page for IT 116

Questions

Course Work

Assignments

Submitting Assignments

Working on Assignments

Software for the Class

Python Review

The Python Interpreter

Python Scripts

Rules for Scripts

Variables

Creating Variables with Assignment Statements

Data Types

Integers and Floats

Characters

Strings and String Literals

Expressions

Comments

Variable Naming Rules

The input Function

Operators

Decimal and Integer Division

Remainder Operator

Exponent Operator

Operator Precedence

Grouping with Parentheses

Mixed-Type Expressions and Data Type Conversion

Escape Characters

Concatenation Operator

Boolean Expression

Relational Operators

Comparing Strings

Control Structures

if Statements

Code Blocks

if-else Statements

Nested if Statements

Testing a Series of Conditions

if-elif-else Statements

Logical Operators

Loops

While Loops

Infinite Loops

Class Exercise

Attendance

The `input` Function

`if` Statements

`if`-`else` Statements

Nested `if` Statements

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