I like re module solutions

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

>>> import re
>>> string = '85.2147....85.2150..85.2152..85.2166...85.2180.85.2190.'
>>> result = re.findall('(\d+\.\d+)\.+',string)
>>> result
['85.2147', '85.2150', '85.2152', '85.2166', '85.2180', '85.2190']

Check the following code with regex solution:

import re

# set up the regex pattern
# the words which should be skipped, must be whole word and case-insensitive
ptn_to_skip = re.compile(r'\b(?:no|none)\b', re.IGNORECASE)

# the pattern for mapping
# Note: any regex meta charaters need to be escaped, or it will fail.
ptn_to_map = re.compile(r'\b(' + '|'.join(replace_terms_df.Text.tolist()) + r')\b')

# map from text to Replace_item
terms_map = replace_terms_df.set_index('Text').Replace_item

def adjust_text(x):
    # if 1 - 3 ptn_to_skip found, return x, 
    # otherwise, map the matched group \1 with terms_map
    if 0 < len(ptn_to_skip.findall(x)) <= 3:
        return x
    else:
        return ptn_to_map.sub(lambda y: terms_map[y.group(1)], x)

# do the conversion:
text_df['new_text'] = text_df.Text.apply(adjust_text)

Some Notes:

• I converted the texts in replace_terms_df.Text into a regex. default the texts are all plain-text without regex meta characters.
• if there are any regex meta characters like '$', ']' etc, you will have to escape them. regex tends to be slow especially with meta characters, if you have large chuck of data, don't suggest this solution to you.

Update:

A new logic is added to check the excluded-words ['no', 'none'] first, if matches, then find the next 0-3 words which are not themselves excluded-words, save them to \1, the actual matched search-word will be saved in \2. then in the regex replacement part, handle them differently.

Below are the new code:

import re

# pattern to excluded words (must match whole-word and case insensitive)
ptn_to_excluded = r'\b(?i:no|none)\b'

# ptn_1 to match the excluded-words ['no', 'none'] and the following maximal 3 words which are not excluded-words
# print(ptn_1)  -->    \b(?i:no|none)\b\s*(?:(?!\b(?i:no|none)\b)\S+\s*){,3}
# where (?:(?!\b(?i:no|none)\b)\S+\s*) matches any words '\S+' which is not in ['no', 'none'] followed by optional white-spaces
# {,3} to specify matches up to 3 words 
ptn_1 = r'{0}\s*(?:(?!{0})\S+\s*){{,3}}'.format(ptn_to_excluded)

# ptn_2 is the list of words you want to convert with your terms_map
# print(ptn_2)    -->    \b(?:random|here|some)\b
ptn_2 = r'\b(?:' + '|'.join(replace_terms_df.Text.tolist()) + r')\b'

# new pattern based on the alternation using ptn_1 and ptn_2
# regex:  (ptn_1)|(ptn_2)
new_ptn = re.compile('({})|({})'.format(ptn_1, ptn_2))

# map from text to Replace_item
terms_map = replace_terms_df.set_index('Text').Replace_item

# regex function to do the convertion
def adjust_map(x):
    return new_ptn.sub(lambda m:  m.group(1) or terms_map[m.group(2)], x)

# do the conversion:
text_df['new_text'] = text_df.Text.apply(adjust_map)

Explanation:

I defined two sub-patterns:

• ptn_1: try to match the words you want to be excluded, i.e., the words 'no', 'none' followed by at most 3 more words which are not in ['no', 'none']
• ptn_2: try to match one of the words you want to convert based on the replace_terms_df.

How it works:

• with the alternation '|', the regex engine will make sure ptn_1 matches before ptn_2, if neither matches, the original text is kept.
• The matched ptn_1 text will be saved in m.group(1) and ptn_2 result to m.group(2)
• In the replacement part. If m.group(1) is not Empty(meaning ptn_1 is matched) then return m.group(1) (thus this part of matches is untouched), otherwise return terms_map[y.group(2)]

Some tests below:

In []: print(new_ptn)
re.compile('(\\b(?i:no|none)\\b\\s*(?:(?!\\b(?i:no|none)\\b)\\S+\\s*){,3})|(\\b(random|here|some)\\b)')

In[]: for i in [
    'yes, no such a random text'
  , 'yes, no such a a random text'
  , 'no no no such a random text no such here here here no'
 ]: print('{}:\n  [{}]'.format(i, adjust_map(i)))
...:
yes, no such a random text:
  [yes, no such a random text]
yes, no such a a random text:
  [yes, no such a a <RANDOM_REPLACED> text]
no no no such a random text no such here here here no:
  [no no no such a random text no such here here <HERE_REPLACED> no]

Let me know if this works.

More to consider:

• in ptn_1, '\S+' is used to define a WORD, this will have issue if one of the words is something like ',none', this preceding 'comma' will let it skip the (?!\b(?:no|none)) test.
• In fact, should ',no', '"none"' be excluded? this will impact how words are counted. modifying ptn_to_excluded could be enough.

Looks like you need np.where

Ex:

test = ["No","No Error"]
data = pd.DataFrame(test, columns=["text"])
data['text'] = np.where(data['text'] == 'No', "Data not available", data['text'])
# OR data.text[data.text=='No'] = "Data not available" 
print(data)

Output:

                 text
0  Data not available
1            No Error

Using a dataframe:

dfa:

        ID No   Time    Variable    Val
0       123     0.1     A           1
1       123     0.1     B           2
2       123     0.1     C           3
3       127     0.8     A           4
4       127     0.8     B           5
5       127     0.8     C           6

you can create a dict mapper:

dictMapper = {'A' : 'aye', 'B': 'bee'}
dfa['Variable'] = dfa['Variable'].map(lambda x: dictMapper.get(x,x))
dfa:
    ID No   Time    Variable    Val
0   123     0.1     aye         1
1   123     0.1     bee         2
2   123     0.1     C           3
3   127     0.8     aye         4
4   127     0.8     bee         5
5   127     0.8     C           6

This ofcourse relies on you knowing all before: after combinations before updating your dataframe as you'll need an exact match to the dict keys.

First problem:

readin = new.read

You're not calling the method, you won't get the file contents in readin

Second problem:

if "docket =3ghi" == True:

You're comparing if a string is True - it's never True.

If you want to replace all occurrences of e that have a t after them, you can use the following:

>>> import re
>>> re.sub(r'e(?=.*t)', 'i', 'forest')
'forist'
>>> re.sub(r'e(?=.*t)', 'i', 'jungle')
'jungle'
>>> re.sub(r'e(?=.*t)', 'i', 'greet')
'griit'

This uses a lookahead, which is a zero-width assertion that checks to see if t is anywhere later in the string without consuming any characters. This allows the regex to find each e that fits this condition instead of just the first one.

Use a regular expression:

term = 'test(s|ing)?'
df_1['color_value'] = df_1['color_value'].str.replace(term, '', regex=True)
print(df_1)

Output

    id color_value
0  001       blue_
1  002         red
2  003     yellow_
3  004      orange
4  005        blue
5  006         red
6  007       blue_
7  008      orange

From the documentation on str.replace:

pat str or compiled regex
String can be a character sequence or regular expression.

UPDATE

For including "new", "origin" you could do use another regex:

term = 'test(s|ing)?|new|orig'
df_1['color_value'] = df_1['color_value'].str.replace(term, '', regex=True)
print(df_1)

Output

    id color_value
0  001       blue_
1  002         red
2  003     yellow_
3  004     orange_
4  005       blue_
5  006         red
6  007       blue_
7  008      orange

General Solution

If you have many words I suggest you use a library such as trrex it will build a regular expression from a set of words:

import pandas as pd
import trrex as tx

df_1 = pd.DataFrame({'id': ['001', '002', '003', '004', '005', '006', '007', '008'],
                     'color_value': ['blue_test', 'red', 'yellow_tests', 'orange_orig',
                                     'blue_new', 'red', 'blue_testing', 'orange']})

term = tx.make(['test', 'tests', 'testing', 'orig', 'new'], prefix="", suffix="")
df_1['color_value'] = df_1['color_value'].str.replace(term, '', regex=True)
print(df_1)

Output

    id color_value
0  001       blue_
1  002         red
2  003     yellow_
3  004     orange_
4  005       blue_
5  006         red
6  007       blue_
7  008      orange

The pattern for the given example is:

term = tx.make(['test', 'tests', 'testing', 'orig', 'new'], prefix="", suffix="")
print(term)

Output (pattern build by trrex)

(?:test(?:ing|s)?|new|orig)

DISCLAIMER

I'm the author of trrex

As i told in the comment section, You don't really need to use index.str.endswith until strictly it needs to be rather use anchors like for start ^ and endswith $ that should do a Job for you.

Just taking @Scott's sample for consideration.

df.index.str.replace(r'_s$', '_sp', regex=True)

I'm retaining this answer here for the sake of posterity ..

How about

>> df.loc[(df['date'] == '2016-09-10') & (df['value'] == 'value1'), 'value'] = 'value7'

You may want to read Indexing and Selecting Data section and this for more info

Here is a short example that should do the trick with regular expressions:

import re

rep = {"condition1": "", "condition2": "text"} # define desired replacements here

# use these three lines to do the replacement
rep = dict((re.escape(k), v) for k, v in rep.items()) 
pattern = re.compile("|".join(rep.keys()))
text = pattern.sub(lambda m: rep[re.escape(m.group(0))], text)

For example:

>>> pattern.sub(lambda m: rep[re.escape(m.group(0))], "(condition1) and --condition2--")
'() and --text--'