Python String Manipulation Exercises

The split() method breaks a string into a list using whitespace as the default separator. In this case:

sentence = "Python is fun and powerful"
words = sentence.split()

The resulting list is:

['Python', 'is', 'fun', 'and', 'powerful']

So words[2] refers to the third element, which is "fun".

String manipulation is a core part of Python programming, especially for data processing, file handling, web scraping, and user interaction. Knowing how to split, search, or reformat strings efficiently gives you a strong advantage in building real-world applications.

The strip() method removes whitespace from both the beginning and end of a string. This includes spaces, tabs, and newline characters. It’s especially useful when handling user input or data from external sources where unintended spaces can affect processing. Python does not have a built-in trim() method — that's found in other languages like Java.

The original string has spaces at both the beginning and the end. The strip() method removes those spaces, resulting in "Hello World!" which is 13 characters long. The len() function then calculates the length of this stripped string, returning 13.

String concatenation in Python is done using the + operator. Option 1 directly combines "Data" and "ScienceRocks" into a single string without any additional characters. Other options either add spaces or use join() incorrectly — which inserts the calling string between each character of the target string.

The capitalize() method converts the first character of the string to uppercase and the rest to lowercase. So "python programming" becomes "Python programming". It's useful when formatting strings for readability, such as names or titles. Note that it doesn’t capitalize each word — for that, use title().

The isalnum() method checks whether all characters in the string are alphanumeric (i.e., only letters and numbers, no special characters or spaces). Since "abc123" contains only lowercase letters and digits, it returns True. If there were any spaces or punctuation, it would return False.

The replace() method replaces all occurrences of a substring with another substring. In this case, all spaces are replaced with underscores, resulting in "Level_Up_With_Python". This is useful for formatting strings to be URL-friendly or for filename generation.

The swapcase() method switches the case of all letters in the string — lowercase becomes uppercase and vice versa. So "HELLO world" becomes "hello WORLD". This method can be helpful when working with case-sensitive formatting or simple encryption tasks.

The method isalnum() returns True if a string contains only letters and/or digits. Since "4567" has only digits, it qualifies as alphanumeric. The isalpha() would return False since there are no letters, and isspace() and istitle() are not applicable here.

The startswith() method checks whether the string begins with the specified substring. Here, since the string actually starts with "Python", it returns True. This is useful for filtering text data or validating user input formats.

This is a string slicing operation with step. The syntax s[start:end:step] slices the string from index 2 to index 9 (10 is exclusive) taking every second character. So, from "MachineLearning", the substring from index 2 to 9 is "chineLe", and taking every 2nd character gives "cieL".

The title() method capitalizes the first letter of every word in the string and converts all other characters to lowercase. So "data analysis is key" becomes "Data Analysis Is Key". This method is commonly used when formatting headings or titles programmatically.

The strip() method removes spaces from both ends of the string. The upper() method then converts the resulting string to all uppercase letters. So the final result is "OPTIMIZE NOW!" without leading or trailing spaces.

The most common Pythonic way to reverse a string is using slicing: string[::-1]. The step of -1 means moving backward through the string. The method reverse() is valid only for lists, not strings, and reverse(string) is not a built-in function.

The split() method divides a string into parts based on a delimiter, here the hyphen "-". The result is a list ["string", "manipulation"], and accessing index 1 gives "manipulation". This method is useful for parsing structured strings such as dates, file paths, or formatted input.

The slicing text[1:-1] gives the substring "123". Then isdigit() checks if all characters in that substring are digits, which is True. This demonstrates combining slicing with string testing methods. The original string had non-digits, but the sliced portion was purely numeric.

The slice s[-5:-2] uses negative indexing to get the substring. It starts from the 5th character from the end ('y') and ends before the 2nd character from the end ('i'), so the substring is "ypt". Negative indices are often tricky for beginners but are useful when working with unknown-length strings.

This expression checks two things: any(c.islower() for c in s) ensures there's at least one lowercase letter, and any(c.isupper() for c in s) ensures there's at least one uppercase letter. Combining them with and confirms both are present. This is a common validation check in passwords or usernames.

The slicing s[::3] means start at the beginning and take every 3rd character. From "visualize", this gives characters at index 0, 3, and 6: 'v', 's', and 'z', so the result is "vsz". This form of slicing is useful for sampling or pattern skipping in data strings.

The expression any(char.isdigit() for char in s) checks whether any character in the string is a digit. Since "Data2025!" contains "2025", the result is True. This is a clean and efficient way to scan strings for numeric characters without having to manually loop or split.