Python Strings

Learn powerful string manipulation techniques that help in cleaning messy text data.

17 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Loading progress...

Key moments

String Literals and Length — Quotes, multi-line string syntax, and the built-in len function are introduced.
Indexing and Slicing — Square bracket indexing with positive and negative numbers and slice range notation are explained.
Escape Sequences — Backslash usage for escaping quotes, inserting backslashes, and adding newlines is demonstrated.
Formatted Strings — F-strings are introduced as a modern approach to interpolate variables and expressions at runtime.
Case and Whitespace Methods — Dot notation is introduced alongside methods for casing transforms and whitespace trimming.
Search, Replace, and Membership — Methods for locating, replacing, and checking substring existence with boolean operators are presented.

PDF notes

Bottom line: You will manipulate, format, and search textual data in Python using indexing, slicing, escape sequences, formatted strings, and built-in string methods. You will also inspect string metadata and evaluate substring membership using boolean operators.

This lesson on Python Strings is hands-on and example-driven. You will manipulate, format, and search textual data in Python using indexing, slicing, escape sequences, formatted strings, and built-in string methods. You will also inspect string metadata and evaluate substring membership using boolean operators.

What You'll Be Able To Do

Extract individual characters and substrings using zero-based positive/negative indexing and slice notation.
Format multi-line strings, handle special characters with escape sequences, and construct dynamic strings via f-strings.
Transform string casing and strip unwanted leading/trailing whitespace using built-in methods.
Locate substring indices and evaluate membership using .find() alongside in / not in operators.

Detailed Concept Walkthrough

1. String Declaration and Escape Sequences

Strings represent textual data delimited by single, double, or triple quotes, with backslashes serving as escape characters to embed special symbols.

Delimiter Selection: Use single or double quotes interchangeably for single-line strings, and triple quotes (''' or """) for formatting multi-line blocks like emails or templates.
Escape Mechanism: Prefix a character with a backslash () to neutralize its syntactical meaning, creating escape sequences such as " for literal double quotes, ' for single quotes, and \ for literal backslashes.
Control Characters: Insert \n within string literals to programmatically force a line break in the output.

# Literal quotes and control characters
quote_example = "He said, \"Python is powerful.\""
multiline_text = """Hi, John.
This is Mosh from codewithmosh.com."""
newline_str = "Python\nProgramming"

print(quote_example)
print(newline_str)

Key Takeaway: Escape sequences prevent syntax errors when nesting identical quotes and inject special formatting characters like newlines.

2. String Indexing and Slicing

Strings are ordered, zero-indexed sequences where individual elements and sub-ranges are accessed using square bracket notation.

Zero-Indexed Access: Access characters starting from index 0 for the first element, or use negative indices (starting at -1) to count backward from the end.
Slice Notation: Extract substrings via [start:end], which captures elements from start up to, but excluding, the end index.
Default Boundaries: Omit the start index to default to 0 ([ :end]), omit the end index to slice to the string's end ([start: ]), or omit both ([:]) to return a complete copy.

course = "Python Programming"

# Character extraction
first_char = course[0]    # 'P'
last_char = course[-1]    # 'g'

# Substring slicing
first_three = course[0:3] # 'Pyt' (indices 0, 1, 2)
from_start = course[:3]   # 'Pyt'
to_end = course[7:]       # 'Programming'
full_copy = course[:]     # 'Python Programming'

Key Takeaway: Slice ranges are half-open intervals: the character at the end index is never included in the resulting slice.

3. Formatted Strings (f-strings)

Formatted strings provide a clean, readable syntax to evaluate and interpolate dynamic expressions directly into text literals at runtime.

Prefix and Evaluation: Prefixing a string with f or F marks it as an expression template that evaluates embedded expressions inside curly braces {} at runtime.
Expression Support: Place any valid Python expression within {}, including variable references, arithmetic operations, and function calls like len().
Best Practice: Prefer f-strings over manual plus (+) concatenation to eliminate manual type conversions and improve code clarity.

first = "Mosh"
last = "Hamedani"

# Dynamic interpolation
full_name = f"{first} {last}"
calc_summary = f"{len(first)} chars, math result: {2 + 2}"

print(full_name)     # Output: Mosh Hamedani
print(calc_summary)  # Output: 4 chars, math result: 4

Key Takeaway: F-strings evaluate any valid Python expression inside curly braces at runtime rather than storing static text.

4. Built-in String Methods and Membership

String methods perform case conversions, cleanup, and pattern searches on string objects without modifying the original immutable string.

Immutability and Transformations: Methods like .upper(), .lower(), and .title() return brand new transformed strings, leaving the original variable unchanged.
Whitespace Sanitization: Use .strip() to trim leading and trailing whitespace, or specify direction using .lstrip() (left) and .rstrip() (right).
Search and Replace: Use .find() to retrieve the starting zero-based index of a substring (returning -1 if absent), .replace() to substitute characters, and in / not in operators to return boolean presence.

course = "  Python Programming  "

# Transformations
clean_course = course.strip()          # 'Python Programming'
titled = "python programming".title()  # 'Python Programming'
replaced = clean_course.replace("P", "J") # 'Jython Jrogramming'

# Search operations
idx = clean_course.find("Pro")         # 7 (in stripped string)
is_present = "Pro" in clean_course     # True
is_missing = "Swift" not in clean_course # True

Key Takeaway: String methods always return a new string value because Python strings are immutable.

Topics Covered in Python Strings

String Literals and Length (0:00 - 0:45) — Quotes, multi-line string syntax, and the built-in len function are introduced.
Indexing and Slicing (0:45 - 2:00) — Square bracket indexing with positive and negative numbers and slice range notation are explained.
Escape Sequences (2:00 - 3:05) — Backslash usage for escaping quotes, inserting backslashes, and adding newlines is demonstrated.
Formatted Strings (3:05 - 4:00) — F-strings are introduced as a modern approach to interpolate variables and expressions at runtime.
Case and Whitespace Methods (4:00 - 5:30) — Dot notation is introduced alongside methods for casing transforms and whitespace trimming.
Search, Replace, and Membership (5:30 - 6:40) — Methods for locating, replacing, and checking substring existence with boolean operators are presented.

Python Cheat Sheet

len(str) — Returns total character count of a string
```
length = len("Python")
```
str[start:end] — Extracts characters from start up to end - 1
```
slice_str = "Python"[0:3]
```
f"{expr}" — Interpolates evaluated expressions directly into text
```
msg = f"Total: {2 + 2}"
```
str.strip() — Trims leading and trailing whitespace
```
clean = "  text  ".strip()
```
str.find(sub) — Returns index of substring, or -1 if missing
```
pos = "Python".find("th")
```
str.replace(old, new) — Substitutes occurrences of target substring
```
res = "Python".replace("P", "J")
```
sub in str — Evaluates True if substring exists in string
```
exists = "th" in "Python"
```
sub not in str — Evaluates True if substring is absent
```
absent = "z" not in "Python"
```

Comparison Table

Feature / Operator	Return Type	Result When Substring Absent
str.find(sub)	int (index)	Returns -1
sub in str	bool	Returns False
sub not in str	bool	Returns True

Common Pitfalls

Mistake: Expecting slice [0:3] to include the character at index 3. Avoid: Remember that slice end indices are exclusive; [0:3] stops at index 2.
Mistake: Expecting methods like course.upper() to modify the course variable in place. Avoid: Reassign the method return value to a variable, as strings are immutable.
Mistake: Assuming .find() is case-insensitive. Avoid: Match casing exactly or normalize the string with .lower() prior to searching.

FAQs

What is the difference between a function like len() and a method like .upper()? A function like len() is a standalone general-purpose routine called independently, whereas a method is attached to an object type and invoked via dot notation.
What does str.find() return if the search string is not found? It returns -1 to indicate the substring is absent, rather than raising an error.
When should I use .find() versus the in operator? Use the in operator when you only need a boolean True/False existence check, and use .find() when you need the integer starting position of the substring.

Common pitfalls

Mistake: Expecting slice [0:3] to include the character at index 3. Avoid: Remember that slice end indices are exclusive; [0:3] stops at index 2.
Mistake: Expecting methods like course.upper() to modify the course variable in place. Avoid: Reassign the method return value to a variable, as strings are immutable.
Mistake: Assuming .find() is case-insensitive. Avoid: Match casing exactly or normalize the string with .lower() prior to searching.

So here we have this course variable set to Python Programming. As I told you before, whenever you work with text, you should surround your text with quotes. You can either use double quotes or single quotes. That's more of a personal preference, but quite often we use double quotes. We also have triple quotes and we use them to format a long string. For example, if you have let's say a variable message, that is the message we want to include in the body of an email. You can use triple quotes to format it like this. Hi, John. This is Mosh from codewithmosh.com. Blah, blah, blah. So that's when we use triple quotes. Now, we don't need this in this lecture. So delete. Let me show you a few useful things you can do with strings. First of all, we have this built-in function in Python for getting the length of strings. What is a function? A function is basically a reusable piece of code that carries out a task. As a metaphor, think of the remote control of your TV. On this remote control, you have buttons for different functions, like turn on, turn off, change the channel, and so on. These are the built-in functions in your TV. In Python and many other programming languages, we have the exact same concept. So we have functions that are built into the language and the platform. You can reuse these functions to perform various tasks. So here we can use the built-in len function to get the length of a string, which means the number of characters in that string. Now, whenever you want to use a function, you should use parentheses. Now we say we're calling this function, which basically means we're using this function. Now, some functions take additional data, which we refer to as arguments. These arguments are inputs to these functions. So, this len function takes an input or an argument. Here we pass our course variable and this will return the number of characters in this string. So let's print that and see what we get. Run the program. We get 18 because we have 18 characters here. Let's look at another example. If you want to get access to a specific character in this string, you use the square bracket notation. So here we add course square brackets. To get the first character, you use the index 0. So in Python, like many other languages, strings are zero-indexed, which means the index of the first character or the first element is zero. So now when we print this, we get P. Okay? Now, you can also use a negative index like -1. What does that mean? Well, if 0 represents the first character here, what do you think -1 represents? That takes us back to the end of the string. So that returns the first character from the end of the string. Let's run this program. You will see we'll get g. There you go. Using a similar syntax, you can slice strings. Let me show you. So I'm going to duplicate this line and remove -1. Now let's say we want to extract the first three characters in this string. So here we need two indexes: the start index, colon, the end index. So this will return a new string that contains the first three characters in this course variable. That will be P, y, and t. So the index of these characters are 0, 1, and 2. So that means the character at the end index is not included. Okay? Let's run the program and make sure we get the right result. There you go: Pyt. Now, what if we don't include the end index? What do you think we're going to get? It's common sense. We start from index 0 and go all the way to the end of the string. So this will return a new string that is exactly the same as the original string. Let's take a look. So we get Python Programming. Now, what if we don't include the start index, but include the end index? What do you think we're going to get? Once again, it's common sense. So by default, Python will put 0 here. So it will start from the beginning of the string. So when I run this program, we should get Pyt one more time. There you go. And finally, as the last example, if we don't include the start and the end index, this will return a copy of the original string. Let's look at this. So we get Python Programming. Now, you don't have to memorize any of these. Just remember, we use the len function to get the length of a string, we use bracket notation to get access to a specific element or a specific character, and we use this notation to slice a string. So we have this string here, Python Programming. Now let's say we want to put a double quote in the middle of this string. There's a problem here. Python interpreter sees this second string as the end of the string. So the rest of the code is meaningless and invalid. How do we solve this problem? Well, there are two ways. One way is to use single quotes for our string, and then we can use a double quote in the middle of the string. But what if, for whatever reason, perhaps for being consistent in our code, we decided to use double quotes? How can we add another double quote in the middle of this string? Well, we can prefix this with a backslash. Backslash in Python strings is a special character. We have a jargon for that called escape character. We use it to escape the character after. Let me show you what I mean. So, let's print this course, and run this program. What's going on here? We don't have the backslash, because we use that to escape this double quote, and basically display it here. So, backslash is an escape character, and \" is an escape sequence. In Python strings, we have a few other escape sequences that you should be aware of. Let me show you. So in Python, we use a hash sign to indicate a comment. A comment is like additional note that we add to our program. It's not executed by Python interpreter. Okay? So here are the escape sequences. You have seen \". We also have \' So we can use that to add a single quote here. Let's run the program. Here it is. Beautiful. We also have double backslash. So if you want to include a backslash in your strings, you should prefix it with another backslash. Let me show you. So when we run this, we get Python, one backslash, Programming. And finally we have \n, which is short for new line. So now if I add a \n here, see what we get. We get a new line after Python, so Programming will end up on the second line. So these are the escape sequences in Python. Here we have two variables, first and last. Let's say we want to print my full name on the console. So we can define another variable, full, set it to first, then concatenate it with a space, and one more time concatenate it with last. Now when we print full, we get my full name on the console. Beautiful. Now this approach of using concatenation to build a string is okay, but there is a better and newer approach. We can use formatted strings. So here we can set full to this string and prefix it with an f, which can be lower case or upper case. This formatted string doesn't have a constant value like these two strings here. It's actually an expression that will be evaluated at runtime. So, here we want to add our first name. We use curly braces to print the value of the first variable. After that, we add a space, and then we add curly braces one more time to print the last name. So at runtime, this expression will be evaluated. What we have in between curly braces will be replaced at runtime. Now let's run this program one more time. We get the exact same result. Just be aware that you can put any valid expressions in between curly braces. So earlier you learned about the built-in len function. We can call len here to get the length of this string. Let's run this program one more time. So we get four. We can also replace last with an expression like this, 2 + 2. Let's run this program. We get 4 and 4. So, when using formatted strings, you can put any valid expressions in between curly braces. In this lecture, we're going to look at a few useful functions available to work with strings. So earlier you learned about this built-in len function. This function is general purpose, so it's not limited to strings. Later, I will show you how to use this function with other kind of objects. But in Python, we have quite a few functions that are specific to strings. Let me show you. So here if we type course. see, all these are functions available on strings. Now, in precise terms, we refer to these functions as methods. This is a term in object-oriented programming that you will learn about later in the course. For now, what I want you to take away is that everything in Python is an object, and objects have functions, we call methods, that we can access using the dot notation. So here, course is an object. We use the dot notation to access its functions or, more accurately, methods. Let's take a look at a few of these methods. We have upper to convert a string to uppercase. Now let's print this, and run the program. Here's what we get. Beautiful. Now, note that the methods that you call here return a new string, so the original string is not affected. Let me show you. So print(course), run the program one more time. Look, this is our original string, right? So course.upper returns a new string, a new value. We can store it in a variable like course_capital, like this. Now, to keep this demo simple and consistent, I'm going to revert this back and use a print statement. We also have the lower method to convert a string to lowercase. We also have title, which will capitalize the first letter of every word. So if our string was like this, when we call the title method, we get Python Programming as you see here. Okay? Another useful method is strip, and we use it to trim any white space at the beginning or end of a string. This is particularly useful when we receive input from the user. Let me show you. So let's imagine the user entered a couple of white spaces at the beginning of this string. When we call course.strip, those white spaces will be removed. Take a look. So note that in the first three examples we have those white spaces, but in the last one, it is removed. So strip removed the white space from both the beginning and end of a string. We also have lstrip, which is short for left strip, and rstrip, which is short for right strip. So it will remove the white space from the end of a string. If you want to get the index of a character or a sequence of characters in your string, you should use the find method. Let me show you. So, course.find So as an argument, here we pass another string. We can pass a character or a series of characters. Let's find the index of "Pro". Run the program. So the index of "Pro" is 9. So if you start from 0 here all the way to 9, this is the index of "Pro". Okay? Now, as I told you before, Python is a case-sensitive language. So if I pass a capital P here, obviously we don't have these exact characters in our string. So let's see what we get. We get -1. That means this string was not found in the original string. Another useful method is replace. So, we call replace. With this, we can replace a character or a sequence of characters with something else. So let's say we want to replace all lowercase p's with j. With this, we get Jython Jrogramming, whatever that means. And finally, if you want to check for the existence of a character or a sequence of characters in your string, you can use the in operator. Let me show you. So print, we write an expression like this: "pro" in course. So this is an expression. As I told you before, an expression is a piece of code that produces a value. So this expression checks to see if we have "pro" in course. The difference between this expression and calling the find method is that the find method returns the index of these characters in our string, whereas this expression returns a boolean, so it's a true or false. Let me show you. So run the program. We get the boolean True. And finally, we have the not operator, and we use that to see if our string does not contain a character or a sequence of characters. So, let's change this to "swift" not in course. When this expression is evaluated, what do you think we're going to get? Well, we don't have "swift" in this string, so not in will return True. Let's take a look. There you go. So these are the useful string methods. Next, we'll look at numbers. Hi guys, thank you for watching this tutorial. My name is Mosh Hamedani and I have tons of tutorials like this for you on my channel. So be sure to subscribe, and also please like and share this video. If you want to learn Python properly from scratch with depth, I have a comprehensive Python tutorial for you. The link is below this video, so click the link to get started. Thank you and have a fantastic day.

Frequently asked questions

What is the difference between a function like len() and a method like .upper()?

A function like len() is a standalone general-purpose routine called independently, whereas a method is attached to an object type and invoked via dot notation.

What does str.find() return if the search string is not found?

It returns -1 to indicate the substring is absent, rather than raising an error.

When should I use .find() versus the in operator?

Use the in operator when you only need a boolean True/False existence check, and use .find() when you need the integer starting position of the substring.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.