Python String Methods split, join, replace, format

Python in Python is best learned by connecting the rule to an automation script. Start with the smallest function or script, observe the output, and then add one realistic constraint so the concept becomes practical.

The key habit for this lesson is to watch input value and returned object as it changes. That makes the topic easier to debug, easier to explain in interviews, and easier to use in real code without memorizing isolated syntax.

What is a String?

A string is a sequence of characters enclosed in single, double, or triple quotes. Strings are immutable - once created, they cannot be changed in place.

Creating Strings

s1 = 'single quotes'
s2 = "double quotes"
s3 = '''triple single - spans
multiple lines'''
s4 = """triple double - also
multi-line"""

# Escape characters
tab    = "Hello\tWorld"   # tab
newline = "Line1\nLine2"  # newline
quote  = "She said \"hi\""
backslash = "C:\\Users\\Alice"

# Raw string - backslashes are literal
path = r"C:\Users\Alice\Documents"
regex = r"\d+\.\d+"

print(len("Python"))   # 6
print(type("hello"))   # <class 'str'>

Indexing and Slicing

Indexing & Slicing

s = "Python"
#    P y t h o n
#    0 1 2 3 4 5   (positive index)
#   -6-5-4-3-2-1   (negative index)

print(s[0])     # P
print(s[-1])    # n
print(s[2])     # t

# Slicing: s[start:stop:step]
print(s[1:4])   # yth
print(s[:3])    # Pyt
print(s[3:])    # hon
print(s[::2])   # Pto  (every 2nd char)
print(s[::-1])  # nohtyP  (reversed)

# Strings are immutable
# s[0] = "J"  # TypeError!
# Create a new string instead:
new_s = "J" + s[1:]
print(new_s)    # Jython

String Formatting

name = "Alice"
age = 25
pi = 3.14159

# f-strings (Python 3.6+) - recommended
print(f"Hello, {name}! You are {age} years old.")
print(f"Pi = {pi:.2f}")          # 2 decimal places
print(f"{age:05d}")               # 00025 (zero-padded)
print(f"{'left':<10}|")          # left-aligned
print(f"{'right':>10}|")         # right-aligned
print(f"{'center':^10}|")        # centered
print(f"{1_000_000:,}")          # 1,000,000 (thousands separator)

# format() method
print("Hello, {}! Age: {}".format(name, age))
print("Hello, {name}!".format(name="Bob"))

# % formatting (old style)
print("Hello, %s! Age: %d" % (name, age))
print("Pi = %.2f" % pi)

# Multiline f-string
report = (
    f"Name: {name}\n"
    f"Age:  {age}\n"
    f"Pi:   {pi:.4f}"
)
print(report)

String Methods

Method	Description	Example
upper()	Uppercase	"hi".upper() -> "HI"
lower()	Lowercase	"HI".lower() -> "hi"
title()	Title case	"hello world".title() -> "Hello World"
strip()	Remove leading/trailing whitespace	" hi ".strip() -> "hi"
lstrip() / rstrip()	Strip left or right only
replace(old, new)	Replace substring	"abc".replace("b","x") -> "axc"
split(sep)	Split into list	"a,b,c".split(",") -> ['a','b','c']
join(iterable)	Join list into string	",".join(["a","b"]) -> "a,b"
find(sub)	Index of first occurrence (-1 if not found)	"hello".find("l") -> 2
index(sub)	Like find but raises ValueError
count(sub)	Count occurrences	"hello".count("l") -> 2
startswith(s)	Check prefix	"hello".startswith("he") -> True
endswith(s)	Check suffix	"hello".endswith("lo") -> True
isdigit()	All digits?	"123".isdigit() -> True
isalpha()	All letters?	"abc".isalpha() -> True
isalnum()	Letters or digits?
zfill(n)	Zero-pad to width n	"42".zfill(5) -> "00042"
center(n)	Center in width n	"hi".center(10)

Methods in Action

text = "  Hello, World!  "

print(text.strip())           # "Hello, World!"
print(text.lower())           # "  hello, world!  "
print(text.upper())           # "  HELLO, WORLD!  "
print(text.replace("World", "Python"))  # "  Hello, Python!  "

csv = "apple,banana,cherry"
fruits = csv.split(",")
print(fruits)                 # ['apple', 'banana', 'cherry']
print(" | ".join(fruits))     # apple | banana | cherry

sentence = "the quick brown fox"
print(sentence.title())       # The Quick Brown Fox
print(sentence.count("the"))  # 1
print(sentence.find("quick")) # 4
print(sentence.startswith("the"))  # True

# Method chaining
clean = "  HELLO WORLD  ".strip().lower().replace(" ", "_")
print(clean)   # hello_world

String Operations

Operations

# Concatenation
first = "Hello"
last = "World"
full = first + ", " + last + "!"
print(full)   # Hello, World!

# Repetition
print("ha" * 3)   # hahaha
print("-" * 30)   # separator line

# Membership
print("ell" in "Hello")      # True
print("xyz" not in "Hello")  # True

# Iteration
for char in "Python":
    print(char, end=" ")   # P y t h o n

# Convert to list of chars
chars = list("Python")
print(chars)   # ['P', 'y', 't', 'h', 'o', 'n']

# Multiline string as template
template = """
Dear {name},

Your order #{order_id} has been shipped.
Expected delivery: {date}

Thanks,
The Team
"""
print(template.format(name="Alice", order_id=12345, date="June 20"))

Applied guide for Python

Use Python when the program needs a clear answer to a specific problem, not because the keyword looks familiar. In a real Python task, first name the input, then name the transformation, then name the output. This small discipline shows whether the topic is being used correctly or only copied from an example.

A reliable practice flow is: create the smallest working function or script, add one normal case, add one edge case such as empty strings, spaces, and missing separators, and then confirm the result with traceback and printed inspection. If the result surprises you, reduce the code until the behavior is visible again.

The most common trap here is assuming the text has the expected length or delimiter. Avoid it by writing one sentence before the code that explains why Python is the right choice. After the code runs, verify the lesson by doing this: print both the value and its length.

Identify the exact problem solved by Python.
Trace input value and returned object before and after the main operation.
Keep one intentionally broken version and explain the fix.
Connect the example to an automation script so the idea feels concrete.

Key Takeaways

I can explain where Python fits inside an automation script.
I can point to the exact input value and returned object affected by this topic.
I tested a normal case and an edge case involving empty strings, spaces, and missing separators.
I verified the result with traceback and printed inspection instead of assuming it worked.
I can describe the main mistake: assuming the text has the expected length or delimiter.

Common Mistakes to Avoid

WRONG Assuming the text has the expected length or delimiter.

RIGHT Write the expected behavior first, then make the example prove it.

A one-line expectation turns the code from copied syntax into a testable idea.

WRONG Practicing only the perfect input.

RIGHT Also test empty strings, spaces, and missing separators before considering the lesson complete.

The edge case is where most interview follow-up questions begin.

WRONG Looking only at the final output.

RIGHT Trace input value and returned object through each important step.

Tracing makes debugging faster because you can see the first incorrect state.

Practice Tasks

Build one small function or script that demonstrates Python in an automation script.
Change the example to include empty strings, spaces, and missing separators and record the difference.
Break the example by deliberately assuming the text has the expected length or delimiter, then write the corrected version.
Explain the finished example in five bullet points: input, operation, output, failure case, and verification.

Frequently Asked Questions

When should I use Python?

Use it when the problem matches the behavior shown in the example and when the result can be verified through traceback and printed inspection.

How do I avoid mistakes in Python?

Start with a tiny case, then test empty strings, spaces, and missing separators. The main warning sign is assuming the text has the expected length or delimiter.

How can I revise Python quickly?

Trace input value and returned object, predict the result, run the example, and compare your prediction with the actual output.

Previous Next

Python String Methods split, join, replace, format