Basic / Intermediate
Learn Python Series):Handling strings is an essential part of coding in Python, as is the case with most, if not all, programming languages. Python has a number of built-in methods to handle strings, to manipulate / change them into something else, and to print and/or return them for further processing.
In this tutorial episode, we will cover creating strings, concatenating and repeating strings, the indexing and slicing of strings - which is by the way an essential ingredient to working with all sequence types -, string formatting, and in Handling Strings Part 2 I will cover a number of commonly used string functions. I hope you'll again find this Learn Python Series episode useful!
Strings are a (text sequence) data type in Python, and a string consists of a number of characters which could be letters, but also numbers, spaces, punctuation such as commas and exclamation marks, or other characters. Strings are enclosed within single quotes ' or double quotes ", as long as the opening and closing quote are the same. To create a string, you just assign its value to a variable, like so:
str1 = 'I am a string enclosed in single quotes'
str2 = "And I'm a string as well"
Nota bene 1: please note how I'm in str2 contains a single quote which is part of the total string, and is not seen as the ending of the total string, because the opening quote and the closing quote are both double quotes and the quote in I'm is a single quote being a part of the total string itself. The take-away here is that quotes not only function as enclosing characters but can be a part of a string itself.
Nota bene 2: please also note that in case you would like to use single quotes as enclosing characters for str2, that that's also possible by escaping the single quote I'm by putting the \ backslash character before the single quote you want to escape, like so:
str3 = 'And I\'m a string as well'
Escaping that single quote, in this case means "This single quote is not the end of the total string, please do not interpret this single quote as the end of the string but as a part of the string".
Using the + operator we can "glue together" multiple strings to form a larger string, which we can then print as one string. This works with concatenating string variables as well as with concatenating string values:
part1 = "This is the f"
part2 = "irst part of th"
part3 = "e total string"
# Concatenate like this,
total = part1 + part2 + part3
print(total)
# This is the first part of the total string
# or like that,
print(part1 + part2 + part3)
# This is the first part of the total string
# or like so:
print("We could also" + " conc" + "atenate like so!")
# We could also concatenate like so!
This is the first part of the total string
This is the first part of the total string
We could also concatenate like so!
Nota bene 3: please note that string concatenation only works when all concatenated variables are of the same string data type. In case you try to concatenate (and then print) a string and an integer, you will get an error. But it is a common use case to wanting to print both text and numbers. In such a situation use explicit type conversion, meaning convert the number to a string prior to concatenating it to another string. Observe the following two examples:
# Gives error
name = 'Lionel Messi'
club = 'Barcelona'
shirt_number = 10
print(name + ' currently plays for ' + club +
' wearing shirt number ' + shirt_number)
# ---------------------------------------------------------------------------
# TypeError Traceback (most recent call last)
# in ()
# 4
# 5 print(name + ' currently plays for ' + club +
# ----> 6 ' wearing shirt number ' + shirt_number)
#
# TypeError: must be str, not int
# Correct concatenation, all of data type string
name = 'Lionel Messi'
club = 'Barcelona'
shirt_number = 10
print(name + ' currently plays for ' + club +
' wearing shirt number ' + str(shirt_number)) # int converted to str before concatenation
Lionel Messi currently plays for Barcelona wearing shirt number 10
Using the * operator, we can repeatedly concatenate strings, like so:
str4 = 'Blah!'
print(str4 * 3)
# Blah!Blah!Blah!
print('Repeat after me:', 'Ooh!'*5)
# Repeat after me: Ooh!Ooh!Ooh!Ooh!Ooh!
Blah!Blah!Blah!
Repeat after me: Ooh!Ooh!Ooh!Ooh!Ooh!
The built-in Python function len() also works on strings, returning the string length, which means, on strings, the amount of characters contained in the string (of course including spaces).
str5 = 'To be, or not to be? That is the question'
print(len(str5))
# 41
41
Standard Python does not include a "character" data type, however, individual characters are treated as strings with a length of 1. A (sequence of) character(s) are therefore treated as substrings. In order to access a substring inside a larger string, you can use the square brackets [] notation for slicing the string using an index number for one character or an index range (slice) for multiple characters.
Observe the following code:
str6 = "This is another string"
print(str6) # print the total string
# This is another string
print(str6[0]) # print the first character, having index number 0
# T
print(str6[0:4]) # print the index range [0:4], including index 0, EXCLUDING index 4
# This
print(str6[:4]) # by omitting the start index, you slice from the beginning
# This
print(str6[8:]) # and by omitting the end index, you slice INCLUDING the last character
# another string
This is another string
T
This
This
another string
It is also possible to use negative index numbers for string slicing. The last character of a string can be accessed with index number -1, the one before that with index number -2, et cetera.
Nota bene 4: please note that in order to include the last character of a string using slicing, you must omit the end index number.
str6 = "This is another string"
print(str6[-1]) # print the last character of the string
# g
print(str6[-6:]) # slice the last 6 characters of the string
# string
print(str6[-6:-1]) # slice doesn't include the last character
# strin
g
string
strin
Regarding string slicing, it's also possible to include an optional third slice parameter called the stride, which is like a "step" and can be negative for reversing the order of characters. Up until here we've been omitting the stride parameter, which we can, because Python defaults to a stride of 1.
On how to use the stride parameter explicitely, regard the following code:
str6 = "This is another string"
print(str6[::1]) # same as print(str6)
# This is another string
print(str6[::2]) # print the whole string starting at index 0,
# but skip every other character
# Ti saohrsrn
print(str6[::-1]) # print the whole string backward
# gnirts rehtona si sihT
This is another string
Ti saohrsrn
gnirts rehtona si sihT
Fun fact: Strides can be used for (simple) "cryptography", where a seemingly "Gibberish" string may in fact contain hidden messages! For example:
gibberish_msg = """!3*oJ6iFupOGiF6cNFSHU 6dmVhoKUrTvfHi
KteBrgHvaIgsX$snTeIgmV0 HvnYGembdJRd*&i$6h&6 &5a*h BGsF@iGv NhsIgiYdh67T"""
print(gibberish_msg[::-3])
# This is a hidden message from Scipio!
This is a hidden message from Scipio!
Thus far we've only used the print() function by passing it one or more arguments. But there exist various ways to format the print output. Let's briefly review some of them.
printf string formattingUnlike the C language, in Python there is no printf() or sprintf() function, but Python's print() function does support the same type of behavior by using operator overloading on the modulo % operator to perform string formatting (and thus has nothing to do with the "regular" modulo functionality: to calculate numerical division remainders). Overloaded output formatting, utilizing placeholders, works like so:
Usage: %[flags][width][.precision]type
print('The number %d divided by %d equals %.2f' % (15, 2, 15/2))
# The number 15 divided by 2 equals 7.50
The number 15 divided by 2 equals 7.50
Explanation:
the print() function first contains a format string with 3 placeholders: %d, %d and %.2f,
then comes the modulo overloader %,
then comes a tuple (15, 2, 15/2), holding the same amount of values as there are placeholders, and in the same order,
the first and second placeholders %d are so-called signed integer decimals,
the third placeholder %.2f is a floating point decimal with precision .2 (= 2 decimal places: 7.50),
while printing the placeholders are replaced by their corresponding tuple values.
The format() string method
This is the new, (well, added first in Python 2.6), more "Pythonic" way to format strings. It functions more-or-less the same as the C-like string formatting explained above:
format() method in which comma-separated values are placed,{},format() method,format() method is used, but the format codes can hold positional parameters as well, either an index number or a keyword argument, making the format string more flexible than its C-like twin string formatter,[width][.precision]type as well.Examples:
print('I like {} better than {}'.format('Steem', 'SBD'))
# I like Steem better than SBD
print('I like {1} better than {0}'.format('Steem', 'SBD'))
# I like SBD better than Steem
print('I like {btc} better than {alt}'.format(alt='Tether', btc='Bitcoin'))
# I like Bitcoin better than Tether
print('The number {0} divided by {1} equals {2:.2f}'.format(15, 2, 15/2))
# The number 15 divided by 2 equals 7.50
I like Steem better than SBD
I like SBD better than Steem
I like Bitcoin better than Tether
The number 15 divided by 2 equals 7.50
Python's standard and string libraries have (at least) 40 more built-in methods (functions) available for manipulating strings, and we'll cover how to use (some of) them. And later on, combined with other Python language constructs, we'll cover how to combine multiple string methods to define new, self-built, functions!