Table of Contents » Chapter 4 : Output : Advanced Printing
Advanced Printing
The print() function is the first function we learned. It's simple, effective, and very widely used in Python programming. But as your programming skills grow, you'll find that the basic print() function sometimes doesn't quite meet your needs. In this section, we'll explore advanced techniques for formatting and controlling console output that go beyond the basic print() function.
The string .format() method inserts specified value(s) into a string using placeholders. Placeholders are defined inside of the target string using curly brackets { }. The result of the format() method is a fully formatted string. These formatted strings can be used in print statements, assigned to variables, passed as parameters, etc. You can find official documentation for this method on the docs.python.org site.
Examples general form of the string format() method:
# Example 1:
string_var.format(Value_1, Value_2, ... Value_n)
# Example 2:
string_var.format("String {PlaceHolder_1} string {PlaceHolder_2} ... string {PlaceHolder_n}").format(Value_1, Value_2, ... Value_n)One or more Values is required in the values list inside the format() method. Each value in the list must be separated by a comma and the values can be of any data type.
Code Examples
Study and practice the following code examples. Pay particular attention to the explanatory comments in the code as well. Also, you can find additional (more in-depth) documentation on string formatting here ↗, and here ↗, and here ↗.
Also, you can find a list of the formatting type operators in the Reference Materials of this book on the String Formatting Types ↗ page.
# Examples of the format() method
# Example of using a print statement with both the string and the variables
print("Hello, {}. Welcome to {}.".format("Bob", "the University of Utah"))
# Example of using a variable to hold the string
greeting = "Hello, {}. Welcome to {}."
print(greeting.format("Bob", "the University of Utah"))
print()
# Example using positional arguments
# Note the print statements are the same, but we can control the
# order of printing based on where we put the placeholders {}
info = "Name: {0}, Age: {1}, University: {2}"
print(info.format("Bob", 22, "Utah"))
info = "University: {2}, Name: {0}, Age: {1}"
print(info.format("Bob", 22, "Utah"))
print()
# Example of using named arguments
# Note the print statements are the same, but we can control the
# order of printing based on where we put the placeholders {}
template = "Artist: {name}, Album: {album}, Year: {year}"
print(template.format(name="Led Zepplin", album="Houses of the Holy", year=1973))
template = "Year: {year}, Album: {album}, Artist: {name}"
print(template.format(name="Led Zepplin", album="Houses of the Holy", year=1973))
print()
# Example of formatting numbers
# Formatting floating point numbers
print("Pi is approximately {0:.3f}.".format(3.14159))
# Formatting integers
print("Population: {0:,}".format(123456789))
# Formatting monetary values
print("Price: ${0:,.2f}".format(12345.67))
print()
# Example of padding and alignment formatting
# Right align
print("Username: {0:>5}".format("Bob"))
print("Username: {0:>10}".format("Bob"))
print("Username: {0:>20}".format("Bob"))
print("Username: {0:>20} Age: {1:>5}".format("Bob", 22))
print()
print("Username: {0:>10}\nAge: {1:>15}".format("Bob", 22))
print()Output
Hello, Bob. Welcome to the University of Utah.
Hello, Bob. Welcome to the University of Utah.
Name: Bob, Age: 22, University: Utah
University: Utah, Name: Bob, Age: 22
Artist: Led Zepplin, Album: Houses of the Holy, Year: 1973
Year: 1973, Album: Houses of the Holy, Artist: Led Zepplin
Pi is approximately 3.142.
Population: 123,456,789
Price: $12,345.67
Username: Bob
Username: Bob
Username: Bob
Username: Bob Age: 22
Username: Bob
Age: 22Python includes a concept called Formatted String Literals (f-strings). f-strings allow for inline expressions (called interpolation) within string literals. This feature makes formatting of console output more intuitive and readable. You can find full documentation for f-strings on the docs.python.org ↗ site.
Code Examples
Study and practice the following code examples. Pay particular attention to the explanatory comments in the code as well.
# Examples of using f-strings
# Simple embedding example
name = "Bob"
print(f"Hello, {name}!")
print()
# Example of embedding expressions
x = 4
y = 5
print(f"The sum of {x} and {y} is {x + y}.")
print()
# Example of embedding formatted values
pi = 3.14159265
print(f"Pi rounded to three decimal places: {pi:.3f}")
print()
# Example of padding & alignment with f-strings
name = "Alice"
print(f"{name:>5}")
print(f"{name:>10}")
print(f"{name:>20}")
print()
# Example of multi-line f-strings
name = "Bob"
occupation = "Software Engineer"
print(f"""
Name:\t {name}
Job:\t {occupation}
""")
print()Output
Hello, Bob!
The sum of 4 and 5 is 9.
Pi rounded to three decimal places: 3.142
Alice
Alice
Alice
Name: Bob
Job: Software Engineer
The string Template() class in Python's standard library provides a simple and more secure way to handle string substitution. It’s part of the string module and offers a straightforward syntax for string interpolation, using $ as a prefix for identifiers. This method is particularly useful when you need to generate text with variable parts, coming from user input or external sources, due to its simplicity and reduced risk of injection attacks.
Because the Template() class is in the standard library, we must import it in order to use it in our programs, like this:
from string import TemplateCode Examples
Study and practice the following code examples. Pay particular attention to the explanatory comments in the code as well.
# Examples of the string Template() class
# First need to import the Template class
from string import Template
# Simple substitution
# This example first creates a template and
# then uses the substitute() method to
# perform the substitution of the data value
# into the template
t = Template("Go, $team!")
print(t.substitute(team="Utes"))
print()
print()
# Complex substitution
# In this example, we create an email template (form
# letter) with variables throughout that will be filled
# in by the substitute() method to produce a personalized
# email message.
email_template = Template("""
Dear $name,
Thank you for purchasing the $color $product. We hope you enjoy it!
Best regards,
Customer Service
""")
email = email_template.substitute(name='Bob', product='Widget 5000', color="red")
print(email)Output
Go, Utes!
Dear Bob,
Thank you for purchasing the red Widget 5000. We hope you enjoy it!
Best regards,
Customer Service
Printing dates and times in Python is a common task in many programming projects, ranging from logging activities in applications to processing and displaying temporal data in data science projects. Python provides a comprehensive standard library for handling dates and times through modules like datetime, time, and calendar. In this section, we'll focus on the datetime library, which is widely used for manipulating dates and times.
You can find a list of the date & time format code referred to below in the Reference Materials of this book on the Date & Time Format Codes ↗ page.
Because datetime is a library we must import it in order to use it in our programs. In the case of the datetime library, it contains numerous useful modules so we'll use the from syntax to import several at once, like this:
from datetime import datetime, date, timeThis line will import the datetime, date, and time modules.
Code Examples
Study and practice the following code examples. Pay particular attention to the explanatory comments in the code as well.
# Examples of formatting dates and times
# First need to import libraries
from datetime import datetime, date, time
import calendar
# The first example we'll consider is how to get the
# current date and time. To do this we'll use the
# now() function of the datetime module.
current_datetime = datetime.now()
print(current_datetime)
# Also, let's check the data type of the output of
# the now() function ...
print(type(current_datetime))
# ... Note that this is not a string, but rather it
# is a datetime object so we will use numerous
# features of datetime to manipulate these objects
print()
# For example ...
print("Current Day:", current_datetime.day)
print("Current Month:", current_datetime.month)
print("Current Year:", current_datetime.year)
# ... we can use the day, month, and year attributes
# to get any of those components of the date stored
# in our variable.
print()
# The values for the day, month and year are useful,
# but we often want them formatted even more clearly
# for human readers. There are a few ways in which
# we can format the output of dates and time. A very
# common approach is to use format codes (see the
# Reference Materials Date & Time Format Codes page
# for a list the codes).
# Also, the strftime() method seen in the following examples
# is used to convert datetime object values into strings
# making it easy to concatenate those objects into output.
# As a reminder, here's the datetime in its original form...
print(current_datetime)
# ... and here are some examples of using the formatting codes
# to produce well-formatted date/time output ...
print("Year (4 digits):", current_datetime.strftime("%Y"))
print("Year (2 digits):", current_datetime.strftime("%y"))
print("Month (number with zero padding):", current_datetime.strftime("%m"))
print("Month (name, abbreviated):", current_datetime.strftime("%b"))
print("Month (full name):", current_datetime.strftime("%B"))
print("Day of the month (with zero padding):", current_datetime.strftime("%d"))
print("Day of the week (name, abbreviated):", current_datetime.strftime("%a"))
print("Day of the week (full name):", current_datetime.strftime("%A"))
print("Hour (24-hour clock, with zero padding):", current_datetime.strftime("%H"))
print("Hour (12-hour clock, with zero padding):", current_datetime.strftime("%I"))
print("Minute (with zero padding):", current_datetime.strftime("%M"))
print("Second (with zero padding):", current_datetime.strftime("%S"))
print("AM or PM:", current_datetime.strftime("%p"))
print("Locale's appropriate date and time:", current_datetime.strftime("%c"))
print("Full Date:", current_datetime.strftime("%A") + ", " +
current_datetime.strftime("%B") + " " +
current_datetime.strftime("%d") + ", " + current_datetime.strftime("%Y"))
print("Full Date and Time:", current_datetime.strftime("%m-%d-%Y %H:%M:%S"))Output
2024-03-11 00:20:01.591502
Current Day: 11
Current Month: 3
Current Year: 2024
2024-03-11 00:20:01.591502
Year (4 digits): 2024
Year (2 digits): 24
Month (number with zero padding): 03
Month (name, abbreviated): Mar
Month (full name): March
Day of the month (with zero padding): 11
Day of the week (name, abbreviated): Mon
Day of the week (full name): Monday
Hour (24-hour clock, with zero padding): 00
Hour (12-hour clock, with zero padding): 12
Minute (with zero padding): 20
Second (with zero padding): 01
AM or PM: AM
Locale's appropriate date and time: Mon Mar 11 00:20:01 2024
Full Date: Monday, March 11, 2024
Full Date and Time: 03-11-2024 00:24:35