Python Strings: String Length Joining and Slicing

Strings in Python | Length Of A String| Join Two Strings | Slicing | Indexing


Welcome to the fascinating world of strings in Python! Strings are an essential data type that allows us to work with text and manipulate it in various ways. In this comprehensive guide, we will explore the fundamentals of strings in Python and uncover the key techniques to unleash the full potential of text manipulation. Let’s dive in!

What are Strings?

  1. Strings are sequences of characters enclosed in quotes, either single (”) or double (“”).
  2. They can contain letters, numbers, symbols, and whitespace.
  3. Strings are immutable, meaning they cannot be changed once created.
  4. They offer a wide range of operations and methods to work with textual data.

Creating Strings in Python

Creating strings is as simple as enclosing text in quotes. We can use either single or double quotes to define a string.

Remember, enclosing numbers in quotes will indeed create a string representation of the number rather than treating it as a numeric value. Strings provide flexibility in handling different types of data, including numbers, symbols, and text.

Creating a string with single quotes:

string1 = ‘Hello, World!’

Creating a string with double quotes:

string1 = “Hello, World!”

Creating a string with numbers enclosed in quotes:

string3 = ’42’ # ’42’ is a string, not a number

Creating a string with mixed characters:

string4 = “I have 3 cats and 2 dogs!”

Creating an empty string:

empty_string = “”

Creating a string with special characters:

string5 = “I can’t wait!”
string6 = ‘She said, “Hello!”‘

Escape Sequences and Special Characters:

Escape sequences allow us to include special characters and represent complex or hard-to-type characters within a string. They provide a way to handle situations where directly typing the characters may be challenging or may conflict with the string syntax.

Newline (\n):

string1 = “Hello\nWorld”




Tab (\t):

string2 = “Python\tProgramming”

Output: Python Programming

Backslash (\):

string3 = “This is a backslash: \\”

Output: This is a backslash: \

Single Quote (‘):

string4 = ‘He\’s happy’

Output: He’s happy

Double Quote (“):

string5 = “She said, \”Hello!\””

Output: She said, “Hello!”

Unicode Characters:

string6 = “Unicode snowman: \u2603”

Output: Unicode snowman: ☃

Concatenating Strings:

To join or concatenate two strings together, we can use the + operator. It combines the contents of two or more strings into a single string.


string1 = ‘Hello, ‘
string2 = ‘World!’
result = string1 + string2
print(result) # Output: Hello, World!

Repeating Strings:

The * operator allows us to repeat a string multiple times by specifying the number of repetitions.


string = ‘Python ‘
result = string * 3
print(result) # Output: Python Python Python

Finding the Length of a String:

The len() function is a handy tool to determine the length of a string. It counts the number of characters in the string, including letters, numbers, symbols, whitespace, and special characters. Remember, the length of a string represents the total count of characters present within it..

Example with a simple string:

string1 = “Hello, World!”
length1 = len(string1)

Output: 13

Example with an empty string:

empty_string = “”
length2 = len(empty_string)

Output: 0

Example with a string containing spaces:

string2 = “Python is fun!”
length3 = len(string2)

Output: 14

Example with a string containing special characters:

string3 = “I can’t wait!”
length4 = len(string3)

Output: 13

Example with a string containing Unicode characters:

string4 = “🌟✨✌️”
length5 = len(string4)

Output: 6

Accessing Individual Characters:

Accessing individual characters in a string is done using indexing in Python. Each character in a string has a corresponding index, starting from 0 for the first character. Let’s dive into the topic of accessing individual characters in detail with more examples:

Accessing characters by positive indexing:

string = “Python”
print(string[0]) # Output: P
print(string[2]) # Output: t
print(string[5]) # Output: n

In this example, we access individual characters of the string “Python” using positive indexing. The character at index 0 is ‘P’, the character at index 2 is ‘t’, and the character at index 5 is ‘n’. Positive indexing starts from the left side of the string, where the first character has an index of 0.

Accessing characters by negative indexing:

string = “Hello, World!”
print(string[-1]) # Output: !
print(string[-6]) # Output: W

Here, we use negative indexing to access individual characters of the string “Hello, World!”. Negative indexing starts from the right side of the string, where the last character has an index of -1. The character at index -1 is ‘!’, the character at index -6 is ‘W’.

Modifying characters using indexing:

string = “Hello”
string[0] = ‘J’ # This will result in an error since strings are immutable

Strings in Python are immutable, meaning you cannot modify individual characters directly. If you try to assign a new value to a specific character using indexing, it will result in an error. To modify a string, you need to create a new string with the desired changes.

Looping through each character in a string:

string = “Python”
for ch in string:








By using a loop, such as a for loop, you can iterate through each character in a string. In this example, we print each character of the string “Python” on a separate line.

Understanding how to access individual characters in a string is crucial for performing various text manipulation tasks. By utilizing indexing and combining it with other concepts like slicing, you can extract specific characters or sub-strings from a string and manipulate them according to your requirements.

Slicing Strings:

Slicing allows us to extract a sub-string from a string by specifying the start and end indices. It returns a new string that includes characters from the start index up to, but not including, the end index.

string = ‘Python Programming’
sub_string = string[7:18]
print(sub_string) # Output: Programming

Slicing with specified start and end indices:

string = “Python Programming”
print(string[0:6]) # Output: Python
print(string[7:18]) # Output: Programming

In this example, we slice the string by specifying both the start and end indices. The first print statement extracts the sub-string from index 0 to 6 (excluding index 6), resulting in “Python”. The second print statement slices the string from index 7 to 17 (excluding index 18), giving us “Programming”.

Slicing from the beginning of the string:

string = “Python Programming”
print(string[:6]) # Output: Python

In this example, we slice the string starting from the beginning (index 0) up to, but not including, index 6. This extracts the sub-string “Python” from the original string.

Slicing to the end of the string:

string = “Python Programming”
print(string[7:]) # Output: Programming

Here, we slice the string starting from index 7 until the end. This extracts the sub-string “Programming” from the original string.

Slicing with a step value:

string = “Python Programming”
print(string[0:12:2]) # Output: Pto rg

By including a step value, we can control the stride or interval between the characters to be extracted. In this case, we start from index 0 and go up to index 12 (excluding index 12), selecting every second character. The result is “Pto rg”.

Slicing with negative indices:

string = “Python Programming”
print(string[-11:-1]) # Output: Programmin

Negative indices can also be used in slicing. In this example, we slice the string using negative indices, starting from index -11 and going up to, but not including, index -1. This extracts the sub-string “Programmin”.

Slicing is a powerful technique that allows us to extract specific parts of a string by specifying the start and end indices. By utilizing slicing with or without a step value, we can manipulate strings and obtain sub-strings based on our requirements. Experimenting with different slice combinations will enhance your understanding and proficiency in working with strings.