Strings Support More Operators Than I Expected: Concatenation, Comparison, and More

Strings aren't just something you slice and index. They also respond to a surprising number of the operator categories from earlier in this series, arithmetic, relational, logical, and membership, each behaving in ways specific to text.

Arithmetic: only two operators actually apply

Out of all the arithmetic operators, only + and * work on strings.

print("Hi" + "everyone")        # Hieveryone, no space, exactly as written
print("Hi" + " " + "everyone")  # Hi everyone

+ concatenates strings together, exactly as written, with no automatic spacing added.

print("Hi" * 5)   # HiHiHiHiHi
print("*" * 10)   # **********

* repeats a string a given number of times. This second one turns out to be genuinely useful, printing a row of characters for a pattern or a table border is a lot cleaner as "*" * 10 than typing ten asterisks by hand.

Relational operators: comparing strings like dictionary order

print("hello" == "hello")   # True
print("hello" != "world")   # True
print("hello" > "hi")       # False
print("hello" < "world")    # True
print("hello" >= "hello")   # True

Term check: lexicographic order Strings compare character by character based on each character's underlying code point, which lines up closely with dictionary (alphabetical) order for everyday text. "hello" comes before "hi" the same way it would in a dictionary, since comparing the second letter, 'e' sorts before 'i'.

This one is a genuinely common interview question, even though it rarely comes up directly while building real projects, so it's worth being able to explain in plain words rather than just trusting the operator to do the right thing.

Logical operators: strings have a truth value

print("hello" and "world")  # world
print("hello" or "world")   # hello
print("" and "world")       # '' (empty string)
print("" or "world")        # world
print(not "hello")          # False

Term check: truthy and falsy Every value in Python has an implicit true/false quality, even when it isn't a literal True or False. A non-empty string is "truthy," and an empty string "" is "falsy." This is what and/or are actually checking behind the scenes when applied to strings, not the string's content, just whether it's empty or not.

and returns the second value once both operands are truthy, since it needs to confirm both are "on" before deciding the overall result. or returns the first truthy value it finds, short-circuiting as soon as one side is confirmed true.

Looping over a string, revisited

This one's a callback to the loops posts: a for loop iterates over a string one character at a time.

for letter in "Darshan":
    print("Hello")

This prints "Hello" seven times, once per character in "Darshan", regardless of what the actual letters are. The loop body runs once per character in the sequence, it's not inspecting the letters here at all, just counting through them.

Membership operators, refreshed

Another callback, this time to the operators post: in and not in work directly on strings.

print("D" in "Darshan")       # True
print("D" not in "Darshan")   # False
print("x" in "Darshan")       # False
print("x" not in "Darshan")   # True

Common mistakes I'd flag here

• Expecting + to add a space automatically between concatenated strings. It doesn't, any spacing has to be added explicitly.

• Trying arithmetic operators beyond + and * on strings (like - or /), which aren't supported and throw a TypeError.

• Assuming and/or on strings return True/False the way they do on plain booleans. They actually return one of the original strings, based on which one is truthy.

• Forgetting that an empty string is falsy, which can quietly change the outcome of a condition that expected a string to just always count as true.

Quick recap

• Strings only support two arithmetic operators: + for concatenation and * for repetition.

• Relational operators compare strings using lexicographic (roughly dictionary) order, based on each character's underlying code point.

• Logical operators treat empty strings as falsy and non-empty strings as truthy, and return one of the actual operand strings rather than a plain True/False.

• Looping over a string iterates through it one character at a time.

• Membership operators (in, not in) check whether a character or substring exists within a string.

What's next

Next up: Python's built-in string functions/methods, the ready-made tools for things like changing case, trimming whitespace, and searching within a string, instead of writing that logic manually.