In Python, creating a new object e.g. with a list comprehension is often better than modifying an existing one:

item_list = ['item', 5, 'foo', 3.14, True]
item_list = [e for e in item_list if e not in ('item', 5)]

... which is equivalent to:

item_list = ['item', 5, 'foo', 3.14, True]
new_list = []
for e in item_list:
    if e not in ('item', 5):
        new_list.append(e)
item_list = new_list

In case of a big list of filtered out values (here, ('item', 5) is a small set of elements), using a set is faster as the in operation is O(1) time complexity on average. It's also a good idea to build the iterable you're removing first, so that you're not creating it on every iteration of the list comprehension:

unwanted = {'item', 5}
item_list = [e for e in item_list if e not in unwanted]

A bloom filter is also a good solution if memory is not cheap.

You can use string.split() if you aren't confident of your string spacing.

string.split() and string.split(' ') work a little differently:

In [128]: 'this     is   a test'.split()
Out[128]: ['this', 'is', 'a', 'test']

In [129]: 'this     is   a test'.split(' ')
Out[129]: ['this', '', '', '', '', 'is', '', '', 'a', 'test']

The former splits your string without any redundant empty strings.

If you want a little more security, or if your strings could contain tabs and newlines, there's another solution with regex:

In [131]: re.split('[\s]+',  'this     is \t  a\ntest', re.M)
Out[131]: ['this', 'is', 'a', 'test']

Lastly, I would suggest converting your lookup list into a lookup set for efficient lookup in your filter:

In [135]: list(filter(lambda x: x not in {'is', 'this', 'a', 'string'}, string.split()))
Out[135]: ['test']

While on the topic of performance, a list comp is a bit faster than a filter, although less concise:

In [136]: [x for x in string.split() if x not in {'is', 'this', 'a', 'string'}]
Out[136]: ['test']

You can use this example to remove selected last words from the list of string:

lst =['dont strip this', 'puppies com', 'company abc org', 'company a com', 'python limited']
to_strip = {'limited', 'com', 'org'}

out = []
for item in lst:
    tmp = item.rsplit(maxsplit=1)
    if tmp[-1] in to_strip:
        out.append(tmp[0])
    else:
        out.append(item)

print(out)

Prints:

['dont strip this', 'puppies', 'company abc', 'company a', 'python']

Regex:

>>> import re
>>> re.sub(r'|'.join(map(re.escape, replace_list)), '', words)
' word2  word4, '

The above one-liner is actually not as fast as your string.replace version, but definitely shorter:

>>> words = ' '.join([hashlib.sha1(str(random.random())).hexdigest()[:10] for _ in xrange(10000)])
>>> replace_list = words.split()[:1000]
>>> random.shuffle(replace_list)
>>> %timeit remove_multiple_strings(words, replace_list)
10 loops, best of 3: 49.4 ms per loop
>>> %timeit re.sub(r'|'.join(map(re.escape, replace_list)), '', words)
1 loops, best of 3: 623 ms per loop

Gosh! Almost 12x slower.

But can we improve it? Yes.

As we are only concerned with words what we can do is simply filter out words from the words string using \w+ and compare it against a set of replace_list(yes an actual set: set(replace_list)):

>>> def sub(m):
    return '' if m.group() in s else m.group()
>>> %%timeit
s = set(replace_list)
re.sub(r'\w+', sub, words)
...
100 loops, best of 3: 7.8 ms per loop

For even larger string and words the string.replace approach and my first solution will end up taking quadratic time, but the solution should run in linear time.

You're trying to change the list at the same time as modifying it. Try creating a new list with the filtered objects instead.

mylist = [x for x in mylist if 'a' in x]

See more methods here: How to remove items from a list while iterating?

Well, first I would say that pop is not the best option for the procedure. pop will return the value, you are only looking to remove it. To remove an element from a list given its index you can do:

my_list = [1,2,3,4]
del(my_list[2])

Nevertheless, going through a for loop while removing the elements that are part of it is not a good idea. It would be best to create a new list with only the elements you want.

my_list = ['fast', 'attack', 'slow', 'baft', 'attack', 'baft']
my_new_list = []
for value_str in my_list:
    if 'a' != value_str[0]:
        my_new_list.append(value_str)

This can also be done more concisely using list comprehension. The snippet below does the same thing as the one above, but with less code.

my_list = ['fast', 'attack', 'slow', 'baft', 'attack', 'baft']
my_new_list = [value_str for value_str in my_list if value_str[0] != 'a']

Tim already gave you that snippet as an answer, but I felt that given the question it would be better to give you a more descriptive answer.

This is a good link to learn more about list comprehensions, if you are interested (they are pretty neat): Real Python - List Comprehensions

You have to assign the result of replace to item again:

clean = []
for item in URLs:
    for loc in locs:
        item = item.replace(loc, '')
    clean.append(item)

or in short:

clean = [
    reduce(lambda item,loc: item.replace(loc,''), [item]+locs)
    for item in URLs
]