Welcome to this friendly tour of the wonderful world of Python strings. In many ways, Python strings behave similarly to JavaScript strings. They are sequences of characters, and you can do many interesting things with them, like measuring their length, combining them, or extracting specific segments. Think of a string as a strand of yarn: it’s one continuous piece, and you can snip out parts, tie new pieces on, or even count exactly how many inches (characters) it has.
When you finish this article, you should be able to:
len() to obtain a count of the number of characters in a string
In Python, strings are wrapped in single ( ' ' ) or double ( " " ) quotation marks. Think of these marks as safety rails that keep your text from spilling out into the rest of the code. Between them, you can include nearly any characters you like, as long as you don’t mix the same type of quote that opens the string without “escaping” it. More on escaping soon.
Valid strings:
"This is cool!"
'a1b2c3'
Invalid string:
"Tom shouted, "Go outside!""
The invalid string is invalid because the code can’t tell where the string really ends. If you want to include a double quote inside a double-quoted string, switch to single quotes (and vice versa).
Occasionally, you need both single and double quotes in the same string. Python lets you “escape” a character using a backslash (\) before it. Think of the backslash like a shield that protects the quote from being interpreted as the “end” of the string.
'Jim asked, "What\'s up, Sam?"'
Here, the backslash in What\'s protects the apostrophe so that Python doesn’t read it as the end of the string.
Python allows strings to span multiple lines using triple quotes ('''). These triple quotes are like large fence posts: they mark a big region where you can write text exactly as you want it to appear (including new lines and quotes of any type).
print('''My instructions are very long so to make them
more readable in the code I am putting them on
more than one line. I can even include "quotes"
of any kind because they won't get confused with
the end of the string!''')
The output is exactly the lines above. This is wonderfully handy for printing longer text, like error messages or ASCII art, and it avoids confusion with nested quotes.
Note: Don’t mix this up with Python’s """ triple double quotes often used for multi-line comments. They can work similarly for strings, but it’s better to keep a consistent style in your code.
If you think of a string as a row of seats, len() will tell you how many seats are filled. If your string is "Spaghetti", it has 9 characters:
print(len("Spaghetti")) # => 9
This can be useful in all sorts of situations, like validating form input lengths (“is the password at least 8 characters long?”) or trimming text in a user interface.
In Python, each character’s position is numbered starting from zero. This is called zero-based indexing. Think of it like a city block starting at house number 0. If you want to pick out the first character, you use index 0. The second character is index 1, and so on.
print("Spaghetti"[0]) # => S
print("Spaghetti"[4]) # => h
Python also lets you use negative indexing. This is akin to pointing at letters from the end of the string. Index -1 is the last character, -2 is the one before that, and so forth.
print("Spaghetti"[-1]) # => i
print("Spaghetti"[-4]) # => e
Slicing or “sub-stringing” in Python is done by specifying a start index and an end index separated by a colon (:). The returned slice will include characters from the start index up to, but not including, the end index. This is like cutting a piece of a loaf of bread starting at one slice and ending just before another:
print("Spaghetti"[1:4]) # => pag
print("Spaghetti"[4:-1]) # => hett
print("Spaghetti"[:4]) # => Spag
print("Spaghetti"[4:]) # => hetti
If you ask for a single index outside the string’s range, you’ll get an error. But if you request a slice that’s partially or completely outside the string, Python won’t complain; it simply returns whatever portion is valid (or an empty string if none is valid).
Python provides functions to operate on or analyze strings, much like JavaScript. A couple of them are index and count, which help you find positions and counts of characters or substrings.
index is similar to indexOf in JavaScript. It returns the first position where the substring appears, or raises an error if not found:
print("Spaghetti".index("h")) # => 4
print("Spaghetti".index("t")) # => 6
print("Spaghetti".index("s")) # => ValueError: substring not found
In JavaScript, you might recall getting -1 if something wasn’t found. In Python, an exception is thrown instead.
count returns how many times a substring appears in a larger string:
print("Spaghetti".count("h")) # => 1
print("Spaghetti".count("t")) # => 2
print("Spaghetti".count("s")) # => 0
print('''We choose to go to the moon...'''.count('the '))
# => 4
Python uses the + operator to glue strings together, just like JavaScript. It’s like linking two puzzle pieces:
print("gold" + "fish") # => goldfish
But Python also allows you to “multiply” strings. This is a quick way to repeat content:
print("s"*5) # => sssss
print("$1" + ",000"*3) # => $1,000,000,000
The second example creates the familiar “billion” format. This trick can save you a lot of typing and is handy for generating patterns or repeated data in test scenarios.
When you’re debugging or logging, you often want to mix variable data with strings. Python offers two main ways: format and f-strings.
first_name = "Billy"
last_name = "Bob"
print('Your name is {0} {1}'.format(first_name, last_name))
# => Your name is Billy Bob
You insert placeholders like {0} and {1} where you want the variables to appear, and then pass the actual data to .format(). F-strings do the same thing more succinctly:
print(f'Your name is {first_name} {last_name}')
F-strings are often simpler to read and are widely used in modern Python code.
Just like JavaScript provides methods like toUpperCase() or split(), Python also offers many string methods. Below are some common examples:
| Value | Method | Result |
|---|---|---|
s = "Hello" |
s.upper() |
"HELLO" |
s = "Hello" |
s.lower() |
"hello" |
s = "Hello" |
s.islower() |
False |
s = "hello" |
s.islower() |
True |
s = "Hello" |
s.isupper() |
False |
s = "HELLO" |
s.isupper() |
True |
s = "Hello" |
s.startswith("He") |
True |
s = "Hello" |
s.endswith("lo") |
True |
s = "Hello World" |
s.split() |
["Hello", "World"] |
s = "i-am-a-dog" |
s.split("-") |
["i", "am", "a", "dog"] |
In Python, join is a method on the string (rather than on the list):
s = "--".join(["it", "is", "kind"])
print(s) # => it--is--kind
There are also handy “testing” methods that check the contents of a string. For example:
isalpha(): returns True if the string consists only of letters (and is not empty).isalnum(): returns True if it has only letters or digits (and is not empty).isdecimal(): returns True if it has only numeric characters (and is not empty).isspace(): returns True if it has only spaces, tabs, and newlines (and is not empty).istitle(): returns True if every word begins with a capital followed by lowercase.Imagine you’re writing a small command-line trivia game. You want to prompt the player for a name, greet them, and show them a scoreboard banner with repeated characters. You’ll do all of that using Python’s string features.
1. Start a new Python file or open a Python shell. We’ll store a player name:
player_name = input("Enter your name: ")
2. Now greet the player. Use f-strings to show how easy it is:
print(f"Hello {player_name}! Welcome to our trivia game.")
3. Imagine you want a decorative banner around your scoreboard. Use * to repeat a character (like -) and combine it with a summary string:
score = 0
banner = "-" * 30
print(banner)
print(f"| Player: {player_name} | Score: {score} |")
print(banner)
4. Test if your player’s name meets certain criteria. For example, check if it contains only letters:
if player_name.isalpha():
print("Nice! Your name is purely alphabetic.")
else:
print("Your name has some extra stuff... not a big deal, but interesting!")
Feel free to extend this exercise. For instance, you could prompt for an age, use int() to convert it, then do something with that data. The possibilities are endless — let your string manipulations run wild.
String operations are crucial in almost every software project. Whether you’re parsing user input on a website, analyzing log files, or generating content dynamically, mastering string methods and understanding how Python handles them will make your life easier.
For example, a data analyst might need to clean up messy CSV files by splitting rows into columns and removing problematic characters. A web developer might build a user account creation form that checks whether a username is alpha-numeric (isalnum()) and has an appropriate length.
len() to find the number of characters in a stringindex, count, upper, lower, startswith, endswith, split, and joinStrings are an everyday part of any developer’s life, and getting comfortable with them early is a huge advantage. Whether you’re building a small script or a large application, your ability to manipulate, analyze, and format text is a superpower that will continue to serve you throughout your coding journey.
Happy coding, and enjoy weaving your new string knowledge into your next project!