String Operations

In the first lesson, you learned about the String data type. A String holds text values and can be enclosed in single, double, or triple quotes. Triple quotes (single or double) are primarily used for strings that span multiple lines.

double_quote_word = "Python"
print(double_quote_word)

single_quote_word = 'Python'
print(single_quote_word)

multi_line_word = '''First line
  Second line'''  # White spaces are preserved
print(multi_line_word)

multi_line_word = """First line
  Second line"""  # Same as the triple-single-quote example
print(multi_line_word)

There are many operations you can perform on a String object.

Here is a list of common operations using the variable word = 'Python':

String Concatenation

You can join strings together using the plus (+) operator.

a = 'abc' + "def"
print(a) # Output: abcdef

However, you cannot directly add a string to other data types (like integers or Booleans).

a = 'abc' + 10 # Invalid a = 'abc' + True # Invalid

To combine them, you must first convert the other data types using the str() function:

a = "abc" + str(10) + str(True)
print(a)  # Output: abc10True

String Special Cases

Sometimes you need to handle characters that have special meaning to the Python parser, such as quotes or newlines.

Quotes within Strings

If you need to include a quote inside a string:

• Enclose in opposite quotes: Use double quotes to wrap a string containing a single quote (e.g., "I'm having fun").
• Use Escape Sequences: Use a backslash (\) to "escape" the character's special meaning.

Escape Sequences (\)

The backslash tells the interpreter to treat the following character as literal text rather than code.

# Escaping a single quote
message = 'I\'m having fun'
print(message)

# Other common escape sequences
print("a\tb")  # Adds a Tab
print("a\nb")  # Adds a Newline

Raw Strings

If you want to represent a string exactly as it is written (ignoring escape sequences), prefix it with r or R. This is very useful for file paths or regular expressions.

print(r"a\tb")  # Output: a\tb (the \t is not treated as a tab)

More Examples

Strings are a type of sequence. You can use the built-in str() function to convert any object into its textual representation.

Common String Methods

Using the in Keyword in Conditionals

The in operator is a clean way to check for the presence of a substring within a larger string.

if "cat" in "caterpillar":
    print("Substring found!")

String Formatting

String formatting is the process of creating dynamic strings by inserting variables or expressions into a template. Instead of manually joining pieces of text with the + operator, formatting allows you to define placeholders within a string that are later filled with data. This makes your code cleaner and easier to maintain, especially when dealing with complex messages or specific numerical displays (like rounding decimals).

Python provides several ways to format strings. While the .format() method is common, f-strings (formatted string literals) are the modern standard introduced in Python 3.6.

F-strings (Modern Standard)

F-strings are preferred because they are more concise, easier to read, and faster than older methods. They allow you to embed expressions directly inside string literals by prefixing the string with f or F and using curly braces {} as placeholders.

name = "Jane"
age = 21
# Direct variable embedding
message = f"My name is {name} and I am {age} years old."
print(message)

# Expressions inside braces
data = {"first": "Jane", "last": "Doe"}
print(f"User: {data['first']} {data['last']}")

Numerical Formatting with F-strings

F-strings make it easy to format numbers for readability (e.g., adding comma separators or rounding decimals).

Conversion Codes

The following codes can be used inside the {} placeholders:

• s: String
• d: Decimal integer (base-10)
• f: Floating point
• c: Character
• b: Binary
• o: Octal
• x / X: Hexadecimal (lowercase/uppercase)
• e: Exponent notation

Note: For floating-point numbers, use f. For whole numbers, use d. You can combine these with commas for thousands separators.

The .format() Method (Legacy)

Before f-strings, the .format() method was the standard. It works by placing {} placeholders in a string and passing values as arguments.

Syntax: str.format(arguments)

Hands-on Exercises

Exercise 1: Metric Reporter (f-strings)

You are building an automatic report generator for marketing metrics.

• Campaign Name: "winter_sale"
• Clicks: 12500
• Conversion Rate: 3.4567 (in percent)

Write a Python program using f-strings to print the following output: Campaign 'Winter Sale' generated 12,500 clicks with a 3.46% conversion rate.

1. Store the metrics in variables.
2. Format the campaign name to title case (.title()).
3. Replace the underscore with a space (.replace("_", " ")).
4. Format the conversion rate to show exactly 2 decimal places (e.g. :.2f).
5. Print the formatted message.

# Write your code below and click Run Code

campaign = "winter_sale"
clicks = 12500
conv_rate = 3.4567

# Format and replace
clean_name = campaign.replace("_", " ").title()

# Using f-string formatting
message = f"Campaign '{clean_name}' generated {clicks:,} clicks with a {conv_rate:.2f}% conversion rate."
print(message)
# Output: Campaign 'Winter Sale' generated 12,500 clicks with a 3.46% conversion rate.

Exercise 2: Serial Code Sanitization

You receive messy inputs from database imports: serial_raw = " \t sn-992a-01B\n "

Write a Python program to:

1. Strip all leading and trailing whitespaces, tabs, and newlines (.strip()).
2. Convert the entire string to uppercase (.upper()).
3. Check and print if the cleaned string starts with the prefix "SN-" (.startswith()).
4. Print the final cleaned string.

# Write your code below and click Run Code

serial_raw = "   \t sn-992a-01B\n   "

# 1. Strip
clean_serial = serial_raw.strip()

# 2. Upper case
clean_serial = clean_serial.upper()

# 3. Check prefix
is_valid_prefix = clean_serial.startswith("SN-")

print("Cleaned Serial:", clean_serial) # "SN-992A-01B"
print("Has valid prefix:", is_valid_prefix) # True