Strings: A Deeper Look

What You Will Learn

• Format string content with f-strings and the format method.
• Concatenate and repeat strings.
• Remove whitespace from the beginning and end of strings.
• Change character case.
• Compare strings.
• Search for and replace substrings.
• Split strings into tokens and join strings together.
• Use character-testing methods such as isdigit() and isalpha().
• Use raw strings when backslashes should be treated literally.
• Create regular expressions for matching, validating, replacing and extracting text.
• Understand metacharacters, character classes, quantifiers, anchors and grouping.
• Use pandas with regular expressions for data cleaning and data munging.

Chapter Structure

8.1 Introduction

A string is a sequence of characters. You have already used strings for names, messages and input. Now we look at the operations that become especially useful when programs work with large amounts of text.

8.2 Formatting Strings

Formatting makes information easier to read. Python provides powerful formatting through f-strings and the older, still common str.format() method.

8.2.1 Presentation Types

A format specifier tells Python how a value should be displayed.

print(f'{17.489:.2f}')
print(f'{10:d}')
print(f'{65:c} {97:c}')

17.49
10
A a

8.2.2 Field Widths and Alignment

A field width reserves a number of character positions for the formatted value. Numbers are right-aligned by default, while strings are left-aligned by default.

print(f'[{27:10d}]')
print(f'[{"hello":10}]')
print(f'[{27:<10d}]')
print(f'[{"hello":>10}]')
print(f'[{27:^10d}]')

[        27]
[hello     ]
[27        ]
[     hello]
[    27    ]

8.2.3 Numeric Formatting

You can display signs, fill unused positions with zeros and group large numbers with commas.

print(f'{27:+10d}')
print(f'{27:+010d}')
print(f'{12345678:,d}')
print(f'{123456.78:,.2f}')

       +27
+000000027
12,345,678
123,456.78

8.2.4 String's format Method

The format() method was the traditional way to format strings before f-strings were introduced. You will still see it in older programs and documentation.

'{:.2f}'.format(17.489)
'{} {}'.format('Amanda', 'Cyan')
'{0} {0} {1}'.format('Happy', 'Birthday')
'{first} {last}'.format(first='Amanda', last='Gray')
'{last} {first}'.format(first='Amanda', last='Gray')

'17.49'
'Amanda Cyan'
'Happy Happy Birthday'
'Amanda Gray'
'Gray Amanda'

Arguments can be referenced by position starting at 0, or by keyword name.

8.3 Concatenating and Repeating Strings

The + operator joins strings. The * operator repeats a string.

s1 = 'happy'
s2 = 'birthday'

s1 += ' ' + s2
print(s1)

symbol = '>'
symbol *= 5
print(symbol)

happy birthday
>>>>>

8.4 Stripping Whitespace from Strings

Whitespace includes spaces, tabs and newline characters. Python provides three useful methods for removing whitespace from the ends of a string.

sentence = '\t \n This is a test string. \t\t \n'

print(sentence.strip())
print(sentence.lstrip())
print(sentence.rstrip())

8.5 Changing Character Case

print('happy birthday'.capitalize())
print('strings: a deeper look'.title())

Happy birthday
Strings: A Deeper Look

8.6 Comparison Operators for Strings

Strings can be compared with ==, !=, <, <=, > and >=. Python compares strings lexicographically using the underlying character values.

print(ord('A'))
print(ord('a'))

print('Orange' == 'orange')
print('Orange' != 'orange')
print('Orange' < 'orange')

65
97
False
True
True

8.7 Searching for Substrings

A substring is a sequence of adjacent characters inside a larger string.

Counting Occurrences

sentence = 'to be or not to be that is the question'

print(sentence.count('to'))
print(sentence.count('to', 12))
print(sentence.count('that', 12, 25))

2
1
1

Finding Positions

sentence = 'to be or not to be that is the question'

print(sentence.index('be'))
print(sentence.rindex('be'))
print('that' in sentence)
print('THAT' not in sentence)
print(sentence.startswith('to'))
print(sentence.endswith('question'))

3
16
True
True
True
True

8.8 Replacing Substrings

The replace() method searches for one substring and returns a new string in which matching occurrences are replaced.

values = '1\t2\t3\t4\t5'
print(values.replace('\t', ','))

print('one one one'.replace('one', 'two', 2))

1,2,3,4,5
two two one

The optional third argument limits how many replacements are performed.

8.9 Splitting and Joining Strings

When text is processed, we often break it into smaller pieces called tokens. Separators used to split data are often called delimiters.

Splitting

letters = 'A, B, C, D'

print(letters.split(', '))
print(letters.split(', ', 2))

['A', 'B', 'C', 'D']
['A', 'B', 'C, D']

split() without an argument separates on whitespace.

Joining

join() does the opposite: it combines an iterable of strings using the string on which join() is called as the separator.

letters_list = ['A', 'B', 'C', 'D']
print(','.join(letters_list))

print(','.join([str(i) for i in range(10)]))

A,B,C,D
0,1,2,3,4,5,6,7,8,9

partition() and rpartition()

partition(separator) returns a tuple containing the part before the separator, the separator itself and the part after it.

result = 'Amanda: 89, 97, 92'.partition(': ')
print(result)

url = 'http://www.deitel.com/books/PyCDS/table_of_contents.html'
rest, separator, document = url.rpartition('/')
print(document)
print(rest)

('Amanda', ': ', '89, 97, 92')
table_of_contents.html
http://www.deitel.com/books/PyCDS

splitlines()

splitlines() turns a multiline string into a list of lines.

lines = """This is line 1
This is line2
This is line3"""

print(lines.splitlines())
print(lines.splitlines(True))

['This is line 1', 'This is line2', 'This is line3']
['This is line 1\n', 'This is line2\n', 'This is line3']

8.10 Characters and Character-Testing Methods

Python does not have a separate character data type. A single character is simply a one-character string.

print('-27'.isdigit())
print('27'.isdigit())
print('A9876'.isalnum())
print('123 Main Street'.isalnum())
print('Hello'.isalpha())

False
True
True
False
True

8.11 Raw Strings

Backslashes introduce escape sequences such as \n and \t. Windows file paths and regular expressions can contain many backslashes, which can make ordinary strings harder to read.

file_path = 'C:\\MyFolder\\MySubFolder\\MyFile.txt'
print(file_path)

file_path = r'C:\MyFolder\MySubFolder\MyFile.txt'
print(file_path)

A raw string is written with an r before the opening quote. It treats backslashes as literal characters rather than starting ordinary escape sequences.

8.12 Introduction to Regular Expressions

A regular expression is a string that describes a pattern. Instead of searching for one exact word, you can describe a whole family of strings.

Regular expressions are useful for phone numbers, e-mail addresses, ZIP Codes and other structured text. They can also extract information from unstructured text and help clean or transform data.

8.12.1 re Module and Function fullmatch

Python's re module provides regular-expression functionality. re.fullmatch() checks whether the entire string matches a pattern.

import re

pattern = '02215'

print('Match' if re.fullmatch(pattern, '02215') else 'No match')
print('Match' if re.fullmatch(pattern, '51220') else 'No match')

Match
No match

Regular-Expression Metacharacters

Predefined Character Classes

Custom Character Classes

print(re.fullmatch(r'[aeiou]', 'a'))
print(re.fullmatch(r'[A-Z]', 'G'))
print(re.fullmatch(r'[a-zA-Z]', 'z'))

Examples:

• [aeiou] — one lowercase vowel.
• [A-Z] — one uppercase letter.
• [a-z] — one lowercase letter.
• [^a-z] — one character that is not a lowercase letter.

Quantifiers

Quantifiers control how many times a pattern element can occur.

print('Valid' if re.fullmatch(r'[A-Z][a-z]*', 'Wally') else 'Invalid')
print('Valid' if re.fullmatch(r'[A-Z][a-z]+', 'E') else 'Invalid')
print('Match' if re.fullmatch(r'\d{3,6}', '123456') else 'No match')
print('Match' if re.fullmatch(r'\d{3,6}', '1234567') else 'No match')

Valid
Invalid
Match
No match

8.12.2 Replacing Substrings and Splitting Strings

The re module's sub() function replaces text that matches a pattern. Its split() function tokenizes text using a regular-expression delimiter.

import re

print(re.sub(r'\t', ', ', '1\t2\t3\t4'))
print(re.sub(r'\t', ', ', '1\t2\t3\t4', count=2))

print(re.split(r',\s*', '1, 2, 3,4, 5,6,7,8'))
print(re.split(r',\s*', '1, 2, 3,4, 5,6,7,8', maxsplit=3))

1, 2, 3, 4
1, 2, 3	4
['1', '2', '3', '4', '5', '6', '7', '8']
['1', '2', '3', '4, 5,6,7,8']

8.12.3 Other Search Functions; Accessing Matches

import re

result = re.search('Python', 'Python is fun')
print(result.group() if result else 'not found')

result = re.search('fun$', 'Python is fun')
print(result.group() if result else 'not found')

contact = 'Wally White, Home: 555-555-1234, Work: 555-555-4321'
print(re.findall(r'\d{3}-\d{3}-\d{4}', contact))

for phone in re.finditer(r'\d{3}-\d{3}-\d{4}', contact):
    print(phone.group())

Python
fun
['555-555-1234', '555-555-4321']
555-555-1234
555-555-4321

Ignoring Case

Regular expressions are case-sensitive by default. The re.IGNORECASE flag can make matching case-insensitive.

result = re.search('Sam', 'SAM WHITE', flags=re.IGNORECASE)
print(result.group() if result else 'not found')

SAM

Beginning and End Anchors

^ restricts a match to the beginning of a string, while $ restricts a match to the end.

print(re.search('^Python', 'Python is fun').group())
print(re.search('fun$', 'Python is fun').group())

Python
fun

Capturing Substrings with Groups

Parentheses ( ) capture parts of a match. The resulting match object can provide the captured groups.

text = 'Charlie Cyan, e-mail: demo1@deitel.com'
pattern = r'([A-Z][a-z]+ [A-Z][a-z]+), e-mail: (\w+@\w+\.\w{3})'

result = re.search(pattern, text)

print(result.groups())
print(result.group())
print(result.group(1))
print(result.group(2))

('Charlie Cyan', 'demo1@deitel.com')
Charlie Cyan, e-mail: demo1@deitel.com
Charlie Cyan
demo1@deitel.com

8.13 Intro to Data Science: Pandas, Regular Expressions and Data Munging

Real-world data is often not ready for analysis. It may contain missing values, bad values, duplicates, inconsistent formats or unnecessary information.

Data Munging and Data Wrangling

Data munging and data wrangling refer to preparing data for analysis. Important work includes cleaning data and transforming it into useful formats.

Cleaning Example: Missing Temperature

Suppose a patient's temperature readings are:

['Brown, Sue', 98.6, 98.4, 98.7, 0.0]

If 0.0 represents a missing sensor reading and is incorrectly treated as a real temperature, the calculated average becomes misleading. The chapter uses this example to show why missing and bad values must be handled carefully.

Validating Data with pandas and Regular Expressions

A pandas Series provides a str attribute with string-processing and regular-expression methods. This allows a pattern to be applied to an entire Series without explicitly writing a loop.

import pandas as pd

zips = pd.Series({
    'Boston': '02215',
    'Miami': '3310'
})

print(zips)
print(zips.str.match(r'\d{5}'))

Boston    02215
Miami      3310
dtype: object

Boston     True
Miami     False
dtype: bool

Here, \d{5} requires exactly five digits. Boston passes the test; Miami does not.

match() vs contains() in pandas

Use match() when the Series element itself must match the pattern. Use contains() when you want to know whether the value contains a substring matching the pattern.

cities = pd.Series([
    'Boston, MA 02215',
    'Miami, FL 33101'
])

print(cities.str.contains(r' [A-Z]{2} '))
print(cities.str.match(r' [A-Z]{2} '))

0    True
1    True
dtype: bool

0    False
1    False
dtype: bool

Reformatting Data

The chapter also shows how regular expressions can transform 10-digit phone numbers into the format ###-###-####.

import re

def get_formatted_phone(value):
    result = re.fullmatch(r'(\d{3})(\d{3})(\d{4})', value)
    return '-'.join(result.groups()) if result else value

contacts = [
    ['Mike Green', 'demo1@deitel.com', '5555555555'],
    ['Sue Brown', 'demo2@deitel.com', '5555551234']
]

contactsdf = pd.DataFrame(
    contacts,
    columns=['Name', 'Email', 'Phone']
)

formatted_phone = contactsdf['Phone'].map(get_formatted_phone)
contactsdf['Phone'] = formatted_phone

print(contactsdf)

         Name              Email         Phone
0  Mike Green  demo1@deitel.com  555-555-5555
1   Sue Brown  demo2@deitel.com  555-555-1234

Quick Concept Map

Common Mistakes

Remember These Points

Revision Questions

1. Why are strings called immutable in Python?
2. What is the difference between strip(), lstrip() and rstrip()?
3. What is a substring?
4. What is the difference between find() and index()?
5. How does join() work?
6. What is a raw string and why is it useful for regular expressions?
7. What does \d mean in a regular expression?
8. What is the difference between * and + in regex?
9. What does {3,6} mean?
10. What is the difference between re.fullmatch() and re.search()?
11. What do ^ and $ mean?
12. Why are parentheses used in a regular expression?
13. What is data munging?
14. In pandas, when would you use str.match() and when would you use str.contains()?

Practice Programs

Chapter Wrap-Up

This chapter takes Python strings from basic text values to practical text-processing tools. You learned detailed string formatting, concatenation and repetition, whitespace removal, case conversion, comparisons, substring searching, replacement, splitting and joining, character testing and raw strings.

The chapter then introduces regular expressions through the re module. You learned how patterns, character classes, quantifiers, anchors and groups can be used to validate, search, extract, replace and split text.

Finally, the data-science section connects these ideas to pandas. Regular expressions can validate Series values and help transform messy real-world data into consistent formats. These skills prepare you for later work with files, CSV data and natural language processing.

Teaching edition note: This HTML is a beginner-friendly explanation based on the chapter's organization and concepts. It uses simplified explanations and original examples rather than reproducing the book verbatim.