IT 116: Introduction to Scripting

IT 116: Introduction to Scripting
Class Notes

F-strings
Printing Numbers
Format Specifiers in F-strings
Using Format Specifiers with Scientific Notation
Using Format Specifiers to Put Commas in Big Numbers
Specifying Minimum Length for a Number
Alignment
Formating Percentages
Order of F-string Designators

F-strings

Often we want to print a string that contains the value of variables
For example, a script might want to print a greeting ...
with the name of a person and their username ...

using the variables name and username

>>> name = "John Smith"
>>> username = "jsmith"

What if I wanted to print the following string
```
	Hello, John Smith! Your username is jsmith
```

I could try

>>> print("Hello ", name, "! Your username is ", username)
Hello  John Smith ! Your username is  jsmith

But the ! should not have a space before it

I could use concatenation

>>> print("Hello, " + name + "! Your username is", username)
Hello, John Smith! Your username is jsmith

But that is a lot of work and is ugly
However, since Python 3.6 I have another option
I can use F-strings, formated strings
An F-string begins with an f ...
followed by a quoted string ...
with the variables inside { } ...

like this

>>> print(f"Hello, {name}! Your username is {username}")
Hello, John Smith! Your username is jsmith

This is much easier to type ...
and much less ugly
But the real power of F-strings lies in what they can do with numbers

Printing Numbers

Printing numbers properly is often a challenge
If we print 1 divided by 3 we get a repeating decimal
```
>>> print(1/3)
0.3333333333333333
```
This decimal goes on forever ...
but the Python interpreter does not have a unlimited memory
So there is a limit to the number of digits after the decimal point ...
a float value can hold
When we print a money value, we only want two decimal places

But Python will always give us as many decimal points as it can

>>> bill = 54.35
>>> 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.8 x 10⁹ years
And the size of an electron as 2.82 x 10^-15 meter
Languages like C, and Java use a special function, printf, in these situations
The name printf stands for "print formated"
But Python uses F-strings

Format Specifiers in F-strings

The { } inside F-strings can hold more than the name of a variable
They can hold a string called a format specifier ...
that tells Python how to display the value of the variable
The format is
```
{LOOP_VARIABLE:FORMAT_SPECIFIER}
```
The format specifier is a string that tells Python how the number is to be formated
It 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 format specifiers are used with a float
The type specifier for a float is f
You can also use the format specifier to determine 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

>>> value = 12345.6789
>>> print(f"The value is {value}")
The value is 12345.6789
>>> print(f"The value is {value:.2f}")
The value is 12345.68

To get three digits after the decimal point we would use .3f

>>> print(f"The value is {value:.3f}")
The value is 12345.679

Notice that the format function automatically rounds the last digit ...
so we do not have to use the round function

Using Format Specifiers with Scientific Notation

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

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

>>> universe_age = 13800000000
>>> print(f"The age of the universe is {universe_age:e} years")
The age of the universe is 1.380000e+10 years
>>> 
>>> print(f"The size of an electron is {electron_size:e} meters")
The size of an electron is 2.820000e-14 meters

We can specify the precision the same way we did before

>>> print(f"The age of the universe is {universe_age:.2e} years")
The age of the universe is 1.38e+10 years
>>> print(f"The size of an electron is {electron_size:.2e} meters")
The size of an electron is 2.82e-14 meters

Using Format Specifiers 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 (.)
We can use format specifiers to add commas to numbers
To do this add a comma before the period in the format specifier

Like this

>>> value = 12345.67890
>>> print(f"The value is {value:,.2f}")
The value is 12,345.68

We never need the precision part when writing the format specifier for an integer

But we have to specify the data type with d

>>> universe_age = 13800000000			
>>> print(f"The age of the Universe is {universe_age:,d} years")
The age of the Universe is 13,800,000,000 years

Specifying Minimum Length for a Number

When you print a table of numbers ...
you want the right-hand sides of the numbers 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")

$ 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 f-strings 

print(f"{13452.12:10.2f} {24:10d} {234523.4589:10.2f} {31:10d} {86:10d}{24:10d} {234523.4589:10.2f} {31:10d} {86:10d}")
print(f"{2324:10d} {79:10d} {74:10d} {22343.453:10.2f} {79:10d}"

$ python3 print_09.py 
  13452.12         24  234523.46         31         86
      2324         79         74   22343.45         79

By writing "10" before the .
We are telling Python to make sure each number is 10 characters wide
Notice that I did not use variable names inside { }
I used number literals instead
I also mixed decimals and integers

Alignment

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

When we work with strings we use the type specifier s

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

print(f"{'Mon':10s} {'Tue':10s} {'Wed':10s} {'Thr':10s} {'Fri':10s}")
print(f"{13452.12:10.2f} {24:10d} {234523.4589:10.2f} {31:10d} {86:10d}")
print(f"{2324:10d} {79:10d} {74:10d} {22343.453:10.2f} {79:10d}")

$ python3 print_10.py 
Mon        Tue        Wed        Thr        Fri       
  13452.12         24  234523.46         31         86
      2324         79         74   22343.45         79

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 specifiers

print(f"{'Mon':>10s} {'Tue':>10s} {'Wed':>10s} {'Thr':>10s} {'Fri':>10s}")
print(f"{13452.12:10.2f} {24:10d} {234523.4589:10.2f} {31:10d} {86:10d}")
print(f"{2324:10d} {79:10d} {74:10d} {22343.453:10.2f} {79:10d}"

$ python3 print_11.py 
       Mon        Tue        Wed        Thr        Fri
  13452.12         24  234523.46         31         86
      2324         79         74   22343.45         79

Formating Percentages

The format specifiers can turn decimals into a percentage

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

>>> print(f"3 out of 10 is {3/10:.0%}")
3 out of 10 is 30%

Notice that the value between the { } is not a variable ...
or a literal ...
but a calculation using operators

Order of F-string Designators

The different characters that appear after the : inside the { } are called designators

And they have appear in a certain order

[alignment] [width] [,] [.precision] [type]