Python can manipulate text (represented by type str, so-called “strings”) as well as numbers. This includes characters “!”, words “rabbit”, names “Paris”, sentences “Got your back.”, etc. “Yay! :)”. They can be enclosed in single quotes (‘…’) or double quotes (“…”)
To quote a quote, we need to “escape” it, by preceding it with \. Alternatively, we can use the other type of quotation marks:
In the Python shell, the string definition and output string can look different. The print() function produces a more readable output, by omitting the enclosing quotes and by printing escaped and special characters:
If you don’t want characters prefaced by \ to be interpreted as special characters, you can use raw strings by adding an r before the first quote:
There is one subtle aspect to raw strings: a raw string may not end in an odd number of \ characters
String literals can span multiple lines. One way is using triple-quotes: “””…””” or ”’…”’. End-of-line characters are automatically included in the string, but it’s possible to prevent this by adding a \ at the end of the line. In the following example, the initial newline is not included:
Strings can be concatenated (glued together) with the + operator, and repeated with *:
Note :# 3 times ‘un’, followed by ‘ium’
Two or more string literals (i.e. the ones enclosed between quotes) next to each other are automatically concatenated.
This only works with two literals though, not with variables or expressions:
If you want to concatenate variables or a variable and a literal, use +:
Strings can be indexed (subscripted), with the first character having index 0. There is no separate character type; a character is simply a string of size one:
Note that since -0 is the same as 0, negative indices start from -1.
In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain a substring:
Slice indices have useful defaults; an omitted first index defaults to zero, an omitted second index defaults to the size of the string being sliced.
Note how the start is always included, and the end always excluded. This makes sure that s[:i] + s[i:] is always equal to s:
One way to remember how slices work is to think of the indices as pointing between characters, with the left edge of the first character numbered 0. Then the right edge of the last character of a string of n characters has index n, for example:
he first row of numbers gives the position of the indices 0…6 in the string; the second row gives the corresponding negative indices. The slice from i to j consists of all characters between the edges labeled i and j, respectively.
For non-negative indices, the length of a slice is the difference of the indices, if both are within bounds. For example, the length of word[1:3] is 2.
Attempting to use an index that is too large will result in an error:
However, out of range slice indexes are handled gracefully when used for slicing:
Python strings cannot be changed — they are immutable. Therefore, assigning to an indexed position in the string results in an error:
If you need a different string, you should create a new one:
The built-in function len() returns the length of a string:
This section contains examples of the str.format() syntax and comparison with the old %-formatting.
In most of the cases the syntax is similar to the old %-formatting, with the addition of the {} and with : used instead of %. For example, ‘%03.2f’ can be translated to ‘{:03.2f}’.
The new format syntax also supports new and different options, shown in the following examples.
Accessing arguments by name:
Accessing arguments’ attributes:
Accessing arguments’ items:
Replacing %s and %r:
Aligning the text and specifying a width:
Replacing %+f, %-f, and % f and specifying a sign:
