Top 40+ Python String Interview Questions & Answers

Strings are one of the most fundamental and widely used data types in Python. For those preparing for interviews, having a solid understanding of string operations such as string manipulation, indexing, slicing, string formatting, and substring extraction is essential for showcasing your Python proficiency.

This article provides a comprehensive collection of 40+ Python string interview questions with detailed answers, tailored for both beginners and experienced candidates.

Now let’s see detailed explanation of some common string-related interview questions and how to effectively answer them during an interview.

1. What are strings in Python and how are they created?

Level: Beginner

In Python, strings are sequences of characters enclosed within quotes. They are used to store text data and are a built-in data type. Strings can be created using single quotes ('), double quotes ("), or triple quotes (''' or """). Triple quotes are often used for multiline strings or docstrings.

Example:

# Single-quoted string
single_quote = 'Hello, World!'

# Double-quoted string
double_quote = "Hello, Python!"

# Triple-quoted string (multiline)
triple_quote = '''This is
a multiline string.'''Code language: Python (python)

You can mention that strings in Python are objects of the str class and can be created using the str() constructor as well:

string_from_constructor = str("This is a string.")Code language: Python (python)

2. What is the difference between single, double, and triple quotes in Python strings?

Level: Beginner

Single (') and double (") quotes can be used interchangeably for creating strings. The choice between them often depends on the need to include quotes of one type inside the string without escaping them.

Triple quotes (''' or """) allow for multiline strings and are commonly used for docstrings (function or module documentation).

Example:

single_quote_string = 'Python is fun!'
# Using double quotes to avoid escaping
quote_inside_string = "It's a sunny day."Code language: Python (python)

3. How are strings immutable in Python, and what does that mean?

Level: Beginner, Intermediate

Strings in Python are immutable, which means once a string is created, it cannot be changed. Any operation that seems to modify a string will actually create a new string object in memory instead of altering the original string.

Immutability means the content of the object cannot be altered after it’s created. For strings, this implies that individual characters in the string or the entire string cannot be modified in place.

Example:

s = "hello"
s = s + " world"
print(s)  # Output: "hello world"Code language: Python (python)

Here, s + " world" creates a new string object "hello world" and assigns it to s. The original string "hello" remains unaltered in memory.

If you try to directly change a character in the string, Python will throw an error:

s[0] = 'P'  # TypeError: 'str' object does not support item assignmentCode language: Python (python)

Why Strings are Immutable

• Efficiency: Strings are frequently used as dictionary keys. Immutability ensures their hash value remains constant, making them reliable for use in hash-based collections like dictionaries and sets.
• Thread Safety: Immutability eliminates the risk of strings being altered by multiple threads simultaneously, leading to safer code in concurrent programming.

Implications

• Memory Usage: String operations can be memory-intensive if many temporary strings are created. To optimize, use methods like str.join() for concatenation.
• Performance: While immutability offers advantages, it can impact performance for repetitive operations. Using mutable types like list to accumulate characters and converting back to a string can be faster in some cases.

5. Which is ideal for concatenation a + operator or join() method?

Level: Intermediate

Yes, strings in Python can be concatenated using the + operator or by using the join() method.

Example:

# Using the + operator
string1 = "Hello"
string2 = "World"
concatenated = string1 + " " + string2
print(concatenated)  # Output: Hello World

# Using the join() method
words = ["Hello", "World"]
concatenated = " ".join(words)
print(concatenated)  # Output: Hello WorldCode language: Python (python)

Note: It’s important to note that repeated concatenation using + in a loop can be inefficient due to the creation of new string objects. In such cases, using join() is more efficient.

Concatenation with + Operator

• How it Works: Each use of the + operator creates a new string in memory because strings are immutable. For small numbers of strings, this impact is negligible.
• Performance Issue: If many strings are concatenated in a loop, the + operator repeatedly creates new strings, leading to high memory usage and reduced performance.
• Use Case: When concatenating a small, fixed number of strings and when readability and simplicity are more important than performance

Concatenation with join() Method

• How it Works: join() takes an iterable (e.g., a list or tuple) of strings and concatenates them using a specified separator in a single pass.
• Efficiency: Since join() processes the strings in one pass, it’s more efficient for large concatenations compared to the + operator. It avoids creating multiple intermediate strings.
• Use Case: When concatenating many strings (especially in loops). When working with iterables of strings. When needing to insert a consistent separator.

6. How can you check the length of a string in Python?

Level: Beginner

The len() function is used to determine the number of characters in a string. This includes spaces, punctuation, and special characters.

Example:

string = "Hello, Python!"
length = len(string)
print(length)  # Output: 14Code language: Python (python)

The len() function is efficient and widely used, making it a key part of string operations.

7. How to removes any leading and trailing whitespace from string

Level: Beginner

The strip() method removes any leading and trailing whitespace (spaces, tabs, or newline characters) from a string. It can also remove specific characters if provided as an argument.

• strip(): Removes characters from both ends of the string.
• lstrip(): Removes characters from the left (beginning) of the string.
• rstrip(): Removes characters from the right (end) of the string.

Example:

text = "  Hello, World!  "
print(text.strip())   # Output: "Hello, World!"
print(text.lstrip())  # Output: "Hello, World!  "
print(text.rstrip())  # Output: "  Hello, World!"

# Removing specific characters
custom_text = "...Hello..."
print(custom_text.strip('.'))  # Output: "Hello"Code language: Python (python)

8. How do you convert a string to uppercase and lowercase in Python?

Level: Beginner

• upper(): Converts all characters in the string to uppercase.
• lower(): Converts all characters in the string to lowercase.

These methods are helpful for case-insensitive comparisons or standardizing text data.

Example:

text = "Hello, World!"
print(text.upper())  # Output: "HELLO, WORLD!"
print(text.lower())  # Output: "hello, world!"Code language: Python (python)

10. How to replace all occurrences of a substring in a string

Level: Beginner, Intermediate

The most straightforward way to replace all occurrences of a substring in a string is to use the replace() method. This method is built into Python’s string objects.

Syntax:

string.replace(old, new, count)Code language: Python (python)

• old: The substring to be replaced.
• new: The substring to replace with.
• count (optional): You can limit the number of replacements using the count parameter, which specifies how many occurrences of the substring to replace.

Since strings are immutable, the replace() method does not modify the original string but returns a new string with the specified replacements applied.

Example:

# replace all occurrences of a substring
text = "I like Python. Python is powerful."
replaced_text = text.replace("Python", "Java")
print(replaced_text)  # Output: "I like Java. Java is powerful."

# replace only first occurrence
limited_replace = text.replace("Python", "Java", 1)
print(limited_replace)  # Output: "I like Java. Python is powerful."Code language: Python (python)

Note: If the old substring is not found, the original string is returned. If the old substring is an empty string, the new substring will be placed at every character position in the original string.

11. Explain the difference between == and str.is()

Level: Intermediate

• To compare the values of the strings, use the == operator
• The str.is() checks if two string objects point to the same memory location.
• Always use the == operator for string value comparisons.

12. How to check check if a string starts and ends with specified prefix and suffix

Level: Beginner

In Python, you can efficiently check if a string starts and ends with specified prefix and suffix using built-in string methods: startswith() and endswith().

string.startswith(prefix):

• This method checks if the string begins with the specified prefix.
• It returns True if it does, and False otherwise.

string.endswith(suffix):

• This method checks if the string ends with the specified suffix.
• It returns True if it does, and False otherwise.

and Operator:

• The and operator combines the results of startswith() and endswith().
• The function returns True only if both conditions are True; otherwise, it returns False

Example:

def check_prefix_suffix(string, prefix, suffix):
  return string.startswith(prefix) and string.endswith(suffix)

# Example usage
file_name = "PYnative.com is for Python lover"
prefix1 = "PY"
suffix1 = "lover"
print(check_prefix_suffix(string1, prefix1, suffix1))
# Output: True

prefix1 = "PY"
suffix1 = "love"
print(check_prefix_suffix(string1, prefix1, suffix1))
# Output: FalseCode language: Python (python)

13. How does string indexing work in Python?

Level: Beginner

String indexing in Python allows you to access individual characters within a string. Each character in a string is assigned a numeric index, starting from 0 for the first character.

Python also supports negative indexing, where the last character of the string is indexed as -1, the second-to-last as -2, and so on.

Example:

string = "Python"
# access first character
print(string[0])   # Output: P

# access last character
print(string[-1])  # Output: nCode language: Python (python)

14. What is string slicing, and how is it used? Provide examples

Level: Beginner

String slicing is a method to extract a portion (substring) of a string using a specific range of indices. Slicing is performed using the syntax:

string[start:end:step]

• start: The starting index of the slice (inclusive).
• end: The ending index of the slice (exclusive).
• step: The interval between characters in the slice. (Optional; default is 1.)

Examples:

string = "Python Programming"

# Extracting characters from index 0 to 5 (excluding 6)
print(string[0:6])  # Output: Python

# Extracting characters from index 7 to the end
print(string[7:])   # Output: Programming

# Extracting every second character
print(string[::2])  # Output: Pto rgamn

# Using negative indices
print(string[-11:-1])  # Output: ProgramminCode language: Python (python)

15. Does slicing modify the original string?

Level: Intermediate

No, slicing does not modify the original string. Strings in Python are immutable, meaning they cannot be changed after they are created. Slicing creates a new string that is a subset of the original string.

Example:

string = "Python"
sliced_string = string[0:3]  # Extracts "Pyt"
print(sliced_string)  # Output: Pyt
print(string)         # Output: Python (original string remains unchanged)Code language: Python (python)

16. How would you reverse a string in Python

Level: Beginner

String slicing is generally considered the most Pythonic and efficient method to reverse a string. It utilizes Python’s slicing capabilities with a step of -1.

Example:

string = "Python"
reversed_string = string[::-1]  # Step -1 reverses the string
print(reversed_string)  # Output: nohtyPCode language: Python (python)

This method is efficient and leverages Python’s built-in slicing capabilities.

17. How can you extract a substring from a string?

Level: Beginner

To extract a substring from a string, use slicing with the appropriate start and end indices. Substrings can be extracted by specifying the range of characters you want.

Example:

string = "Python Programming"

# Extract substring "Programming"
substring = string[7:]  # Start at index 7 and include the rest
print(substring)  # Output: Programming

# Extract substring "thon Pro"
substring = string[2:10]  # Start at index 2 and stop before index 10
print(substring)  # Output: thon Pro

# Extract substring with a step value (e.g., every second character from "Programming")
substring = string[7::2]
print(substring)  # Output: PormigCode language: Python (python)

18. What is the output of the following string operations

Level: Intermediate

# case 1:
s = "PYnative"
print(s[2:5])

# case 2:
s = "PYnative"
print(s[::2])

# case 3:
s = "PYnative"
print(s[-3:-1])

# case 4:
s = "Pynative"
print(s[:])Code language: Python (python)

Answer:

Case 1: nat
Case 2: Pntv
Case 3: iv
Case 4: Pynative

19. Describe the difference between str.split() and str.partition() methods

Level: Intermediate

str.split():

The split() method breaks a string into a list of substrings. If you want to split a string on a specific separator, specify it so that the split() method can break the string at each occurrence of the separator and return a list of substrings. If the separator is not provided, it defaults to whitespace.

Example:

s = "Jon,Emma,Kelly"
print(s.split(','))  

# Outputs ['Jon', 'Emma', 'Kelly']Code language: Python (python)

str.partition(separator):

The partition(seperator) method returns a tuple containing the part before the first occurrence of the separator, the separator itself, and the part after it. If the separator is not found, the tuple will contain the original string, followed by two empty strings.

Example:

str1 = "Jon,Emma,Kelly"
# split string on occurrence of each comma
print(str1.partition(','))

# Outputs ('Jon', ',', 'Emma,Kelly')Code language: Python (python)

20. What is the difference between str and repr in Python?

Level: Intermediate

Both str and repr are used to get a string representation of an object, but they serve different purposes.

• str(): Provides a readable, user-friendly representation of an object. Typically used for display to end-users, logging, or printing information.
• repr(): Provides an unambiguous representation aimed at developers, often including type information and meant to be a valid Python expression. Useful for debugging, logging in detail, or recreating the object.

21. What are the different ways to format strings in Python?

Level: Intermediate

Python provides three main techniques to format strings, each with its unique features:

1. Percent (%) Formatting

The % operator is the oldest way to format strings in Python, reminiscent of printf-style formatting in C. It uses placeholders like %s, %d, and %f to substitute values into a string.

Example:

name = "Alice"
age = 30
print("My name is %s, and I am %d years old." % (name, age))
# Output: My name is Alice, and I am 30 years old.Code language: Python (python)

2. .format() Method

Introduced in Python 2.7 and 3.0, the .format() method is more powerful and readable. It allows positional and keyword arguments for substituting values into placeholders.

Example:

name = "Bob"
age = 25
print("My name is {}, and I am {} years old.".format(name, age))
# Output: My name is Bob, and I am 25 years oldCode language: Python (python)

You can also use numbered placeholders or keywords:

print("My name is {0}, and I am {1} years old.".format(name, age))
print("My name is {name}, and I am {age} years old.".format(name=name, age=age))Code language: Python (python)

c. f-Strings (Formatted String Literals)

Introduced in Python 3.6, f-strings are the most concise and efficient way to format strings. By prefixing a string with f, you can directly embed expressions inside curly braces {}.

Example:

name = "Carol"
age = 28
print(f"My name is {name}, and I am {age} years old.")
# Output: My name is Carol, and I am 28 years old.

# You can even include expressions:
print(f"Next year, I will be {age + 1} years old.")Code language: Python (python)

Note:

Use f-strings for most modern Python code. They are concise, readable, and expressive.

Use format() for:

• Backward compatibility with Python < 3.6.
• Scenarios requiring advanced formatting.

Avoid % formatting unless:

• You’re working with legacy code.
• The use case is extremely simple and requires no modern features.

22. Reverse a string without using any built-in functions

Level: Intermediate

To reverse a string without built-in functions, you can use a loop to construct the reversed string manually. This approach ensures that each character is processed in reverse order by appending it to the beginning of the result string:

def reverse_string(s):
    reversed_s = ''
    for char in s:
        reversed_s = char + reversed_s
    return reversed_s

# Example usage
print(reverse_string("hello"))  # Output: "olleh"Code language: Python (python)

23. Count the occurrences of each character in a string

Level: Intermediate

You can use a dictionary to count character occurrences. The get method is helpful for initializing the count to 0 if the character is not already in the dictionary. This approach iterates through the string using for loop and updates the count for each character:

def count_characters(s):
    char_count = {}
    for char in s:
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

# Example usage
print(count_characters("hello"))  # Output: {'h': 1, 'e': 1, 'l': 2, 'o': 1}Code language: Python (python)

24. Given two strings, determine if they are anagrams of each other

Level: Intermediate

An anagram is a word formed by rearranging the letters of another word. You can check this by comparing sorted versions of the strings. Sorting both strings ensures their characters are in the same order if they are anagrams:

def are_anagrams(s1, s2):
    return sorted(s1) == sorted(s2)

# Example usage
print(are_anagrams("listen", "silent"))  # Output: TrueCode language: Python (python)

26. Find the first non-repeating character in a string

Level: Intermediate

To find the first non-repeating character, you can use a dictionary to count the occurrences of each character in the string. The key idea is to maintain the order of characters while identifying which character appears only once.

• In the first pass, the program counts the occurrences of each character.
• In the second pass, it iterates through the string to find the first character with a count of 1

def first_non_repeating_character(s):
    char_count = {}
    for char in s:
        char_count[char] = char_count.get(char, 0) + 1

    for char in s:
        if char_count[char] == 1:
            return char
    return None

# Example usage
print(first_non_repeating_character("swiss"))  # Output: 'w'Code language: Python (python)

Explanation: In the example “swiss”:

• During the first iteration, the character counts are: { 's': 3, 'w': 1, 'i': 1 }.
• In the second iteration, the function identifies that ‘w’ is the first character with a count of 1.
• The result is 'w', as it appears only once and is the first such character.

If all characters in the string repeat, the function will return None.

27. Remove all duplicate characters from a string

Level: Intermediate

To remove duplicate characters from a string while maintaining the order, you can use a set to track characters that have already been processed.

The program iterates through the string, adding each character to a result string only if it hasn’t been seen before. This ensures that duplicates are removed while the order of characters is preserved:

def remove_duplicates(s):
    seen = set()
    result = ''
    for char in s:
        if char not in seen:
            seen.add(char)
            result += char
    return result

# Example usage
print(remove_duplicates("programming"))  # Output: "progamin"Code language: Python (python)

Explanation: In the example “programming”:

• The function processes each character sequentially: p, r, o, g, a, m, m, i, n, g.
• As characters are added to the seen set, duplicates like the second m and g are skipped.
• The result is “progamin”, where all duplicates have been removed while preserving the original order of first occurrences.

This approach ensures that the resulting string maintains the order of appearance of the unique characters in the input string.

28. Check if a string contains only digits

Level: Beginner

You can use the isdigit() method, which returns True if all characters in the string are digits and the string is non-empty. This method simplifies the check significantly:

def contains_only_digits(s):
    return s.isdigit()

# Example usage
print(contains_only_digits("12345"))  # Output: True
print(contains_only_digits("123a5"))  # Output: FalseCode language: Python (python)

29. Given a string, find the longest word in it.

Level: Intermediate

You can split the string into words using the split() method and find the longest one using the max function with the key argument set to len for comparing word lengths:

def find_longest_word(s):
    words = s.split()
    longest_word = max(words, key=len)
    return longest_word

# Example usage
print(find_longest_word("Python is an amazing programming language"))  # Output: "programming"Code language: Python (python)

30. Write a function to count vowels and consonants in a string

Level: Beginner, Intermediate

You can use a loop to classify each character as a vowel or consonant. Only alphabetic characters are considered, and the isalpha method is used to filter out non-alphabetic characters:

def count_vowels_and_consonants(s):
    vowels = "aeiouAEIOU"
    vowel_count = 0
    consonant_count = 0

    for char in s:
        if char.isalpha():
            if char in vowels:
                vowel_count += 1
            else:
                consonant_count += 1

    return vowel_count, consonant_count

# Example usage
vowels, consonants = count_vowels_and_consonants("hello world")
print(f"Vowels: {vowels}, Consonants: {consonants}")  # Output: Vowels: 3, Consonants: 7Code language: Python (python)

31. Implement a function to remove all spaces from a string

Level: Beginner

You can use the replace() method to remove all spaces by replacing them with an empty string. This approach is simple and efficient:

def remove_spaces(s):
    return s.replace(" ", "")

# Example usage
print(remove_spaces("Python programming is fun"))  # Output: "Pythonprogrammingisfun"Code language: Python (python)

32. What is the use of escape sequences in Python strings?

Level: Intermediate

Escape sequences are used to include special characters in strings that would otherwise be difficult or impossible to insert directly. They ensure that your string can handle newlines, tabs, quotes, and other characters seamlessly.

Common Escape Sequences:

33. How would you include special characters in string

Level: Intermediate

To include special characters in strings, you can use escape sequences in Python. Escape sequences are prefixed with a backslash (\) to represent characters that cannot be directly included in a string.

Ways to Include Special Characters

1. Using Escape Sequences

Escape sequences allow you to include special characters in a string:

# Single and double quotes
single_quote = 'It\'s a sunny day'
double_quote = "She said, \"Hello!\""
print(single_quote)  # Output: It's a sunny day
print(double_quote)  # Output: She said, "Hello!"Code language: Python (python)

2. Using Triple Quotes

Triple quotes (''' or """) are useful for including multi-line strings or quotes without escaping:

# Multi-line string
multi_line = """This is a "multi-line"
string with special characters like
newlines (\n) and tabs (\t)."""
print(multi_line)Code language: Python (python)

34. How do you check if a string is a palindrome?

Level: Intermediate

A palindrome is a string that reads the same backward as forward. To check if a string is a palindrome, you can compare the string with its reverse.

Approach:

• Reverse the string and compare it with the original.
• Consider only alphanumeric characters and ignore cases for more robust solutions.

Solution:

import re

def is_palindrome(s):
    # Preprocess: Remove non-alphanumeric characters and convert to lowercase
    s = re.sub(r'[^a-zA-Z0-9]', '', s).lower()
    return s == s[::-1]

# Example usage
print(is_palindrome("A man, a plan, a canal: Panama"))  # Output: True
print(is_palindrome("hello"))  # Output: FalseCode language: Python (python)

Explanation:

• The function first removes non-alphanumeric characters using regular expressions.
• It converts the string to lowercase to ensure case insensitivity.
• Finally, it compares the string with its reverse.

35. How can you check if a string contains only alphabets, digits, or alphanumeric characters?

Level: Intermediate

Python provides built-in string methods like .isalpha(), .isdigit(), and .isalnum() to check the nature of a string’s content.

Solution:

def check_string_content(s):
    if s.isalpha():
        return "The string contains only alphabets."
    elif s.isdigit():
        return "The string contains only digits."
    elif s.isalnum():
        return "The string contains alphanumeric characters."
    else:
        return "The string contains special characters."

# Example usage
print(check_string_content("HelloWorld"))  # Output: The string contains only alphabets.
print(check_string_content("12345"))  # Output: The string contains only digits.
print(check_string_content("Hello123"))  # Output: The string contains alphanumeric characters.
print(check_string_content("Hello@123"))  # Output: The string contains special characters.Code language: Python (python)

Explanation:

• .isalpha(): Returns True if all characters are alphabetic.
• .isdigit(): Returns True if all characters are digits.
• .isalnum(): Returns True if all characters are alphanumeric (letters or digits).

36. How do you count occurrences of a character or substring in a string?

Level: Intermediate

Python’s .count() method can be used to count occurrences of a character or substring.

Solution:

def count_occurrences(s, sub):
    return s.count(sub)

# Example usage
print(count_occurrences("hello world", "o"))  # Output: 2
print(count_occurrences("ababab", "ab"))  # Output: 3Code language: Python (python)

Explanation: count(substring): Counts non-overlapping occurrences of the substring in the string.

For more control over overlapping matches, use regular expressions:

import re

def count_overlapping_occurrences(s, sub):
    return len(re.findall(f'(?={re.escape(sub)})', s))

# Example usage
print(count_overlapping_occurrences("ababab", "ab"))  # Output: 4Code language: Python (python)

Explanation:

• re.findall() with a lookahead pattern (?=...) allows overlapping matches.

37. How would you check if one string is a substring of another?

Level: Intermediate

To check if one string is a substring of another, you can use Python’s in operator or the .find() method.

Solution:

def is_substring(s1, s2):
    return s1 in s2

# Example usage
print(is_substring("hello", "hello world"))  # Output: True
print(is_substring("test", "hello world"))  # Output: FalseCode language: Python (python)

Explanation:

• The in operator checks if s1 is found in s2. It is concise and efficient.

Alternatively, use .find() for more information:

def find_substring(s1, s2):
    index = s2.find(s1)
    if index != -1:
        return f"Substring found at index {index}."
    else:
        return "Substring not found."

# Example usage
print(find_substring("hello", "hello world"))  # Output: Substring found at index 0.
print(find_substring("test", "hello world"))  # Output: Substring not found.Code language: Python (python)

Explanation: .find(substring): Returns the starting index of the first occurrence of the substring or -1 if not found.

38. What is raw string in Python?

Level: Intermediate

We can represent textual data in Python using both strings and raw strings. The primary difference lies in how backslashes (\) are treated.

• Raw strings are prefixed with an r or R, e.g., r'...' or r"...".
• In a raw string, backslashes (\) are treated as literal characters, and escape sequences are not processed.
• They are often used for file paths, regular expressions, or any scenario where backslashes need to be preserved.

Example 1: Construct a file path

raw_string = r"C:\Users\Name\Documents"
print(raw_string)  # Output: C:\Users\Name\DocumentsCode language: Python (python)

Here, the \ is treated literally, so the output is exactly as typed.

Example 2: Construct a more readable regular expression using a raw string

import re
# regular expression
 validating an Email
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'Code language: Python (python)

39. How can you format numbers (e.g., decimals, percentages) in strings?

Level: Intermediate

Formatting numbers is crucial when working with financial data, percentages, or measurements. Python provides several ways to achieve this:

1. Using f-Strings: You can format numbers directly within f-strings using format specifiers.

Example:

value = 1234.5678
print(f"Value: {value:.2f}")  # Two decimal places
# Output: Value: 1234.57Code language: Python (python)

You can also format percentages:

percentage = 0.12345
print(f"Percentage: {percentage:.2%}")
# Output: Percentage: 12.35%Code language: Python (python)

2. Using .format()

The .format() method also supports number formatting with specifiers like :.2f or :.2%.

Example:

value = 9876.54321
print("Value: {:.2f}".format(value))
# Output: Value: 9876.54Code language: Python (python)

3. Using the format() Function

The format() function provides flexibility for formatting numbers outside of strings.

Example:

number = 12345.6789
formatted = format(number, ",.2f")  # Includes comma as a thousand separator
print(formatted)
# Output: 12,345.68Code language: Python (python)

Output:

C:\Users\Bob\DocumentsCode language: Python (python)

40. Check if Two Strings Are Rotations of Each Other

Level: Intermediate, Advance

Two strings are considered rotations of each other if one string can be obtained by rotating the other. For example, “abcd” and “dabc” are rotations.

To check if two strings are rotations:

• Check if both strings have the same length.
• Concatenate the first string with itself. If the second string is a substring of this concatenated string, they are rotations.

Python Code:

def are_rotations(str1, str2):
    if len(str1) != len(str2):
        return False
    return str2 in (str1 + str1)

# Example
print(are_rotations("abcd", "dabc"))  # Output: TrueCode language: Python (python)

41. Given a String, Find the Most Frequent Character in It

Level: Intermediate, Advance

Finding the most frequent character involves counting occurrences of each character and identifying the one with the maximum count.

• Use a dictionary or collections.Counter to store character frequencies.
• Traverse the string to populate the dictionary.
• Find the character with the highest frequency.

Python Code:

from collections import Counter

def most_frequent_character(s):
    if not s:
        return None  # Handle empty string
    
    freq = Counter(s)
    return max(freq, key=freq.get)

# Example
print(most_frequent_character("aabbbcc"))  # Output: bCode language: Python (python)

42. Write a Program to Reverse the Words in a Sentence

Level: Intermediate, Advance

Reversing words in a sentence involves splitting the sentence into words and rejoining them in reverse order.

• Split the sentence by spaces to get a list of words.
• Reverse the list and join the words back with spaces.

Python Code:

def reverse_words(sentence):
    words = sentence.split()
    return ' '.join(reversed(words))

# Example
print(reverse_words("Hello World"))  # Output: "World Hello"Code language: Python (python)

44. How to Remove a Specific Character from a String

To remove a specific character from a string, iterate through the string and exclude the unwanted character.

Solution:

• Use a list comprehension to filter out the character.
• Alternatively, use the replace method.

Python Code:

def remove_character(s, char_to_remove):
    return ''.join([char for char in s if char != char_to_remove])

# Using replace
# def remove_character(s, char_to_remove):
#     return s.replace(char_to_remove, '')

# Example
print(remove_character("hello world", "l"))  # Output: "heo word"Code language: Python (python)

These questions help assess key programming concepts like string manipulation, algorithm design, and efficiency. Practice these problems to strengthen your skills for coding interviews.

Summary and Next Steps

By familiarizing yourself with the interview questions and answers presented in this article, you’ve taken a significant step toward mastering Python strings. You’ll be able to give a confident and thorough explanation of Python strings during an interview.

Preparing for Python string interview questions involves understanding the core concepts of strings in Python and practicing common string manipulation techniques. Here’s a breakdown of summary on how to prepare:

1. Understand Basic String Concepts:

• String Definition:
  • Understand how to define and use strings
• Immutability:
  • Grasp the concept that strings are immutable, meaning they cannot be changed after creation.
• String Indexing and Slicing:
  • Be comfortable with accessing individual characters using indexing (e.g., string[0]).
  • Master string slicing to extract substrings (e.g., string[1:4]).
• String Concatenation:
  • Know how to combine strings using the + operator.

2. Master Common String Methods:

• Case Manipulation:
  • upper(), lower(), capitalize(), title(): Understand how to change the case of strings.
• Whitespace Handling:
  • strip(), lstrip(), rstrip(): Learn how to remove leading and trailing whitespace.
• String Searching and Finding:
  • find(), index(), count(), startswith(), endswith(): Know how to search for substrings and count occurrences.
• String Modification:
  • replace(): Understand how to replace substrings.
  • split(): Learn how to split strings into lists of substrings.
  • join(): Know how to join lists of strings into a single string.
• String Formatting:
  • format() and f-strings: Be proficient in formatting strings with variables.

3. Practice Common String Problems:

• Palindrome Check:
  • Write code to determine if a string is a palindrome.
• Anagram Detection:
  • Write code to determine if two strings are anagrams.
• String Reversal:
  • Practice reversing strings using slicing or loops.
• Character Counting:
  • Write code to count the occurrences of specific characters in a string.
• String Manipulation:
  • Removing duplicate characters from a string.
  • Reversing the words in a string.

4. Regular Expressions (Regex):

• Understand the basics of regular expressions and the re module in Python.
• Be able to use re.match(), re.search(), re.findall(), and re.sub().
• Practice writing regex patterns for common tasks like validating email addresses or phone numbers.

5. Key areas to focus on:

• String manipulation: This is the core of many string related questions.
• Algorithm implementation: Being able to implement algorithms that process strings.
• Edge case handling: being able to handle empty strings, or strings that contain unexpected characters.
• Efficiency: Consider the time and space complexity of your solutions.

Remember that practical application is key to solidifying your understanding. Practice the techniques covered, experiment with different string operations, and explore additional resources to deepen your knowledge.

Few More Intermediate and Advanced-Level Questions you can try to solve

1. Write a program to find all permutations of a string.
2. How would you compress a string (e.g., “aaabb” -> “a3b2”)?
3. Write a function to find the longest palindrome substring in a string.
4. Given a string, find the most frequent character in it..
5. How would you check if a string contains balanced parentheses/brackets?
6. Write a function to determine if a string can be rearranged into a palindrome.
7. Given a string, write a program to find all substrings.
8. Implement a function to remove a specific character from a string.
9. Write a function to find the longest common prefix among a list of strings.
10. Given a string, write a program to find all possible subsets of its characters.
11. Write a program to group anagrams from a list of strings.
12. Implement a function to determine if a string matches a given pattern (e.g., “aabb” matches “xxzz”).
13. Write a function to perform a basic string search algorithm (e.g., KMP or Rabin-Karp).
14. Given a string, find the minimum number of characters needed to make it a palindrome.
15. Write a program to check if a string contains all unique characters.
16. Implement a function to split a string into valid words based on a dictionary.