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

Quotes and Formatting — Strings can be defined using single, double, or triple quotes for long or multi-line text.
Length Function — The built-in len() function returns the number of characters in a string.
Indexing and Negatives — Individual characters are accessed using zero-based indexing or negative indexing from the end.
String Slicing — Substrings are extracted using the [start:end] notation, where the end index is non-inclusive.
Escape Sequences — The backslash is used as an escape character to include special characters like quotes or newlines.
Formatted Strings — F-strings allow embedding variables and expressions inside curly braces for dynamic string creation.
String Methods Overview — String methods are functions attached to string objects, accessed via dot notation, and return new strings.
Utility Methods — Methods like strip(), find(), and replace() are used for cleaning, searching, and modifying string content.
Existence Check — The in and not in operators check for the presence of a substring and return a boolean value.

PDF notes

Bottom line: You will learn how to define, manipulate, and format text data using Python strings. By the end of this lesson, you will be able to extract specific characters, slice substrings, and use powerful built-in methods to clean and transform text for data analysis tasks.

This lesson on Python Strings is hands-on and example-driven. You will learn how to define, manipulate, and format text data using Python strings. By the end of this lesson, you will be able to extract specific characters, slice substrings, and use powerful built-in methods to clean and transform text for data analysis tasks.

What You'll Be Able To Do

Define strings using single, double, or triple quotes and incorporate special characters using escape sequences.
Calculate the length of any string using the built-in len() function.
Access individual characters or extract substrings using indexing and slicing notation.
Construct complex strings efficiently using f-string formatting and embedded expressions.
Apply common string methods like upper(), strip(), and find() to transform and analyze text data.

Detailed Concept Walkthrough

1. String Quotes and Escaping

Strings are sequences of characters used to represent text data, defined by surrounding the text with quotes. Escape sequences allow you to include characters that Python normally interprets as syntax, such as quotes or newlines.

Syntax Rule: Use single (') or double (") quotes for standard strings; use triple quotes (""" or ''') for multi-line strings or strings requiring internal formatting.
Mechanism: The backslash () acts as an escape character, telling the interpreter to treat the following character literally or as a special formatting command.
Best Practice: If your string contains many double quotes, define it using single quotes (and vice versa) to avoid needing to escape them.
Escape Sequence: \n inserts a newline character, and \ inserts a literal backslash into the string output.

course = "Python programming"
long_msg = """Hi John,
This is Mosh.""" # Triple quotes for multi-line
escaped = 'We use "double quotes" and a newline.\n'
print(escaped)

Key Takeaway: Choose the appropriate quote type based on the content and use the backslash to handle special characters internally.

2. Indexing and Slicing

Strings are ordered sequences, meaning each character has a specific position (index). Indexing accesses a single character, while slicing extracts a contiguous sequence (a substring).

Mechanism: Python uses zero-indexing, where the first character is at index 0.
Execution Flow: Positive indices count from the start (0, 1, 2...). Negative indices count backward from the end (-1 is the last character).
Syntax Rule: Slicing uses the format [start:end]. The character at the end index is always excluded from the result.
Best Practice: Omitting the start index defaults to 0 (the beginning); omitting the end index defaults to the end of the string.

course = "Python programming"
print(course[0])    # Indexing: P
print(course[-1])   # Negative Indexing: g
print(course[0:6])  # Slicing: Python (index 6 excluded)
print(course[7:])   # Slicing to the end: programming

Key Takeaway: Remember that slicing is non-inclusive of the end index, which is crucial for accurate substring extraction.

3. F-String Formatting

Formatted strings (f-strings) provide a concise and readable way to embed variables and expressions directly within a string literal. They are evaluated at runtime.

Syntax Rule: Prefix the string with f or F (e.g., f"...").
Mechanism: Variables or expressions are placed inside curly braces {} within the string.
Execution Flow: At runtime, the expression inside the curly braces is evaluated, and its resulting value replaces the {} placeholder in the string.
Best Practice: Use f-strings instead of traditional string concatenation (+) for improved readability and performance when combining variables and text.

first = "Mosh"
last = "Hamedani"
# Embed variables and expressions
full = f"{first} {last} ({len(first) + len(last)})"
print(full)

Key Takeaway: F-strings allow you to embed any valid Python expression inside curly braces for dynamic string generation.

4. String Methods and Immutability

Strings are objects in Python, and they come with built-in functions called methods, accessed using dot notation (.). These methods perform common transformations like case conversion or searching.

Under the Hood: Strings are immutable; methods like upper() or replace() do not modify the original string but instead return a brand new string object containing the result.
Mechanism: Methods are called using the syntax string_variable.method_name(). Some methods, like find() or replace(), require arguments.
Best Practice: Always assign the result of a string method to a new variable or use it immediately, as the original variable remains unchanged.
Search/Check: find('sub') returns the starting index (or -1 if not found), while the in operator returns a boolean (True/False) indicating existence.

course = "  python programming  "
# Transformation methods
capital = course.strip().upper()
print(capital) # PYTHON PROGRAMMING

# Search methods
index = course.find('pro')
exists = 'pro' in course
print(f"Index: {index}, Exists: {exists}")

Key Takeaway: String methods return new strings; they never modify the original string object in place.

Topics Covered in Python Strings

Quotes and Formatting (0:00 - 0:45) — Strings can be defined using single, double, or triple quotes for long or multi-line text.
Length Function (1:00 - 2:15) — The built-in len() function returns the number of characters in a string.
Indexing and Negatives (2:20 - 3:30) — Individual characters are accessed using zero-based indexing or negative indexing from the end.
String Slicing (3:30 - 5:30) — Substrings are extracted using the [start:end] notation, where the end index is non-inclusive.
Escape Sequences (5:30 - 7:45) — The backslash is used as an escape character to include special characters like quotes or newlines.
Formatted Strings (8:00 - 10:45) — F-strings allow embedding variables and expressions inside curly braces for dynamic string creation.
String Methods Overview (11:00 - 13:45) — String methods are functions attached to string objects, accessed via dot notation, and return new strings.
Utility Methods (13:45 - 16:45) — Methods like strip(), find(), and replace() are used for cleaning, searching, and modifying string content.
Existence Check (16:45 - 17:30) — The in and not in operators check for the presence of a substring and return a boolean value.

Python Cheat Sheet

len(string) — Returns the total number of characters in the string
```
print(len("data"))
```
string[i] — Accesses the character at index i
```
course[-1]
```
string[start:end] — Extracts a substring from start up to (but not including) end
```
course[0:6]
```
f"text {var} text" — Embeds variables or expressions into a string
```
f"{first} {last}"
```
string.upper() — Returns a new string with all characters capitalized
```
course.upper()
```
string.strip() — Removes leading and trailing whitespace from the string
```
course.strip()
```
string.find('sub') — Returns the starting index of the substring, or -1
```
course.find('pro')
```
'sub' in string — Checks if the substring exists, returns True or False
```
'Python' in course
```

Comparison Table

Feature	String Concatenation (+)	F-Strings (f"...")
Syntax	Uses + operator repeatedly.	Uses f prefix and {} placeholders.
Readability	Poor for complex strings.	Excellent, variables embedded directly.
Embedded Logic	Requires pre-calculating values.	Allows embedding any valid expression.
Runtime Behavior	Creates multiple intermediate strings.	Optimized, single expression evaluation.

Common Pitfalls

Mistake: Forgetting that string slicing excludes the character at the end index. Avoid: Always use [start:end] where end is the index after the last desired character.
Mistake: Assuming string methods modify the original string variable in place. Avoid: Always reassign the result, e.g., course = course.strip().
Mistake: Using find() to check for existence when the substring is not at index 0. Avoid: Use the 'in' operator for simple existence checks, as it returns a clear boolean.
Mistake: Trying to use a double quote inside a double-quoted string without escaping it. Avoid: Use " or switch to single quotes for the outer definition.

FAQs

Why do we need triple quotes if we have escape sequences like \n? Triple quotes are primarily used for defining multi-line strings easily without needing to insert \n manually on every line break.
Is Python case-sensitive when searching strings? Yes, Python is case-sensitive; methods like find() will return -1 if the case of the search string does not match the target string exactly.
What is the difference between a function and a method? A function (like len()) is a standalone piece of code; a method (like upper()) is a function associated with an object (like a string) and is called using dot notation.
If I slice a string using [:], does it modify the original string? No, slicing always returns a new string object, even if it is an exact copy of the original string.

Common pitfalls

Mistake: Forgetting that string slicing excludes the character at the end index. Avoid: Always use [start:end] where end is the index *after* the last desired character.
Mistake: Assuming string methods modify the original string variable in place. Avoid: Always reassign the result, e.g., course = course.strip().
Mistake: Using find() to check for existence when the substring is not at index 0. Avoid: Use the 'in' operator for simple existence checks, as it returns a clear boolean.
Mistake: Trying to use a double quote inside a double-quoted string without escaping it. Avoid: Use \" or switch to single quotes for the outer definition.

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 a string. 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 on the platform. You can reuse this 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 parenthesis. 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 zero. So in Python, like many other languages, strings are zero index, which means the index of the first character or the first element is zero. So, now, when we print this, we'll get P, okay? Now, you can also use a negative index, like -1. What does that mean? Well, if zero 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 zero, one, and two. 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, P, Y, T. 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 zero 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 zero here, so it will start from the beginning of the string. So, when I run this program, we should get P, Y, T 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 the string. There is 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 displayed here. So backslash is an escape character and backslash double quote 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 backslash double quote. We also have backslash single quote. 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 backslash n, which is short for new line. So, now, if I add a backslash 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 lowercase or uppercase. This formatted string doesn't have a constant value like these two strings here. It's actually an expression that will be evaluated at run time. 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 run time, this expression will be evaluated. What we have in between curly braces will be replaced at run time. 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 dot, 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 is 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 lower case. 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 whitespace 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 whitespaces at the beginning of the string. When we call course.strip, those whitespaces will be removed. Take a look. So, note that in the first three examples we have those whitespaces, but in the last one, it is removed. So, strip removes the whitespace 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 whitespace 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 zero 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, Joramming, 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

Why do we need triple quotes if we have escape sequences like \n?

Triple quotes are primarily used for defining multi-line strings easily without needing to insert \n manually on every line break.

Is Python case-sensitive when searching strings?

Yes, Python is case-sensitive; methods like find() will return -1 if the case of the search string does not match the target string exactly.

What is the difference between a function and a method?

A function (like len()) is a standalone piece of code; a method (like upper()) is a function associated with an object (like a string) and is called using dot notation.

If I slice a string using [:], does it modify the original string?

No, slicing always returns a new string object, even if it is an exact copy of the original string.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.