Use np.where

Ex:

import numpy as np

df['Target'] = np.where(df['Target'] == "U", df['Action'], df['Target'])

I like re module solutions

if not re.search(r'(?<!X)AAA', myString):
    ...

You are not keeping the result of x.replace(). Try the following instead:

for tag in tags:
    x = x.replace(tag, '')
print x

Note that your approach matches any substring, and not just full words. For example, it would remove the LOL in RUN LOLA RUN.

One way to address this would be to enclose each tag in a pair of r'\b' strings, and look for the resulting regular expression. The r'\b' would only match at word boundaries:

for tag in tags:
    x = re.sub(r'\b' + tag + r'\b', '', x)

A defaultdict can be very helpful here. The defaultdict enables the creation of the specified dict-key-object (list) if it does not already exist, or uses the existing object's methods if it does exist.

On first iteration, the dict is empty, but the list.append method can be called on the 'empty' key, as the default object of the dict is a list. This SO post goes into greater detail.

For example:

from collections import defaultdict

sublist = ['green', 'red', 'red', 'red', 'blue', 'blue', 'green']

d = defaultdict(list)
for i in sublist:
    d[i].append(i)

Output:

defaultdict(list,
            {'green': ['green', 'green'],
             'red': ['red', 'red', 'red'],
             'blue': ['blue', 'blue']})

Which can be accessed just like a builtin dict:

>>> d['green']
['green', 'green'] 

Or, explicitly converted into a builtin dict:

>>> dict(d)
{'green': ['green', 'green'],
 'red': ['red', 'red', 'red'],
 'blue': ['blue', 'blue']}  

Removing unwanted items

If the source list contains unwanted items, they can be removed as shown below.

The complete code:

from collections import defaultdict

sublist = ['green', 'red', 'red', 'red', 'blue', 'blue', 'green',
           None, 'Sam', 'Bob', 'Sue', None, None]

# Append items to dict key/items.
d = defaultdict(list)
for i in sublist:
    d[i].append(i)

# Define a list of items to be kept.
keep = ['blue', 'red', 'green']

# Iterate a *copy* of the dict and pop the unwanted items.
for k in d.copy():
    if k not in keep:
        d.pop(k)

Output:

defaultdict(list,
            {'green': ['green', 'green'],
             'red': ['red', 'red', 'red'],
             'blue': ['blue', 'blue']})

new = ['a ','local ','is ']
my_str = 'anindianaregreat'
old = ['an','indian','are']

for i, string in enumerate(old):
    my_str = my_str.replace(string, new[i], 1)

print(my_str)

Here's how I would do it:

Just a couple notes first, you seem to have confused the syntax for dictionaries. Dictionaries start with { and end with }. [ and ] are used for lists and they don't have : (a list looks like: [1,2,3,4,5]. The following code will iterate through all the keys in the dictionary and then replace them properly in the string.

li={'20':'1','40':'2','60':'3','80':'4','100':'5'}

string='abcd abcd 60'
for key in li:
    string = string.replace(key,li[key])

print(string)

As said the check is not required. But it might help if you may have a lot cases where there are a lot of strings where the substring is not there. In that case you might get a good amount of performance gain. Checking it using the timeit module:

Comparison where there a lot of cases where the substring is not present in the string. Note that there is a big difference in performance.

➜  ~ python3.5 -m timeit '"vxnxikmhdc".replace("a", "b") if "a" in "vxnxikmhdc" else "vxnxikmhdc"'
10000000 loops, best of 3: 0.0524 usec per loop
➜  ~ python3.5 -m timeit '"vxnxikmhdc".replace("a", "b")'
1000000 loops, best of 3: 0.207 usec per loop

Comparison where substring is present in the string. Note that there is very little difference in performance.

➜  ~ python3.5 -m timeit '"vxnxikmhdc".replace("x", "j")'
1000000 loops, best of 3: 0.245 usec per loop
➜  ~ python3.5 -m timeit '"vxnxikmhdc".replace("x", "j") if "x" in "vxnxikmhdc" else "vxnxikmhdc"'
1000000 loops, best of 3: 0.308 usec per loop

The string replace method does not replace characters by position, it replaces them by what characters they are.

>>> 'apple aardvark'.replace('a', '!')
'!pple !!rdv!rk'

So in your first case, you are telling to replace "hk" with "kh". It doesn't "know" that you want to only replace one of the occurrences; it just knows you want to replace "hk" with "kh", so it replaces all occurrences.

You can use the count argument to replace to specify that you only want to replace the first occurrence:

>>> go = 'USC_45774-1111-0     <hkxhk> {10} ; 78'
... go.replace(go[22:24],go[23:21:-1],1)
'USC_45774-1111-0     <khxhk> {10} ; 78'

Note, though, that this will always replace the first occurrence, not necessarily the occurrence at the position in the string you specified. In this case I guess that's what you want, but it may not work directly for other similar tasks. (That is, there is no way to use this method as-is to replace the second occurrence or the third occurrence; you can only replace the first, or the first two, or the first three, etc. To replace the second or third occurrence you'd need to do a bit more.)

As for the second part of your question, you are misunderstanding what if "{01}" or "{-1}" in line means. It means, in layman's terms, if "{01}" or if "{-1}" in line. Since if "{01}" is always true (i.e., the string "{01}" is not a false value), the whole condition is always true. What you want is if "{01}" in line or "{-1}" in line".