Python Strings – Tutorial with Examples

In Python, a string is a sequence of characters that can be used to store and manipulate text-based data. A string is created using quotes, either single quotes or double quotes, and can be used for a variety of purposes, such as representing words, sentences, or entire paragraphs. In this article, we will go over the basics of strings in Python, including how to create them, access their characters, perform operations with them, and use them in various other ways.

Creating Strings

Strings in Python can be created using either single quotes or double quotes. The following are examples of how to create strings in Python:

x = "Hello, World!"
y = 'Hello, World!'
z = "This is a longer string that spans multiple lines.\nIt uses the backslash character to escape the newline character."

In the third example, we use the backslash character (\) to escape the newline character, allowing us to create a multi-line string. If you prefer to create a multi-line string using triple quotes, you can use either triple single quotes or triple double quotes:

x = """This is a multi-line string
that uses triple quotes."""
y = '''This is another multi-line string
that uses triple quotes.'''

Accessing Characters

In Python, individual characters within a string can be accessed using square brackets and an index number. The first character in a string has an index of 0, the second character has an index of 1, and so on. The following is an example of accessing characters in a string:

x = "Hello, World!"
print(x[0]) # Output: H
print(x[-1]) # Output: !

In the second line of the example, we use a negative index number to access the last character in the string. Negative index numbers in Python count from the end of the string, so the last character has an index of -1, the second-to-last character has an index of -2, and so on.

String Slicing

In addition to accessing individual characters, we can also access substrings or slices of a string. This is done using square brackets with a starting and ending index number. The following is an example of slicing a string:

x = "Hello, World!"
print(x[0:5]) # Output: Hello
print(x[7:12]) # Output: World
print(x[7:]) # Output: World!
print(x[:5]) # Output: Hello

In the first line of the example, we extract the first five characters of the string, which is the word “Hello”. In the second line, we extract the characters from index 7 to index 12, which is the word “World”. In the third line, we extract all characters starting from index 7 to the end of the string. In the fourth line, we extract all characters from the beginning of the string up to index 5.

String Methods

Strings in Python have a number of built-in methods that can be used to perform various operations. Some of the most commonly used string methods include:

• upper(): Converts all characters in the string to uppercase
• lower(): Converts all characters in the string to lowercase
• capitalize(): Converts the first character of the string to uppercase and all other characters to lowercase
• count(): Returns the number of occurrences of a specified character or substring in the string
• find(): Returns the index of the first occurrence of a specified character or substring in the string
• replace(): Replaces all occurrences of a specified character or substring with another character or substring
• split(): Splits the string into a list of substrings based on a specified character or substring
• join(): Joins a list of strings into a single string, with a specified character or substring between each element

Let’s look at some examples of how these methods can be used:

x = "hello, world!"
#upper()
print(x.upper()) # Output: HELLO, WORLD!

#lower()
print(x.lower()) # Output: hello, world!

#capitalize()
print(x.capitalize()) # Output: Hello, world!

#count()
print(x.count("l")) # Output: 3

#find()
print(x.find("l")) # Output: 2

#replace()
print(x.replace("l", "L")) # Output: heLLo, worLd!

#split()
print(x.split(", ")) # Output: ['hello', 'world!']

#join()
y = ["hello", "world"]
z = " ".join(y)
print(z) # Output: hello world

Looping Through Strings

In Python, you can loop through a string by using a for loop and accessing individual characters within the string. The following is an example of how to loop through a string:

x = "Hello, World!"
for char in x:
    print(char)
#Output:
#H
#e
#l
#l
#o
#,
#W
#o
#r
#l
#d
#!

In this example, we create a for loop that iterates through each character in the string x and prints each character to the console.

Checking if a String Contains Text

You can check if a string contains a specified character or substring using the in operator. The following is an example of how to check if a string contains a specific character:

x = "Hello, World!"
print("H" in x) # Output: True
print("h" in x) # Output: False

In this example, we use the in operator to check if the character 'H' is in the string x. The first check returns True, while the second check returns False because 'h' is not in the string x. If you want to check if a string does not contain a specified character or substring, you can use the not in operator:

x = "Hello, World!"
print("h" not in x) # Output: True
print("H" not in x) # Output: False

In this example, we use the not in operator to check if the character 'h' is not in the string x. The first check returns True, while the second check returns False because 'H' is in the string x.

String Formatting

String formatting in Python allows you to insert values into a string, either by concatenating strings together or by using placeholders and replacing them with values. There are several ways to format strings in Python, including:

• Concatenation
• String Interpolation
• String Formatting using the format() method
• String Formatting using f-strings

Let’s look at each of these methods in detail:

Concatenation

Concatenation involves using the + operator to join two or more strings together. The following is an example of concatenation:

x = "Hello"
y = "World"
z = x + ", " + y + "!"
print(z) # Output: Hello, World!

String Interpolation

String interpolation involves embedding expressions inside string literals, which are evaluated and their values are concatenated with the string. In Python, this can be achieved using the % operator, called the format specifier, along with a set of format codes. Here is an example:

x = "Hello"
y = "World"
z = "%s, %s!" % (x, y)
print(z) # Output: Hello, World!

String Formatting using the format() method

The format() method allows you to insert values into a string using placeholders and replaces the placeholders with values. Placeholders are represented using curly braces {} and can contain an optional format specification. Here is an example:

x = "Hello"
y = "World"
z = "{}, {}!".format(x, y)
print(z) # Output: Hello, World!

String Formatting using f-strings

f-strings, also known as f-literals, are string literals that are prefixed with the letter “f”. They provide a way to embed expressions inside string literals, which are evaluated and their values are concatenated with the string. Here is an example:

x = "Hello"
y = "World"
z = f"{x}, {y}!"
print(z) # Output: Hello, World!

In conclusion, string formatting in Python provides several ways to insert values into a string, including concatenation, string interpolation, the format() method, and f-strings. Each method has its own strengths and weaknesses, and the appropriate method to use depends on the specific requirements of the task at hand.