Formatting with f-strings

Format strings, or f-strings, are the easiest way to format data in Python. All you need is a lowercase f or uppercase F followed immediately by some text or expressions enclosed in quotation marks. Here is an example:

f"Hello {username}"

The f before the first quotation mark tells Python that what follows is a format string. Inside the quotation marks, the text, called the literal part, is displayed literally (exactly as typed in the f-string). Anything in curly braces is the expression part of the f-string, a placeholder for what will appear when the code executes. Inside the curly braces, you can have an expression (a formula to perform some calculation, a variable name, or a combination of the two). Here is an example:

username = "Alan"
print(f"Hello {username}")

When you run this code, the print function displays the word Hello, followed by a space, followed by the contents of the username variable, as shown in Figure 1-6.

Here is another example of an expression — the formula quantity times unit_price — inside the curly braces:

unit_price = 49.99
quantity = 30
print(f"Subtotal: ${quantity * unit_price}")

The output from that, when executed, follows:

Subtotal: $1499.7

That $1499.7 isn't an ideal way to show dollar amounts. Typically, we like to use commas in the thousands places, and two digits for the pennies, as in the following:

Subtotal: $1,499.70

Fortunately, f-strings provide you with the means to do this formatting, as you learn next.

Showing dollar amounts

To get a comma to appear in the dollar amount and the pennies as two digits, you can use a format string inside the curly braces of an expression in an f-string. The format string starts with a colon and needs to be placed inside the closing curly brace, right up against the variable name or the value shown.

To show commas in thousands places, use a comma in your format string right after the colon, like this:

:,

Using the current example, you would do the following:

print(f"Subtotal: ${quantity * unit_price:,}")

Executing this statement produces this output:

Subtotal: $1,499.7

To get the pennies to show as two digits, follow the comma with

.2f

The .2f means “two decimal places, fixed” (never any more or less than two decimal places). The following code will display the number with commas and two decimal places:

print(f"Subtotal: ${quantity * unit_price:,.2f}")

Here's what the code displays when executed:

Subtotal: $1,499.70

Perfect! That's exactly the format we want. So anytime you want to show a number with commas in the thousands places and exactly two digits after the decimal point, use an f-string with the format string, .2f.

Formatting percent numbers

Now, suppose your app applies sales tax. The app needs to know the sales tax rate, which should be expressed as a decimal number. So if the sales tax rate is 6.5 percent, it has to be written as 0.065 (or .065, if you prefer) in your code, like this:

sales_tax_rate = 0.065

It's the same amount with or without the leading zero, so just use whichever format works for you.

This number format is ideal for Python, and you wouldn't want to mess with that. But if you want to display that number to a human, simply using a print() function displays it exactly as Python stores it:

sales_tax_rate = 0.065
print(f"Sales Tax Rate {sales_tax_rate}")
Sales Tax Rate 0.065

When displaying the sales tax rate for people to read, you'll probably want to use the more familiar 6.5% format rather than .065. You can use the same idea as with fixed numbers (.2f). However, you replace the f for fixed numbers with %, like this:

print(f"Sales Tax Rate {sales_tax_rate:.2%}")

Running this code multiples the sales tax rate by 100 and follows it with a % sign, as you can see in Figure 1-7.

In both of the previous examples, we used 2 for the number of digits. But of course you can display any number of digits you want, from zero (none) to whatever level of precision you need. For example, using .1%, as in the following:

print(f"Sales Tax Rate {sales_tax_rate:.1%}")

displays this output when the line is executed:

Sales Tax Rate 6.5%

Replacing 1 with a 9, like this:

print(f"Sales Tax Rate {sales_tax_rate:.9%}")

displays the percentage with nine digits after the decimal point:

Sales Tax Rate 6.500000000%

You don't need to use an f-string only inside a call to the print function. You can also execute an f-string and save the result in a variable that you can display later. The format string itself is like any other string in that it must be enclosed in single, double, or triple quotation marks. When using triple quotation marks, you can use either three single quotation marks or three double quotation marks. It doesn't matter which you use as the outermost quotation marks on the format string; the output is the same, as you can see in Figure 1-8.

For single and double quotation marks, use the corresponding keyboard keys. For triple quotation marks, you can use three of either. Make sure you end the string with exactly the same characters you used to start the string. For example, all the strings in Figure 1-8 are perfectly valid code, and they will all be treated the same.

Making multiline format strings

If you want to have multiline output, you can add line breaks to your format strings in a few ways:

• Use /n: You can use a single-line format string with any place you want a line break. Just make sure you put the in the literal portion of the format string, not inside curly braces. For example:

  user1 = "Alberto"
user2 = "Babs"
user3 = "Carlos"
output=f"{user1} {user2} {user3}"
print(output)

  When executed, this code displays:

  Alberto
Babs
Carlos

• Use triple quotation marks (single or double): If you use triple quotation marks around your format string, you don't need to use . You can just break the line in the format string wherever you want it to break in the output. For example, look at the code in Figure 1-9. The format string is in triple quotation marks and contains multiple line breaks. The output from running the code has line breaks in the same places.

As you can see, the output honors the line breaks and even the blank spaces in the format string. Unfortunately, it's not perfect — in real life, we would right align the numbers so that the decimal points line up. All is not lost, though, because with format strings you can also control the width and alignments of your output.

Formatting width and alignment

You can also control the width of your output (and the alignment of content within that width) by following the colon in your f-string with < (for left aligned), ^ (for centered), or > (for right aligned). Put any of these characters right after the colon in your format string. For example, the following will make the output 20 characters wide, with the content right aligned:

:>20

In Figure 1-9, all the dollar amounts are left aligned, because that's the default. To right align numbers, which is how we usually see dollar amounts, you can use > in an f-string. To make the numbers the same width, specify a number after the > character. For example, in Figure 1-10, each f-string includes >9, which causes each displayed number to be right aligned and 9 characters wide. The output, which you can see at the bottom of the figure, makes all the numbers align to the right, with their dollar signs neatly aligned to the left. The spaces to the right of each dollar sign make sure each number is exactly 9 characters wide.

You may look at Figure 1-10 and wonder why the dollar signs are lined up the way they are. Why aren't they aligned right next to their numbers? The dollar signs are part of the literal string, outside the curly braces, so they aren't affected by the >9 inside the curly braces.

Realigning the dollar signs is a little more complicated than you might imagine, because you can use the ,.2f formatting only on a number. You can't attach a $ to the front of a number unless you change the number to a string — but then it wouldn't be a number anymore, so.2f wouldn't work.

But complicated doesn't mean impossible; it just means inconvenient. You can convert each dollar amount to a string in the current format, stick the dollar sign on that string, and then format the width and alignment on this string. For example, the following code creates a variable named s-subtotal containing a dollar sign immediately followed by the dollar amount, with the dollar sign just to the left of the first digit and no spaces after the dollar sign:

s_subtotal = "$" + f"{subtotal:,.2f}"

In this code, we assume the subtotal variable contains some number. Let's say the number is 1598.402, though it could be any number. The f"{subtotal:,2f}" formats the number in a fixed two-decimal-places format with a comma in the thousands place, like this:

1,598.40

The output is a string rather than a number because an f-string always produces a string.

The following part of the code sticks (concatenates) a dollar sign in the front:

"$"+

So now the output is $1,598.40. That final formatted string is stored in a new variable named s_subtotal. (We added the leading s_ to remind us that this is the string equivalent of the subtotal number, not the original number.)

To display that dollar amount right aligned with a width of 9 digits, use >9 in a new format string to display the s_subtotal variable, like this:

f{s_subtotal:>9}

When you use + with strings, you concatenate (join) the two strings. The + only does addition with numbers, not strings.

Figure 1-11 shows a complete example, including the output from running the code. All the numbers are right aligned with the dollar signs in the usual place.

Binary, octal, and hexadecimal numbers

If your work requires dealing with base 2, base 8, or base 16 numbers, you're in luck because Python has symbols for writing these as well as functions for converting among them. Table 1-3 shows the three non-decimal bases and the digits used by each.

Most people never have to work with binary, octal, or hexadecimal numbers. So if all of this is giving you the heebie-jeebies, don't sweat it. If you’ve never heard of them before, chances are you’ll never hear of them again after you’ve completed this section.

If you want more information about the various numbering systems, you can use your favorite search engine to search for binary number or octal, or decimal, or hexadecimal.

You can use these various functions to convert how the number is displayed at the Python prompt, of course, as well as in an apps you create. At the prompt, just use the print() function with the conversion function inside the parentheses, and the number you want to convert inside the innermost parentheses. For example, the following displays the hexadecimal equivalent of the number 255:

print(hex(255))

The result is 0xff, where the 0x indicates that the number that follows is expressed in hex, and ff is the hexadecimal equivalent of 255.

To convert from binary, octal, or hex to decimal, you don't need to use a function. Just use print() with the number you want to convert inside the parentheses. For example, print(0xff) displays 255, the decimal equivalent of hex ff. Figure 1-12 shows some more examples you can try at the Python prompt.

Complex numbers

Complex numbers are another one of those weird numbering things you may never have to deal with unless you happen to be into electrical engineering, higher math, or a branch of science that uses them. A complex number is one that can be expressed as a+bi where a and b are real numbers, and i represents the imaginary number satisfied by the equation x²=–1. There is no real number x whose square equals –1, so that's why it’s called an imaginary number.

Some branches of math use a lowercase i to indicate an imaginary number. But Python uses j (as do those in electrical engineering because i is used to indicate current).

Anyway, if your application requires working with complex numbers, you can use the complex() function to generate an imaginary number, using the following syntax:

complex(real,imaginary)

Replace real with the real part of the complex number, and replace imaginary with the imaginary number. For example, in code or the command prompt, try this:

z = complex(2,-3)

The variable z gets the imaginary number 2–3j. Then use a print() function to display the contents of z, like this:

print(z)

The screen displays the imaginary number 2-3j.

You can tack .real or .imag onto an imaginary number to get the real or imaginary part. For example, the following produces 2.0, which is the real part of the number z:

print(z.real)

And this returns –3.0, which is the imaginary part of z:

print(z.imag)

Once again, if none of this makes sense to you, don't worry. It’s not required for learning or doing Python. Python simply offers complex numbers and these functions for people who happen to require them.

If your work requires working with complex numbers, search the web for python cmath to learn about Python's cmath module, which provides functions for complex numbers.

Concatenating strings

You can join strings by using a + sign. The process of doing so is called string concatenation in nerd-o-rama world. One thing that catches beginners off-guard is the fact that a computer doesn't know a word from a bologna sandwich. So when you join strings, the computer doesn't automatically put spaces where you'd expect them. For example, in the following code, full_name is a concatenation of the first three strings.

first_name = "Alan"
middle_init = "C"
last_name = "Simpson"
full_name = first_name+middle_init + last_name
print(full_name)

When you run this code to print the contents of the full_name variable, you can see that Python did join them in one long string:

AlanCSimpson

Nothing is wrong with this output, per se, except that we usually put spaces between words and the parts of a person's name.

Because Python won’t automatically put in spaces where you think they should go, you have to put them in yourself. The easiest way to represent a single space is by using a pair of quotation marks with one space between them, like this:

" "

If you forget to put the space between the quotation marks, like the following, you won't get a space in your string because there's no space between the quotation marks:

""

You can put multiple spaces between the quotation marks if you want multiple spaces in your output, but typically one space is enough. In the following example, you put a space between first_name and last_name. You also stick a period and space after middle_init:

first_name = "Alan"
middle_init = "C"
last_name = "Simpson"
full_name = first_name + " " + middle_init + ". " + last_name
print(full_name)

The output of this code, which is the contents of that full_name variable, looks more like the kind of name you're used to seeing:

Alan C. Simpson

Getting the length of a string

To determine how many characters are in a string, you use the built-in len() function (short for length). The length includes spaces because spaces are characters, each one having a length of one. An empty string — that is, a string with nothing in it, not even a space — has a length of zero.

Here are some examples. In the first line you define a variable named s1 and put an empty string in it (a pair of quotation marks with nothing in between). The s2 variable gets a space (a pair of quotation marks with a space between). The s3 variable gets a string with some letters and spaces. Then, three print() functions display the length of each string:

s1 = ""
s2 = " "
s3 = "A B C"
print(len(s1))
print(len(s2))
print(len(s3))

Following is the output from that code, when executed. The output makes perfect sense when you understand that len() measures the length of strings as the number of characters (including spaces) in the string:

0
1
5

Working with common string operators

Python offers several operators for working with sequences of data. One weird thing about strings in Python (and in most other programming languages) is that when you're counting characters, the first character counts as 0, not 1. This makes no sense to us humans. But computers count characters that way because it’s the most efficient method. So even though the string in Figure 1-13 is five characters long, the last character in that string is the number 4, because the first character is number 0. Go figure.

Table 1-4 summarizes the Python 3 operators for working with strings.

Figure 1-14 shows examples of using the string operators in Jupyter Notebook. When the output of a print() function doesn't look right, keep in mind two important facts about strings in Python:

• The first character is always number 0.
• Every space counts as one character, so don't skip spaces when counting.

You may have noticed that min(s) returns a blank space, meaning that the blank space character is the lowest character in that string. But what exactly makes the space “lower” than the letter A or the letter a? The simple answer is the letter's ASCII number. Every character you can type at your keyboard, and many additional characters, have a number assigned by the American Standard Code for Information Interchange (ASCII).

Figure 1-15 shows a chart with ASCII numbers for many common characters. Spaces and punctuation characters are “lower” than A because they have smaller ASCII numbers. Uppercase letters are “lower” than lowercase letters because they have smaller ASCII numbers. Are you wondering what happened to the characters assigned to numbers 0–31? These numbers have characters too, but they are control characters and are essentially non-printing and invisible, such as when you hold down the Ctrl key and press another key.

Python offers two functions for working with ASCII. The ord() function takes a character as input and returns the ASCII number of that character. For example, print(ord("A")) returns 65, because an uppercase A is character 65 in the ASCII chart. The chr() function does the opposite. You give it a number, and it returns the ASCII character for that number. For example, print(chr(65)) displays A because A is character 65 in the ASCII chart.

Manipulating strings with methods

Every string in Python 3 is considered a str object (pronounced “string object”). The shortened word str for string distinguishes Python 3 from earlier versions of Python, which referred to string as string objects (with the word string spelled out, not shortened). This naming convention is a great source of confusion, especially for beginners. Just try to remember that in Python 3, str is all about strings of characters.

Python offers numerous str methods (also called string methods) to help you work with str objects. The general syntax of str object methods is as follows:

string.methodname(params)

where string is the string you're analyzing, methodname is the name of a method from Table 1-5, and params refers to any parameters that you need to pass to the method (if required). The leading s in the first column of Table 1-5 means “any string,” be it a literal string enclosed in quotation marks or the name of a variable that contains a string.

You can play around with these methods in a Jupyter notebook, at the Python prompt, or in a .py file. Figure 1-16 shows some examples in a Jupyter notebook using three variables named s1, s2, and s3 as strings to experiment with. The result of running the code appears below the code.

Don't bother trying to memorize or even make sense of every string method. Remember instead that if you need to operate on a string in Python, you can do a web search for python 3 string methods to find out what's available.

Working with dates

The datetime.date data type is ideal for working with dates when time isn't an issue. You can create a date object in two ways. You can get today’s date from the computer's internal clock by using the today() method. Or you can specify a year, month, and day (in that order) inside parentheses.

When specifying the month or day, never use a leading zero for datetime.date(). For example, April 1 2020 has to be expressed as 2020,4,1 — if you type 2020,04,01, it won't work.

For example, after importing the datetime module, you can use date.today() to get the current date from the computer's internal clock. Or use date(year, month, day) syntax to create a date object for some other date. The following code shows both methods:

# Import the datetime module, nickname dt
import datetime as dt
# Store today's date in a variable named today.
today = dt.date.today()
# Store some other date in a variable called last_of_teens
last_of_teens = dt.date(2019, 12, 31)

Try it by typing the code in a Jupyter notebook, at the Python prompt, or in a .py file. Use the print() function to see what's in each variable, as shown in Figure 1-17. Your today variable won't be the same as in the figure; it will the date you try this.

You can isolate any part of a date object by using .month, .day, or .year. For example, in the same Jupyter cell or Python prompt, execute this code:

print(last_of_teens.month)
print(last_of_teens.day)
print(last_of_teens.year)

Each of the three components of that date appear on a separate line:

12
31
2019

As you saw on the first printout, the default date display is yyyy-mm-dd, but you can format dates and times however you want. Use f-strings, which we discuss earlier in this chapter, along with the directives shown in Table 1-6, which includes the format for dates as well as for times, as we discuss later in this chapter.

Some tutorials tell you to format dates and times by using strftime rather than f-strings, and that's certainly a valid method. We're sticking with the newer f-strings here, however, because we think they'll be preferred over strftime in the future.

When using format strings, make sure you put spaces, slashes, and anything else you want between directives where you want those to appear in the output. For example, this line:

print(f"{last_of_teens:%A, %B %d, %Y}")

when executed, displays this:

Tuesday, December 31, 2019

To show the date in the mm/dd/yyyy format, use %m/%d/%Y, like this:

todays_date = f"{today:%m/%d/%Y}"

The output will be the current date for you when you try it, with a format like the following:

11/19/2018

Table 1-7 shows a few more examples you can try with different dates.

Working with times

If you want to work strictly with time data, use the datetime.time class. The basic syntax for defining a time object using the time class is

variable = datetime.time([hour,[minute,[second,[microsecond]]]])

Notice how all the arguments are optional. For example, you can use no arguments:

midnight = dt.time()
print(midnight)

This code stores the time as 00:00:00, which is midnight. To verify that it's really a time, entering print(type(midnight)) displays the following:

00:00:00
<class 'datetime.time'>

The second line tells you that the 00:00:00 value is a time object from the datetime class.

The fourth optional value you can pass to time() is microseconds (millionths of a second). For example, the following code puts a time that's a millionth of a second before midnight in a variable named almost_midnight and then displays that time onscreen with a print() function:

almost_midnight = dt.time(23, 59, 59, 999999)
print(almost_midnight)
23:59:59.999999

You can use format strings with the time directives from Table 1-6 to control the format of the time. Table 1-8 shows some examples using 23:59:59:999999 as the sample time.

Sometimes you want to work only with dates, and sometimes you want to work only with times. Often you want to pinpoint a moment in time using both the date and the time. For that, use the datetime class of the datetime module. This class supports a now() method that can grab the current date and time from the computer clock, as follows:

import datetime as dt
right_now = dt.datetime.now()
print(right_now)

What you see on the screen from the print() function depends on when you execute this code. But the format of the datetime value will be like this:

2019-11-19 14:03:07.525975

This means November 19, 2019 at 2:03 PM (with 7.525975 seconds tacked on).

You can also define a datetime using any the following parameters. The month, day, and year are required. The rest are optional and set to 0 in the time if you omit them.

datetime(year, month, day, hour, [minute, [second, [microsecond]]])

Here is an example using 11:59 PM on December 31 2019:

import datetime as dt
new_years_eve = dt.datetime(2019, 12, 31, 23, 59)
print(new_years_eve)

Here is the output of that print() statement with no formatting:

2019-12-31 23:59:00

Table 1-9 shows examples of formatting the datetime using directives shown previously in Table 1-6.

Calculating timespans

Sometimes just knowing the date or time isn't enough. You need to know the duration, or timespan, as it’s typically called in the computer world. In other words, not the date, not the o'clock, but the “how long” in terms of years, months, weeks, days, hours, minutes, or whatever. For timespans, the Python datetime module includes the datetime.timedelta class.

A timedelta object is created automatically whenever you subtract two dates, times, or datetimes to determine the duration between them. For example, suppose you create a couple of variables to store dates, perhaps one for New Year's Day and another for Memorial Day. Then you create a third variable named days_between and put in it the difference you get by subtracting the earlier date from the later date, as follows:

import datetime as dt
new_years_day = dt.date(2019, 1, 1)
memorial_day = dt.date(2019, 5, 27)
days_between = memorial_day - new_years_day

So what exactly is days_between in terms of a data type? If you print its value, you get 146 days, 0:00:00. In other words, there are 146 days between those dates; the 0:00:00 is time but because we didn't specify a time of day in either date, the time digits are all just set to 0. If you use the Python type() function to determine the data type of days_between, you see it's a timedelta object from the datetime class, as follows:

146 days, 0:00:00
<class 'datetime.timedelta'>

The timedelta calculation happens automatically when you subtract one date from another to get the time between. You can also define any timedelta (duration) using this syntax:

datetime.timedelta(days=, seconds=, microseconds=, milliseconds=, minutes=, hours=, weeks=)

If you provide an argument, you must include a number after the = sign. If you omit an argument, its value is set to 0.

To get an understanding of how this works, try out the following code. After importing the datetime module, create a date using .date(). Then create a timedelta object using .timedelta. If you add a date and a timedelta, you get a new date — in this case, a date that's 146 days after 1/1/2019:

import datetime as dt
new_years_day = dt.date(2019, 1, 1)
duration = dt.timedelta(days=146)
print(new_years_day + duration)
2019-05-27

Of course, you can subtract too. For example, if you start with a date of 5/27/2019 and subtract 146 days, you get 1/1/2019, as shown here:

import datetime as dt
memorial_day = dt.date(2019, 5, 27)
duration = dt.timedelta(days=146)
print(memorial_day - duration)
2019-01-01

It works with datetimes too. If you're looking for a duration that's less than a day, just give both times the same date. For example, consider the following code and the results of the subtraction:

import datetime as dt
start_time = dt.datetime(2019, 3, 31, 8, 0, 0)
finish_time = dt.datetime(2019, 3, 31, 14, 34, 45)
time_between = finish_time - start_time
print(time_between)
print(type(time_between))
6:34:45
<class 'datetime.timedelta'>

We know that 6:34:45 is a time duration of 6 hours 34 minutes and 45 seconds for two reasons. One, it's the result of subtracting one moment of time from another. Two, printing the type() of that data type tells us it’s a timedelta object (a duration), not an o'clock time.

Here is another example using datetimes with different dates: One is the current datetime, and the other is a date of birth with the time down to the minute (March 31 1995 at 8:26 AM). To calculate age, subtract the birthdate from the current time, now:

import datetime as dt
now = dt.datetime.now()
birthdatetime = dt.datetime(1995, 3, 31, 8, 26)
age = now - birthdatetime
print(age)
print(type(age))
8634 days, 7:55:07.739804
<class 'datetime.timedelta'>

The result is expressed as follows:

8634 days, 7 hours, 52 minutes, and 1.967031 seconds

The tiny seconds value stems from the fact that datetime.now grabs the date and time from the computer's clock down to the microsecond.

You don't always need microseconds or even seconds in your timedelta object. For example, say you’re trying to determine someone’s age. You could start by creating two dates, one named today for today's date and another named birthdate that contains the birthdate. The following example uses a birthdate of Jan 31, 2000:

import datetime as dt
today = dt.date.today()
birthdate = dt.date(2000, 12, 31)
delta_age = (today - birthdate)
print(delta_age)

The last two lines create a variable named delta_age and print what's in the variable. If you run this code, you’ll see something like the following output (but it won't be exactly the same because your today date will be whatever today's date is when you run the app):

6533 days, 0:00:00

Let’s say what we really want is the age in years. You can convert timedelta to a number of days by tacking .days onto timedelta. You can put that in another variable called days_old. Printing days_old and its type show you that days_old is an int, a regular old integer you can do math with. For example, in the following code, the days_old variable receives the value delta_age.days, which is delta_age from the preceding line converted to a number of days:

delta_age = (today - birthdate)
days_old = delta_age.days
print(days_old, type(days_old))
6533 <class 'int'>

To get the number of years, divide the number of days by 365. If you want just the number of years as an integer, use the floor division operator (//) rather than regular division (/). (Floor division removes the decimal portion from the quotient, so you get a whole number). You can put the result of that calculation in another variable if you like. For example, in the following code, the years_old variable contains a value calculated by dividing days_old by 365:

years_old = days_old // 365
print(years_old)
18

So we get the age, in years: 18. If you want the number of months, too, you can ballpark that just by taking the remainder of dividing the days by 365 to get the number of days left. Then floor divide that value by 30 (because on average each month has about 30 days) to get a good approximation of the number of months. Use % rather than / for division to get just the remainder after the division. Figure 1-18 shows the sequence of events in a Jupyter notebook, with comments to explain what's going on.