IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class 6

Today's Topics

Reading Assignment

You should read Chapter 3, Decision Structures and Boolean Logic, from our textbook, Starting Out with Python, before next weeks's class.

Homework 3

I have posted homework 3 here.

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

Let's take a look at it.

Tips and Examples

Converting Decimal to Integer

In this week's homework you will use a formula to convert between Fahrenheit and Celsius
The formula you will will create a decimal number
but the assignment asks for an integer
You might be tempted to use the int conversion function
But int converts a decimal to an integer by throwing away the decimal part
This is OK when the decimal is less than .5
```
>>> int(5.3)
5
```
But not when the decimal is greater than .5
```
>>> int(5.9)
5
```
To get the correct result you need to use another function called round
```
>>> round(5.3)
5
>>> round(5.9)
6
```

Review

Performing Calculations

Operators are special characters that act upon one or more values and perform an action
Usually that action is to produce 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

Decimal and Integer Division

Python has two division operators
- /
- //
The first works like ordinary division
```
>>> 4 / 2
2.0
>>> 4 / 5
0.8
```
Notice that the result is always a decimal
Even when the result is a whole number
// division always results in 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 up to the next integer
```
>>> -4 // 2
-2
>>> -5 // 2
-3
```

Exponent Operator

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

Remainder Operator

When we perform long division and divide one number by another 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
```
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 is 0, the number is even
If the remainder is 1, the number is odd

Operator Precedence

When more than one type of operator is used in a calculation the interpreter must decide which to use first
The rules that are used to make this decision are called rules of operator precedence
The operator with the higher 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 time 5 before it adds 2
But what if we wanted a different order?
What if we wanted 2 to be added to 3
And then the result added multiplied by 5?
We can do this if we put the addition inside parentheses
```
>>> 2 + 3 * 5
17
>>> (2 + 3) * 5
25
```
Whenever you are in doubt about the order of precedence you can use parentheses to make your intention clear

Mixed-Type Expressions and Data Type Conversion

If you multiply two integers, you get an integer
```
>>> 3 * 5
15
```
If you multiply two decimals, you get a decimal
```
>>> 3.0 * 5.0
15.0
```
But what if you multiply an integer by a decimal?
In Python, you will get a decimal
```
>>> 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,
  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

Breaking Long Statements into Multiple Lines

Statements are the basic unit of Python programs
A statement can be as long as you like
It's best to have all you statements no longer than a certain width
That way you can read your code without changing the width of the window
You can break a long Python statement into two or more lines

You do this by hitting backslash, \, before hitting Enter

>>> print("To be or not to be. \
... That is the question.")
To be or not to be. That is the question.

New Material

More Expressions inside Expressions

In the last class I talked about using a function call as an argument to another function call
```
number = int(input("Please enter an integer: "))
```
But using an expression inside another expression happens in other places too
It happens with calculations using operators
Look at the following expression
```
rate * balance
```
* is an operator
But what about rate and balance?
They are variables
But variables are expressions themselves
The general format for a calculation is
```
EXPRESSSION  OPERATOR  EXPRESSION
```
Whenever we use a calculation each of the operands are themselves expressions
This means we can write something like this
```
5 + round(value)
```
Or this
```
value_1 + round(value_2)
```
Or even this
```
round(value_1) + round(value_2)
```
Expression appear everywhere in Python statements as they do in most computer programs

Whitespace Characters

Not all characters appear as marks on a page
The Python statement
```
print("Hello")
```
prints 5 characters
But the statement
```
print("Hello world")
```
prints 11 characters, one of them a Space
Space is a perfectly good character
Even though it does not put a mark on the page
Spaces are very important
Canyoureadthisline?
Not easily
Spaces mark the end of one word and the beginning of the next
Spaces are a relatively recent invention
They first appeared in the Middle Ages
The Space is a member of a special group of characters whitespace
These characters do not put a mark on the page
But make the printed characters easier to read
The other two whitespace characters are Tab and newline
The newline character moves the printed output down one line
You type a newline by hitting Enter (PC) or Return (Mac)

Escape Characters

How do you add whitespace characters to a print statement?
With Space, you just hit the space bar on the keyboard
There is a Tab key on your keyboard
But when you use it inside a string literal it just adds many Space characters
That is not the same thing as a Tab
And how are we to go down to the next line in a print statement?

Just hitting the Enter or Return key does not work

>>> print("Line 1
  File "<stdin>", line 1
    print("Line 1
                ^
SyntaxError: EOL while scanning string literal)

The way we write the newline character in Python and most computer languages is
```
\n
```

Like this

print("Line 1\nLine 2\nLine 3")
Line 1
Line 2
Line 3

This is an example of an escape character
An escape character is a single character which is written as two characters
A backslash, \ followed by another character
Another name for this combination of characters is an escape sequence
Escape sequences are used to represent single characters that cannot be written any other way

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

A Windows pathname uses the backslash character \ after the name of each directory
Unix uses a slash, /, instead

To print a Windows pathname we need to use \\

print('The path is C:\\temp\\data.')
The path is C:\temp\data.

We can use the Tab escape character \t ...

to space out text on the screen

>>> print("Monday\tTuesday\tWednesday\tThursday\tFriday")
Monday  Tuesday Wednesday   Thursday    Friday

When you print columns of numbers Tabs come in handy

You can also use Tabs so that values on different lines align properly

$ cat print_06.py 
# uses tabs to align values

print("percent\t", 10)
print("rate\t", 5)

$ python3 print_06.py 
percent  10
rate      5

There are escape characters for single and double quotes, \' and \" ...
This comes in handy when writing a string literal with many quotes
```
>>> print("He said \"It\'s me!\"")
He said "It's me!"
```

Using `print` without Going to a New Line

The print function normally prints its output on one line and moves down to the next

$ cat print_04.py 
# Prints three lines

print("Line 1")
print("Line 2")
print("Line 3")

$ python3 print_04.py 
Line 1
Line 2
Line 3

The print function normally adds the newline character to the string you give it as an argument
But you can tell print not to add this newline character at the end
Or you can tell it to print some other character instead of newline
To do this you have to give print a special kind of argument
Normally an argument to a function is an expression like
```
5
a
a * 6
```
But in certain situations you can give an argument in a different way
This different form looks like an assignment statement
I will explain this in more detail in a later class
For now here is what you need to know
If you want print to supply another character instead of newline you write something like this
```
end=" "
```

If we run the following script

$ cat print_02.py 
# Prints a single line

print("Line 1", end=" ")
print("Line 2", end=" ")
print("Line 3")

we get

$ python3 print_02.py 
Line 1 Line 2 Line 3

You can also tell print to add nothing at the end
You do this by setting end to the empty string ""

The empty string is the string with no characters

$ cat print_03.py 
# Prints a single line

print("Line 1", end="")
print("Line 2", end="")
print("Line 3")

$ python3 print_03.py 
Line 1Line 2Line 3

The empty string is a perfectly good string
It just contains no characters
It's like 0 for strings

You can use more than one character as the value of end

$ cat print_04.py 
# Prints a single line

print("Line 1", end="---")
print("Line 2", end="---")
print("Line 3")

$ python3 print_04.py 
Line 1---Line 2---Line 3

`print` Item Separator

If you give print more that one argument to print it will add a Space between each value
```
>>> print(1, 2, 3, 4, 5)
1 2 3 4 5
```
You can change the character automatically added between each printed argument.
This is done using a technique similar to the one above
Here the argument name is sep
So we can change the space between values to a comma like this
```
>>> print(1, 2, 3, 4, 5, sep=",") 
1,2,3,4,5
```
We can also use more than one character as a separator
```
>>> print(1, 2, 3, sep=", ")
1, 2, 3
```

You can also use both sep and end in the same print statement

$ cat print_05.py 
# Prints a single line

print(1, 2, sep=", ", end="---")
print(3, 4, sep=", ", end="---")
print(5)

$ python3 print_05.py 
1, 2---3, 4---5

I will never ask you a question about the end or sep arguments on an exam

Concatenation Operator

In the last class we introduced the arithmetic operators
These operators work on vales that are integers or decimal numbers
Different operators work on different data types
That's because an operation that makes sense in one data type may not make sense in another
Dividing two numbers make sense
But not dividing two strings
The most common operation performed on strings is to take two strings and join them
This is called concatenation

The concatenation operator in Python is +

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

The arguments of the first print statement are a string literal and a variable
The second print statement has one argument
The argument the expression formed by the concatenation of a string literal and a variable

Concatenating Strings with Numbers

When you give the print function a number it has to convert it into a string in order to print it
```
>>> value = 5
>>> print("The value is", value)
The value is 5
```
But you have to be careful when using the concatenation operator + in an argument
The values on both sides of the + must be strings

If they are not, you will get an error

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

The concatenation operator only works with strings

so this works

>>> balance = "1000"
>>> print("The balance is " + balance)
The balance is 1000

because balance is a string

But this does not

>>> balance = 1000
>>> print("The balance is " + balance)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

In order to use a number in concatenation, you have to convert it into a string with str
```
print("The balance is " + str(balance))
The balance is 1000
```

Printing Numbers

Printing numbers properly often poses a challenge
If we print 1 divided by 3 we get a repeating decimal
```
>>> print(1/3)
0.3333333333333333
```
Of course the decimal goes on forever
But the Python interpreter does not have a unlimited memory
So there is a limit to the number of decimal points a float value can have
When we perform a calculation involving money we want to display only two decimal points

But Python will always give us as many decimal points as it has to offer

>>> print(bill, "split three ways is", bill/3)
54.35 split three ways is 18.116666666666667

Of course we can always use the round function

>>> print(bill, "split three ways is", round(bill/3, 2))
54.35 split three ways is 18.12

A similar problem occurs when we want to print really big or really small numbers

>>> print("The age of the Universe is 13800000000 years")
The age of the Universe is 13800000000 years
>>> print("The size of an electron is .0000000000000282 meters")
The size of an electron is .0000000000000282 meters

This is why scientists use scientific notation
This notation represents a value with two numbers
The first number is a value and the second number is a power of ten
So we could represent the age of the Universe as 13.7 x 10⁹ years
And the size of an electron as 2.82 x 10^-15 meter
Languages like C, and Java deal with the problem of printing numbers using print function called printf ...
But Python takes another approach

The `format` Function

The name printf stands for "print formated"
Instead of providing a new print function, Python provides the format function
This function allows you to prints numbers in many different ways
It gives you a lot of flexibility when printing numbers
The format function takes two arguments
- A value
- A format specifier
The format specifier is a string that specifies how the number is to be formated
The format specifier can have many different parts most of which are optional
The part that isn't optional is the part that specifies the data type of the value
Most of the time when we use the format function we are using it with a float value
The type specifier for a float is f
Usually we use format on a float to specify the number of digits after the decimal point
To do this, the format specifier uses a dot, .
Followed by an integer
Followed by f
The number of digits after the decimal point is called the precision
The format string asking for 2 digits of precision when printing a float is .2f
```
>>> format(12345.67890, ".2f")
'12345.68'
```
To get three digits after the decimal point we would use .3f
```
>>> format(12345.67890, ".3f")
'12345.679'
```
Notice that the format function automatically rounds the last digit
So we do not have to use the round function

Using `format` with Scientific Notation

You can use the format function to print a number in scientific notation

All you have to do is use e instead of f in the format specifier

>>> print("The age of the universe is" , format(13800000000, "e"), "years")
The age of the universe is 1.380000e+10 years
>>> print("The size of an electron is", format(.0000000000000282, "e"), "meters")
The size of an electron is 2.820000e-14 meters

We can specify the precision the same way we did before

>>> print("The age of the universe is" , format(13800000000, ".2e"), "years")
The age of the universe is 1.38e+10 years
>>> print("The size of an electron is", format(.0000000000000282, ".2e"), "meters")
The size of an electron is 2.82e-14 meters

Using `format` to Put Commas in Big Numbers

Normally, when we write big numbers we use commas
They separate thousand from millions, from billions and so on
At least this is how we do it in English
Many other languages such as German and French use spaces
Spanish and Italian use periods (.)
To get format to group numbers with commas we add a comma before the period in the format specifier
Like this
```
format(12345.67890, ",.2f")
'12,345.68'
```
We can even leave out the precision part of the specifier
```
>>> format(12345.67890, ",f")
'12,345.678900
```
We never need the precision part when writing the format specifier for an integer ...

But we have to specify the data type with d

print("The age of the Universe is", format(13800000000, ",d"), "years")
The age of the Universe is 13,700,000,000 years

Specifying Minimum Length for a Number

When you print a table of numbers you want the left hand sides of the number to line up

Sometimes you can do this with tabs

$ cat print_07.py 
# uses tabs to print a table

print("Mon\tTue\tWed\tThr\tFri")
print("15\t24\t89\t31\t86")
print("21\t79\t74\t23\t79")
[528] glenn - ~/workspace-neon/it116/resources_it116/code_it116/examples_it116/2_chapter_examples
$ python3 print_07.py 
Mon Tue Wed Thr Fri
15  24  89  31  86
21  79  74  23  79

But this often does not work

$ cat print_08.py 
# uses tabs to print a table

print("Mon\tTue\tWed\tThr\tFri")
print("13452.12\t24\t234523.4589\t31\t86")
print("2324.1\t79\t74\t22343.453\t79")

$ python3 print_08.py 
Mon Tue Wed Thr Fri
13452.12    24  234523.4589 31  86
2324.1  79  74  22343.453   79

What we really want is some way to specify the minimum width of a value

We can do this by putting a number in front of the . in the format specifier

$ cat print_09.py 
# prints a table of values using format

print(format(13452.12, "10.2f") + format(24, "10.2f") + format(234523.4589, "10.2f")  \
      + format(31, "10.2f") + format(86, "10.2f"))
print(format(2324.1, "10.2f") + format(79, "10.2f") + format(74, "10.2f") \
      + format(22343.453, "10.2f") + format(79, "10.2f"))

$ python3 print_09.py 
  13452.12     24.00 234523.46     31.00     86.00
   2324.10     79.00   74.00  22343.45    79.00

Alignment with the `format` Function

I left off the column labels in the previous script because I did not want to complicate things
But we can use the format function to set the minimum width of strings as well as numbers

When we use format with strings we use the type specifier s

$ cat print_10.py 
# prints a table of values using format

print(format("Mon", "10s") + format("Tue", "10s") + format("Wed", "10s") \
      + format("Thr", "10s") + format("Fri", "10s"))
print(format(13452.12, "10.2f") + format(24, "10.2f") + format(234523.4589, "10.2f")  \
      + format(31, "10.2f") + format(86, "10.2f"))
print(format(2324.1, "10.2f") + format(79, "10.2f") + format(74, "10.2f") \
      + format(22343.453, "10.2f") + format(79, "10.2f"))

$ python3 print_10.py 
Mon       Tue       Wed       Thr       Fri       
  13452.12     24.00 234523.46     31.00     86.00
   2324.10   79.00     74.00  22343.45    79.00

The output does not look good because the numbers are right aligned
But the strings are left aligned

We can force all the strings to be right aligned if we place a > at the beginning of the format specifier

$ cat print_11.py 
# prints a table of values using format

print(format("Mon", ">10s") + format("Tue", ">10s") + format("Wed", ">10s") \
      + format("Thr", ">10s") + format("Fri", ">10s"))
print(format(13452.12, "10.2f") + format(24, "10.2f") + format(234523.4589, "10.2f")  \
      + format(31, "10.2f") + format(86, "10.2f"))
print(format(2324.1, "10.2f") + format(79, "10.2f") + format(74, "10.2f") \
      + format(22343.453, "10.2f") + format(79, "10.2f"))

$ python3 print_11.py 
       Mon       Tue       Wed       Thr       Fri
  13452.12     24.00 234523.46     31.00     86.00
   2324.10     79.00     74.00  22343.45     79.00

Formating Percentages

The format function can turn decimals into percentage

All you have to do is change the type specifier from f to %

>>> print("3 out of 10 is", format(3/10, ".0%"))
3 out of 10 is 30%

Don't Worry about the `format` Function

I will not ask you to use format on a quiz or exam.

I do not expect you to memorize all the different components of a format string.

These are the sorts of things you look up when you need them.

Today's Topics

Tips and Examples

Review

New Material

Reading Assignment

Homework 3

Tips and Examples

Converting Decimal to Integer

Review

Performing Calculations

Decimal and Integer Division

Exponent Operator

Remainder Operator

Operator Precedence

Grouping with Parentheses

Mixed-Type Expressions and Data Type Conversion

Breaking Long Statements into Multiple Lines

New Material

More Expressions inside Expressions

Whitespace Characters

Escape Characters

Using print without Going to a New Line

print Item Separator

Concatenation Operator

Concatenating Strings with Numbers

Printing Numbers

The format Function

Using format with Scientific Notation

Using format to Put Commas in Big Numbers

Specifying Minimum Length for a Number

Alignment with the format Function

Formating Percentages

Don't Worry about the format Function

Attendance

Using `print` without Going to a New Line

`print` Item Separator

The `format` Function

Using `format` with Scientific Notation

Using `format` to Put Commas in Big Numbers

Alignment with the `format` Function

Don't Worry about the `format` Function