Python Strings: f-Strings, Slicing, and Every String Method You'll Use

Text, But With Methods

A Python string is a sequence of characters, and you'll use strings more than any other type. Every name, label, message, URL, file path, and API response lives in a string at some point.

Create one with quotes — single, double, or triple:

Single and double quotes are interchangeable. Use whichever keeps you from having to escape a character. "don't" is clean; 'don\'t' needs a backslash.

Strings are immutable. Once a string exists, you can't change a character of it in place. Every operation that looks like it changes a string actually returns a new one. This is why you'll write text = text.upper() rather than just text.upper() — without the reassignment, the new uppercase string would be thrown away.

Joining and Repeating

Two operators do most of the string combining you'll need:

+ concatenates strings. * repeats a string. Both return a new string.

Concatenating many pieces with + gets ugly fast. When you're mixing values of different types into a message, reach for f-strings instead — see the next section.

f-Strings: The Way You'll Usually Format

Put an f in front of the opening quote and the string becomes a template. Anything in {...} gets replaced with the value of that expression:

You can put any expression inside the braces — variables, arithmetic, method calls, function calls. Keep them simple, though; if you're tempted to cram a three-line calculation into {...}, compute it into a named variable first.

f-strings also support format specifiers after a colon, for controlling number formatting, padding, and alignment:

These format specs are the same ones str.format() uses and are worth a quick skim once you're comfortable with the basics. You don't need them for day-one code.

Slicing: Pick a Piece

Strings are indexable like sequences. Each character has a zero-based position, and you can grab one character or a range:

The pattern [start:stop:step] shows up in lists and other sequences too, so investing a few minutes to internalise it pays off everywhere.

Two things worth calling out:

• The stop index is exclusive: word[0:2] includes indices 0 and 1, not 2.
• Negative indices count from the end: -1 is the last character, -2 the one before, and so on.

How to Reverse a String

Strings don't have a .reverse() method — they're immutable — but slicing with a step of -1 gets the job done in one line:

word[::-1] reads as "from start to end, step backwards by 1." The result is a brand-new string; the original is untouched. If you need to iterate the characters in reverse without materialising a new string, reversed(word) returns a lazy iterator.

How to Check a String's Length

len(text) returns the number of characters:

Note that len counts Unicode code points, not bytes. len("café") is 4, not 5, even though the UTF-8 encoding takes more bytes — which is usually what you want.

How to Check If a String Contains a Substring

The in operator is the idiomatic check, and it reads like English:

For case-insensitive checks, normalise both sides first:

If you need the position, not just a yes/no, use .find() — it returns the index or -1 when the substring isn't there.

Common String Methods

Strings have dozens of methods. You'll reach for this handful constantly:

Splitting and joining:

.split(separator) turns a string into a list. separator.join(list_of_strings) glues it back together. These two methods carry a disproportionate amount of real-world string work.

One more useful pair:

That's a parser for a single-line config entry, written in three lines. Small strings, big leverage.

Checking What's Inside

Several methods return booleans, useful in if conditions:

Use these sparingly — they don't handle Unicode quirks in all the ways you might expect. For anything beyond ASCII, either lean on the regex module or the unicodedata module.

Escaping Special Characters

Some characters need a backslash to appear inside a string:

If you're writing Windows paths or regexes, raw strings make life easier. Put an r in front of the quote and backslashes stop being escape characters:

Strings Are Everywhere, So Keep It Readable

Three habits that keep string-heavy code from turning into soup:

1. Use f-strings for interpolation. Don't chain + across multiple types.
2. Reassign when you "mutate." text = text.strip(), not text.strip() alone.
3. Reach for .split() and .join() before writing manual loops to parse or assemble text. They're faster, clearer, and harder to get wrong.

Next: f-strings in depth — the formatting tool you've seen a handful of times already, plus the number- and date-formatting specs that make them worth mastering.