You can use a list comprehension with an if-else.

list_A = ['hello', 'world', 'goodbye', 'world']
list_B = [word if word != 'world' else 'friend' for word in list_A]

You now have a new list, list_B, where all instances of the word "world" have been replaced with "friend".

Iterate over the invalid_list and use the in-built replace() function to replace the substring.

for i in invalid_list:
    s = [string.replace(i, 'xyz') for string in s]

They advise using the re library here, however, I think it's easier, easier and better to use simple text.format() formatting

Code example:

list_of_words = ['text', 'be', 'there']

text = "This is an example {}. Normally there would {} something important here but {} isn't.".format(*list_of_words)

The output will look like this:

This is an example text. Normally there would be something important here but there isn't.

Don't join.

It merge list elements into single string. You had 3 phrases that could be independently checked. Now you have single string.

Instead what you want to do, is to check if any of phrases from italic_list are present in input string one by one.

In python you can do that with loops. Just loop over italic_list, and for each element check if element is present in input string, and if so, replace that part with one with extra elements.

You can do that with a single call to sub:

big_regex = re.compile('|'.join(map(re.escape, prohibitedWords)))
the_message = big_regex.sub("repl-string", str(word[1]))

Example:

>>> import re
>>> prohibitedWords = ['Some', 'Random', 'Words']
>>> big_regex = re.compile('|'.join(map(re.escape, prohibitedWords)))
>>> the_message = big_regex.sub("<replaced>", 'this message contains Some really Random Words')
>>> the_message
'this message contains <replaced> really <replaced> <replaced>'

Note that using str.replace may lead to subtle bugs:

>>> words = ['random', 'words']
>>> text = 'a sample message with random words'
>>> for word in words:
...     text = text.replace(word, 'swords')
... 
>>> text
'a sample message with sswords swords'

while using re.sub gives the correct result:

>>> big_regex = re.compile('|'.join(map(re.escape, words)))
>>> big_regex.sub("swords", 'a sample message with random words')
'a sample message with swords swords'

As thg435 points out, if you want to replace words and not every substring you can add the word boundaries to the regex:

big_regex = re.compile(r'\b%s\b' % r'\b|\b'.join(map(re.escape, words)))

this would replace 'random' in 'random words' but not in 'pseudorandom words'.

You can replace the elements in a list (in place) using slice assignment:

word_list = [ 'foo','bar','baz' ]
new_list = [ 'qux','tux','lux', 'holy cow!  python is awesome' ]

word_list[:] = new_list
print(word_list)  #[ 'qux','tux','lux', 'holy cow!  python is awesome' ]

new_list and old_list don't even need to be the same length.

You can also replace only part of a list with part of the other list if you'd like:

word_list = [ 'foo','bar','baz' ]
new_list = [ 'qux','tux','lux', 'holy cow!  python is awesome' ]

word_list[1:-2] = new_list[:-1]
print word_list #['foo', 'qux', 'tux', 'lux', 'bar', 'baz']

Use a set for unique_words. Sets are considerably faster than lists for determining if an item is in them (see Python Sets vs Lists ).

Also, it's only a stylistic issue but I think you should drop the brackets in the if. It looks cleaner.

Note that the condition if word in words in replacer performs a linear search on words if it's a list, as in the current code. Since this condition is executed for every word in the input, it would be good to optimize it a bit. You could for example pass a set of words instead of a list.

The names first_iter and second_iter are not very meaningful. It would be good to come up with some better names for these.