When working with strings in Python, there may be times when you need to bold certain parts of the string while ignoring the case. This can be particularly useful when dealing with HTML text. In this article, we will explore three different ways to solve this problem using Python.

Option 1: Using the re module

The re module in Python provides support for regular expressions, which can be used to search for and manipulate strings. We can use the re.sub() function to replace the desired parts of the string with the bold HTML tags.

import re

def bolden_string(text, parts):
    for part in parts:
        pattern = re.compile(re.escape(part), re.IGNORECASE)
        text = pattern.sub(f"{part}", text)
    return text

text = "Boldening parts of string ignoring case python html"
parts = ["boldening", "ignoring", "python", "html"]

bold_text = bolden_string(text, parts)
print(bold_text)

In this code, we define a function bolden_string() that takes the input text and a list of parts to be boldened. We iterate over each part and use the re.compile() function to create a regular expression pattern that matches the part while ignoring the case. We then use the re.sub() function to replace the matched part with the bold HTML tags. Finally, we return the modified text.

Option 2: Using str.replace()

An alternative approach is to use the str.replace() method to replace the desired parts of the string. This method allows us to specify the old substring and the new substring to be replaced.

def bolden_string(text, parts):
    for part in parts:
        text = text.replace(part, f"{part}", -1)
        text = text.replace(part.capitalize(), f"{part.capitalize()}", -1)
    return text

text = "Boldening parts of string ignoring case python html"
parts = ["boldening", "ignoring", "python", "html"]

bold_text = bolden_string(text, parts)
print(bold_text)

In this code, we define the same bolden_string() function as before. We iterate over each part and use the str.replace() method to replace the part with the bold HTML tags. We also use str.capitalize() to handle cases where the part appears with a different capitalization. Finally, we return the modified text.

Option 3: Using str.join() and str.split()

Another approach is to split the string into individual words using the str.split() method, and then join them back together using the str.join() method while applying the bold HTML tags to the desired parts.

def bolden_string(text, parts):
    words = text.split()
    for i in range(len(words)):
        if words[i].lower() in parts:
            words[i] = f"{words[i]}"
    return " ".join(words)

text = "Boldening parts of string ignoring case python html"
parts = ["boldening", "ignoring", "python", "html"]

bold_text = bolden_string(text, parts)
print(bold_text)

In this code, we split the input text into individual words using str.split(). We then iterate over each word and check if it matches any of the desired parts (ignoring the case). If a match is found, we replace the word with the bold HTML tags. Finally, we join the modified words back together using str.join() and return the modified text.

After exploring these three options, it is clear that the first option using the re module provides the most robust and flexible solution. It allows for more complex pattern matching and replacement, making it suitable for a wider range of scenarios. However, the choice ultimately depends on the specific requirements of your project.