The replacement occurs on a variable inside the loop So nothing is changed in the sentence list To fix this make a new list with the changed items in it

word_list = { "hello" : "1"}

sentence= ['hello you, hows things', 'hello, good thanks']
newlist=[]

for key, value in word_list.items():
   for i in sentence:
       i = i.replace(key, value)
       newlist.append(i)
print newlist

Another way with map

word_list = { "hello" : "1"}

sentence= ['hello you, hows things', 'hello, good thanks']
newlist=[]

for key, value in word_list.items():
  newlist=map(lambda x: x.replace(key,value), sentence)
print newlist

Another way with a list comprehension

word_list = { "hello" : "1"}

sentence= ['hello you, hows things', 'hello, good thanks']
newlist=[]

for key, value in word_list.items():
  newlist=[x.replace(key,value) for x in sentence]
print newlist

note: updated for python3, thanks @MGM

If the values are unique, then you can flip the dictionary:

subs = {v:k for k, v in subs.iteritems()}

Then you can use .get() to get the value from a dictionary, along with a second parameter incase the key is not in the dictionary:

print map(subs.get, my_lst, my_lst)

Prints:

['L.A. Clippers', 'Houston', '03/03 06:11 PM', '2.13', '1.80', '03/03 03:42 PM']

Haidro explained it pretty well, but I thought I'd expand his code, and also address another issue.

First off, as Inbar Rose pointed out, your naming conventions bad. It makes code much more difficult to read, debug, and maintain. Pick concise descriptive names, and make sure to follow PEP-8. Avoid re-using the same variable name for different things, especially within the same scope.

Now, to the code:

words = ['Super', 'Random', 'List']
clues = {'R': 'S', 'd': 'r', 'a': 'e', 'o': 'e', 'm': 't', 'n': 'c'}


def decrypter(words, clues):

    progression = words[:]

    for i, word in enumerate(progression):
        for key in clues:
            progression[i] = progression[i].replace(key, clues.get(key))

    return progression

This now replaces characters in the content of progression[i] instead of replacing progression[i] with the key from clues.

Also, changed progression = words to progression = words[:] in order to create a copy of the list to act on. You pass in a reference to words, and then assign that same reference to progression. As you manipulate progression, so to do you manipulate words, rendering progression useless to be using in this case.

Example using:

print words
print decrypter(words, clues)
print words

Output using progression = words:

['Super', 'Random', 'List']
['Super', 'Secret', 'List']
['Super', 'Secret', 'List']

Output using progression = words[:]:

['Super', 'Random', 'List']
['Super', 'Secret', 'List']
['Super', 'Random', 'List']

Now that you have your dict the proper way, you can do regular dict object stuff like checking for keys and grabbing values:

>>> text = 'the man lives in a house'
>>> mydict = {"the":1,"in":2,"a":3}
>>> splitlines = text.split()
>>> for word in splitlines:
    if word in mydict:
        text = text.replace(word,str(mydict[word]))

HOWEVER, note that with this:

>>> text
'1 m3n lives 2 3 house'

since a is a key, the a in man will be replaced. You can instead use regex to ensure word boundaries:

>>> text = 'the man lives in a house'
>>> for word in splitlines:
    if word in mydict:
        text = re.sub(r'\b'+word+r'\b',str(mydict[word]),text)


>>> text
'1 man lives 2 3 house'

the \b ensures that there is word boundary around each match.

a = ['I own 1/2 bottle', 'Give me 3/4 of the profit']
b = {'1/2': 'half', '1/4': 'quarter', '3/4': 'three quarters'}

def replace(x):
    for what, new in b.items(): # or iteritems in Python 2
        x = x.replace(what, new)
    return x

print(list(map(replace, a)))

Output:

['I own half bottle', 'Give me three quarters of the profit']

key = {'a':'z','b':'y','c':'x'}
List = ['a','b','c']

print([key.get(x,"No_key") for x in List])

#### Output ####

['z', 'y', 'x']

If your interest is only to print them as string,then:

print(*[key.get(x,"No_key") for x in List],sep="")

#### Output ####

zxy

Just in case you need the solution without join.

ss = ''
def fun_str(x):
    global ss
    ss = ss + x
    return(ss)
print([fun_str(x) for x in List][-1])

#### Output ####

zxy

You can create a dictionary

>>> char_replace = {"%":"pct" , "*":"star" , "&":"and"}
>>> st = 'Hello %*& World'
>>> for i,j in char_replace.items():
...                st = st.replace(i,j)
...
>>> st
'Hello pctstarand World'
>>>

Just out of curiosity I tried to time all the ways to replace string characters discussed here. In case you were wondering which is better.

1st way

>>> setup= '''
... char_replace = {"%":"pct" , "*":"star" , "&":"and"}
... st = 'Hello %*& World'
... for i,j in char_replace.items():
...         st = st.replace(i,j)
... '''
>>> t = Timer(setup)
>>> t.timeit()
2.3223999026242836
>>>

2nd way

>>> setup1 = '''
... string = 'Hello %*& World'
... repl = ['%','*','&'], ['pct','star','and']
... for a, b in zip(*repl):
...     string = string.replace(a, b)
...
... '''
>>> t = Timer(setup1)
>>> t.timeit()
3.2493382405780267

3rd way

>>> setup2 = '''
... string = 'Hello %*& World'
... repl = {'*': 'star', '%': 'pct', '&': 'and'}
... repl = str.maketrans(repl)
... string = string.translate(repl)
...
... '''
>>> t = Timer(setup2)
>>> t.timeit()
3.3588874718125226
>>>

Tests

It's nice to see that you have included various tests to verify that replace_in_string works as expected.

Docstring

Its great that you have provided a docstring, but I think it could be a bit more descriptive (argument string is not even mentioned). For example:

"""
      string: a str.
replacements: a dictionary whose keys are strings and whose values
              are lists of string replacements.

For each key in replacements, search string for occurrences
of that key replacing each occurrence with successive elements
of the key's value.
"""

Methodology

Using re.sub seems to be the best approach to string replacement.

Will you ever have a situation where you might wish to ensure that a string being replaced is on a word boundary? In that case you could surround the key with r'\b', but then calling re.escape on the key would not work. So your keys will already need to be regular expressions that do not need escaping. Would it be useful to have an additional argument, e.g. is_regex, that defaults to False but when True means that the keys are already regular expressions that should not be escaped?

Recommendation and Alternatives

I think it's indicative of something being amiss if there are too few values for any key in replacements. Consequently, in your alternative implementation of replace_func my preference would be for you to either raise an Exception or at least issue a warning for this situation.

An alternative would be to provide an extra, optional argument to your function, e.g. strict_mode=True, which causes behavior as just described but when False, issues no warnings or exceptions.

Another alternative is to define the function so that the last replacement value for a key is never popped; there is always at least one element in the value list for any key. This remaining value will be used for all subsequent replacements. In that way, you can replace all occurrences of a string with the same value just by having a replacement list consisting of a single element. The only error situation now would be to define an empty list as the value for a key.