IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 5

Microphone

Questions

Are there any questions before I begin?

Homework 3

I have posted homework 3 here.

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

Today's Class

Today I'll talk about operators and how to use different data types in calculations

General Advice

Learn to Read Carefully

Most of us spend a large part of each day reading
Most of this reading is done quickly ...
because the material is familiar ...
and the details are not that important
Most of the time we read, we know what to expect
For example, if you get text from a friend ...
you don't linger over each word
You have some idea of what your friend is going to say ...
so you can read it quickly
The same thing happens if you read the about your favorite singer
The details aren't important ...
just the overall picture
The reading you must do for this course ...
is fundamentally different
Technical work is detailed work
If you read technical material too quickly ...
you will miss important details
You must learn to read technical material slowly and carefully
You will sometime have to read something a second or third time ...
until you fully understand it
Learning how to read technical material ...
may be the most important thing you take away from this class

Course Work

Graded Quiz Today

After I finish my lecture today I will hand out papers for today's graded quiz
Write your name clearly at the top
When you finish the Quiz hand it to me
Then you can work on the Class Exercise

Late Penalty

You will lose 2 points for every day that your assignment is late
Every Unix file has a time stamp that changes every time the file is modified
My scripts look at this date stamp to determine whether a submission is late
If your assignment is not working by the due date ...
you can continue to work on it ...
but you will lose a few points
If your assignment is working, do not go back and change it
Any changes you make will change the date stamp ...
which will cost you points

Do Not Email Me about Missing Assignments

If you get an email from me saying an assignment is missing
do not email me about this
I get far too many emails
Instead of sending me an email, fix the problem
If you do not know how to fix it
- Come to Zoom Office Hours
- Post a question of Piazza
- Contact the Class Assistant
I collect homework assignments and check Class Exercises several times during the week
I will check or collect your assignment later in the week.

Importance of Exams

Many people find exams difficult
But the best way for me to know if you have really learned the material is by giving exams
It is too easy to cheat on Class Exercises and homework assignments
This is why the two exams account for 50% of your grade
Too many students do well on the graded quizzes, Class Exercises and homework assignment ...
only to do poorly on the exams
This lowers their grade considerably
The purpose of the Class Exercises and homework assignments is to give you hands on experience with the material
And to better prepare you for the exams

Preparing for Exams

Both the midterm and final exams follow the same format
60% of the points on the exams come from questions taken from the ungraded class quizzes
The remaining 40% of the points come from 4 code questions
These questions ask you to write short segments of Python code
Two things will help you prepare for exams
- Flash cards
- Class Exercises and homework assignments
Flash cards should be made for all questions from Ungraded Class Quizzes
You should review them frequently throughout the semester
Pay attention when you are working on the Class Exercises and homeworks
Work on these assignments is teaching you how to write Python code
This will come in handy for answering the code questions on the midterm and final

Tips and Examples

Do Not Fall Behind in This Course

Technical courses require that you master a great deal of detail
You will need to study for this course several times during the week
Studying once a week is usually not enough
The key to success in a technical course is steady, consistant, work
It should be spread out over several days
Some important concepts do not sink in immediately
It may take several days for something new to become clear
Material in this course often depends on what came before
So it is critical that you not fall behind
If you fall behind, it can be VERY hard to catch up

Read the Homework Assignments Carefully

Homework assignments may ask you to do many things
So you may need to read the assignment more than once
A single reading might not be enough to understand what I want you to do
Take the time to read these documents slowly
This will help you understand all the details
If you don't, you will make mistakes and lose points
Technical work is detailed work
So you must learn to read documents with a lot of detail
If you do not understand something post a question on Piazza
NEVER GUESS at the meaning of something I have written

Representation of Data

Python has different data types for different kinds of values
Each data type has a different way of storing its value in memory
The string "5" appears in memory as the binary number 110101 ...
which is 53 in decimal ...
and is the number associated with the Unicode symbol "5"
The integer 5 appears as the binary number 101
The data type of a value determins what you can do it with
You can use an integer in arithmetic
But you can't do that with a string

Review

Expressions

Whenever we need a value in Python, we write an expression
An expression is anything that can be turned into a value
There are four different kinds of expressions
- Literals
- Variables
- Calculations involving operators
- Function calls
There are two places where expressions frequently occur
- Assignment statements
- As arguments in a function call
Whenever you need a value you can use any of the four kinds of expression
```
print("Hello")
print(rate)
print(total + 10)
print(round(5.3))
```

Comments

When you write a program you understand its different parts
But will you remember what each part does a year from now ...
when you need to change it?
A program should be readable
That means that anyone who knows Python should be able to understand it
There are many ways to make a program readable
But one of the most important is to use comments
A comment is text written inside a script
that is not read by the interpreter
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 comment that spans several lines ...
each line must begin with a #

Variable Naming Rules

Variable names in Python must follow certain rules
- You cannot use keywords as function names
- Function names cannot have spaces
- The first character of a function name must be a letter, a-z or A-Z, or an underscore, _
- After the first character you can use also use digits
- Uppercase and lowercase letters are different
Words that have special meaning to Python are called keywords

Here is the list of Python keywords

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

Python is case sensitive
That means that UPPERCASE letters and lowercase letters are completely different
So value and Value are the names of different variables

Choosing Good Variable Names

You should use variable names that make it clear what value the variable holds
So don't use d to hold the distance traveled
Use the variable name distance instead
Sometimes you need more than one word ...
to describe the value contained in a variable
When this happens, use the underscore character _ ...
to separate words
```
course_id
student_name
first_name
```

Numeric Data Types and Literals

A Python variable can hold many different types of values
- Strings
- Integers
- Decimals
Each of these value types is stored in the computer's memory ...
using a different binary pattern
The technical term for each of these different representations is a data type
When a string is stored in memory, its data type is str
When an integer is stored in memory, it has the data type int
When a decimal is stored, it has data type float
Float is short for floating point
Whenever we write a value directly into a Python statement ...
that value is called a literal
The data type of a value determines what you can do with it
You can add, subtract, multiply or divide integers and floats
But you cannot divide or subtract strings

Conversion Functions

Python has functions that convert from one data type to another

Use int() to convert a value into an integer

>>> type('5') 
<class 'str'>
>>> int('5')
5
>>> type(5)
<class 'int'>

Use str() to convert a value into a string

>>> type(5)
<class 'int'>
>>> str(5)
'5'
>>> type('5')
<class 'str'>

Use float() to convert a value into a float

>>> type('5.3')
<class 'str'>
>>> float('5.3')
5.3
>>> type(5.3)
<class 'float'>

There are some values that cannot be converted

>>> int("five")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'five')

Reading Input from the Keyboard

A Python script can get a value from the user using the input function
input has one argument
That argument is text that will prompt the user for input
input is used in an assignment statement like this
```
LOOP_VARIABLE = input(PROMPT)
```
When the interpreter gets to an assignment statement using input it
- Prints the prompt
- Waits for the user to enter text and hit Enter
- Stores the text entered at the command line into the variable

Here is an example

>>> team = input("Please enter a team name: ")
Please enter a team name: Red Sox
>>> print("Go", team)
Go Red Sox

The text in blue was entered by the user

Notice that I put a space at the end of the prompt string
It's good to have a gap between the prompt and the value entered by the user

Reading Numbers with the `input` Function

The value produced by the input function is always a string

This is true no matter what type of the valuewas entered by the user

>>> number = input("Please enter a number: ")
Please enter a number: 55
>>> type(number)
<class 'str'>

Although the user entered 55 ...
which looks like an integer ...
input returned the string '55'
If you want the value to be some other data type
You have to use a conversion function
To convert the variable number to an integer use the int function
```
>>>  number = int(number)
>>>  type(number)
<class 'int'>
```

Attendance

New Material

Operators

Look at the following Python statement
```
number_2 = number_1 + 5
```
Here we created the varariable number_2 ...
by adding 5 to number_1
+ is the symbol we use for addition
When the Python interpreter sees + ...
it recognizes it as an operator
Operators are special characters that act upon one or more values ...
and perform an action
Usually that action produces 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

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

New Arithmetic Operators

The first 4 operators
- +
- -
- *
- /
should be familiar to you
Though mulitplication uses * instead of × ...
(the symbol × is not the same as the letter x
And division uses / in place of ÷)
Because you won't find × or ÷ on the keyboard
But you may not have come across the last three operators
- //
- %
- **
It turns out we need all 7 operatos ...
to do arithmetic in Python

Normal Division

If I wanted to set the variable result to the value you get by dividing 7 by two ...
I would write the following assignment statement
```
>>> result = 7/2
>>> print(result)
3.5
```
This kind of division is familiar to us
Though / has one strange quirk in Python
/ always returns a decimal value ...

even when the result is an integer

>>> result = 4/2
>>> print(result)
2.0
>>> type(result)
<class 'float'>>

This may seem strange ...
but it actually makes it easier for the interpreter

Integer Division

Remember long division from arithmatic class?
To divide 17 by 3 you would write

Where 5 was the quotient ...
and 2 was the remainder
The // operator gives us the quotient ...
which is the integer part of the answer
So // is integer division
```
>>> 17 // 3
5
```

Remainder Operator

To get the remainder from long division we need the remainder operator %
```
>>> 17 % 3
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, when we divide by 2, the remainder is 0, the number is even
```
>>> 2 % 2
0
>>> 4 % 2
0
>>> 5 % 2
1
```
If, when we divide by 2, the remainder is 1, the number is odd
```
>>> 1 % 2
1
>>> 3 % 2
1
>>> 5 %2
1
```

Exponent Operator

When we raise a number to a power we multiply it by itself ...
a certain number of times
When we multiply a number by itself ...
we get the square of a number
```
>>> 2 * 2
4
>>> 3 * 3
9
>>>
```
When we multiply a number by itself and then itself again ...

we get the cube of a number

>>> 2 * 2 * 2
8
>>> 3 * 3 * 3
27
>>> 4 * 4 * 4
64

** is the exponent operator
The number before this operator is raised to the power of the second number
To get the square of a number we raise it to the 2nd power
```
>>> 2 ** 2
4
>>> 3 ** 2
9
>>> 4 ** 2
16
```
To get the cube of a number we raise it to the 3rd power
```
>>> 2 ** 3
8
>>> 3 ** 3
27
>>> 4 ** 3
64
```

Operator Precedence

We can use more than one operator in a calculation
```
>>> 2 + 3 + 5
10
```
When the operators are all the same ...
the order in which we do the operations does not matter
```
>>> 5 + 3 + 2
10
```
We could start at the left and work to the right
Or start at the right and work to the left
Order doesn't matter if we do addition and subtraction together
```
>>> 2 + 3 - 5
0
>>> -5 + 3 + 2
0
```
We get the same result if we first add 2 and 3 and then subtract 5
Or subtract 5 from 3 and then add 2
But with other combinations of operators the order does matter
What if the calculation was
```
2 + 3 * 5
```
Which operation do we do first?
Do we add 2 + 3 and then multiply by 5?
Or multiply 3 * 5 and add 2?
Running this calculation in Python gives
```
>>> 2 + 3 * 5
17
```
So Python does multiplication first
This is what you were taught in arithmetic class
That you do multiplication or division first
And then addition or subtraction
When I studied arithmetic we learned the phrase "My Dear Aunt Sally"
That stood for
M multiplication
D division
A addition
S subtraction
Whenever an expression has operators of different levels ...
they must be applied in a specific order
This order is called operator precedence
The operator with the higher precedence is used first
Then the operator with the next highest precedence
And so on

The precedence for Python's arithmetic operators is

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

Let's see how this works with the following calculation
```
4 + 3 * 5 ** 2
```
** has the highest precedence so first we raise 5 to the power of 2
```
5 ** 2 = 25
```
Then we multiply this result by 3
```
3 * 25 = 75
```
Then we add 4
```
4 + 75 = 79
```
This is indeed the value that Python gives us
```
>>> 4 + 3 * 5 ** 2
79
```

Grouping with Parentheses

But what if we wanted to evalaute the operators ...
in the order in which they were written?
What if we wanted to first add 4 and 3
Then multiply the result by 5
Then square that result?
We can use operators in an order different from the order of precedence
We do this using parentheses, ( )
To first add 2 + 3 then multiply by 5 we write
```
(4 + 3) * 5 = 35
```
Parentheses are not operators
But they override the normal order of precedence
Calculations inside parentheses must be done first ...
before using operators outside the parentheses
I'm told that nowadays arithmetic teachers no longer use "My Dear Aunt Sally"
Instead they tell their student to remember PEMDAS
P - Parentheses
E - Exponent (raising to a power)
M - Multiplication
D - Division
A - Addition
S - Subtractions
This mnemonic (memory aid) is useful because it includes exponentiation
But parentheses are not operators ...
because they perform no action

Expressions inside Expressions

In the last class I showed you two statements

number = input("Please enter a number: ")
number = int(number)

It turns out that you do the same thing in one statement
```
number = int(input("Please enter an integer: "))
```
This is legal Python because a function call can take any expression as its argument
A function call that returns a value is itself an expression
So the argument to a function call can be another function call
In the statement above the argument to int is a function call to input

Converting Algebra Into Python

You may have noticed that when we write the Python expression
```
a + b 
```
it looks like something you saw in algebra
But there are important difference between Python and algebra
In algebra variable names are always a single letter
It is legal to have a Python variable whose name is a single letter
But it is not good practice
Variable names should say something about the value they hold
There are other differences
In algebra when we write

We mean that the value of a is multiplied by the value of b ...
and that result is in turn is multiplied by the value of c
In Python we would write this as
```
a * b * c
```
Similarly, the algebraic expression

would be written like this in Python
```
12 * 4
```
The following algebraic formula

Would look like this in Python
```
y = 3 * x / 2
```
Similarly the formula

in Python would be
```
a = (x + 12) / (13 * b)
```
Notice that we had to put both the numerator
```
x + 12
```
and the denominator
```
13 * b
```
inside parentheses
We have to calculate the value of each of these expressions before dividing them
This is were the rules of precedence swing into action
The financial formula

Would become the following in Python
```
P = F / (1 + r) ** n
```

General Advice

Course Work

Tips and Examples

Review

New Material

Questions

Homework 3

Today's Class

General Advice

Learn to Read Carefully

Course Work

Graded Quiz Today

Late Penalty

Do Not Email Me about Missing Assignments

Importance of Exams

Preparing for Exams

Tips and Examples

Do Not Fall Behind in This Course

Read the Homework Assignments Carefully

Representation of Data

Review

Expressions

Comments

Variable Naming Rules

Choosing Good Variable Names

Numeric Data Types and Literals

Conversion Functions

Reading Input from the Keyboard

Reading Numbers with the input Function

Attendance

New Material

Operators

New Arithmetic Operators

Normal Division

Integer Division

Remainder Operator

Exponent Operator

Operator Precedence

Grouping with Parentheses

Expressions inside Expressions

Converting Algebra Into Python

Class Exercise

Class Quiz

Reading Numbers with the `input` Function