Formatting
Strings
You can format
strings in a number of ways using Python. The main emphasis of formatting is to
present the string in a form that is both pleasing to the user and easy to
understand. Formatting doesn’t mean adding special fonts or effects in this
case, but refers merely to the presentation of the data. For example, the user
might want a fixed-point number rather than a decimal number as output.
You have quite a
few ways to format strings and you see a number of them as the book progresses.
However, the focus of most formatting is the format() function. You create a
formatting specification as part of the string and then use the format()
function to add data to that string. A format specification may be as simple as
two curly brackets {} that specify a placeholder for data. You can number the
placeholder to create special effects. For example, {0} would contain the first
data element in a string. When the data elements are numbered, you can even
repeat them so that the same data appears more than once in the string.
The formatting
specification follows a colon. When you want to create just a formatting
specification, the curly brackets contain just the colon and whatever
formatting you want to use. For example, {:f} would create a fixed-point number
as output. If you want to number the entries, the
number that
precedes the colon: {0:f} creates a fixed-point number output for data element
one. The formatting specification follows this form, with the italicized
elements serving as placeholders here:
[[fill]align][sign][#][0][width][,][.precision][type]
The specification
at https://docs.python.org/3/library/string. html provides you with the
in-depth details, but here’s an overview of what the various entries mean:
fill: Defines the fill character used when
displaying data that is too small to fit within the assigned space.
align: Specifies the alignment of data within
the display space. You can use these alignments:
<: Left aligned
>: Right aligned
^: Centered
=: Justified
sign: Determines the use of signs for the
output:
+: Positive numbers have a plus sign and
negative numbers have a minus sign.
-: Negative numbers have a minus sign.
<space>: Positive numbers are preceded
by a space and negative numbers have a minus sign.
#: Specifies that the output should use the
alternative display format for numbers. For example, hexadecimal numbers will
have a 0x prefix added to them.
0: Specifies that the output should be sign
aware and padded with zeros as needed to provide consistent output.
width: Determines the full width of the data
field (even if the data won’t fit in the space provided).
,: Specifies that numeric data should have
commas as a thousands separator.
.precision: Determines the number of
characters after the decimal point.
type: Specifies the output type, even if the
input type doesn’t match. The types are split into three groups:
String: Use an s or nothing at all to specify
a string.
Integer: The integer types are as follows: b
(binary); c (character); d (decimal); o (octal); x (hexadecimal with lowercase
letters);
X (hexadecimal
with uppercase letters); and n (locale-sensitive decimal that uses the
appropriate characters for the thousands separator).
Floating point: The floating-point types are
as follows: e (exponent using a lowercase e as a separator); E (exponent using
an upper-case E as a separator); f (lowercase fixed point); F (uppercase fixed
point); g (lowercase general format); G (uppercase general format); n
(local-sensitive general format that uses the appropriate charac-ters for the
decimal and thousands separators); and % (percentage).
The formatting
specification elements must appear in the correct order or Python won’t know
what to do with them. If you specify the alignment before the fill character,
Python displays an error message rather than performing the required
formatting. The following steps help you see how the formatting specification
works and demonstrate the order you need to follow in using the various
formatting specification criteria.
Open a Python File window.
You see an editor
in which you can type the example code.
Type the following code into the window —
pressing Enter after each line:
Formatted =
"{:d}" print(Formatted.format(7000))
Formatted =
"{:,d}" print(Formatted.format(7000))
Formatted =
"{:^15,d}" print(Formatted.format(7000))
Formatted =
"{:*^15,d}" print(Formatted.format(7000))
Formatted =
"{:*^15.2f}" print(Formatted.format(7000))
Formatted =
"{:*>15X}" print(Formatted.format(7000))
Formatted =
"{:*<#15x}" print(Formatted.format(7000))
Formatted =
"A {0} {1} and a {0} {2}." print(Formatted.format("blue",
"car", "truck"))
The example starts
simply with a field formatted as a decimal value. It then adds a thousands
separator to the output. The next step is to
make the field
wider than needed to hold the data and to center the data within the field.
Finally, the field has an asterisk added to pad the output.
Of course, there
are other data types in the example. The next step is to display the same data
in fixed-point format. The example also shows the output in both uppercase and
lowercase hexadecimal format. The
uppercase output
is right aligned and the lowercase output is left aligned.
Finally, the
example shows how you can use numbered fields to your advantage. In this case,
it creates an interesting string output that repeats one of the input values.
Choose Run➪Run Module.
You see a Python
Shell window open. The application outputs data in various forms.
0 comments:
Post a Comment