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

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.

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.

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

using regular expression word boundary:

import re

print(re.sub(r"\bis\b","was","This is my sentence"))

Better than a mere split because works with punctuation as well:

print(re.sub(r"\bis\b","was","This is, of course, my sentence"))

gives:

This was, of course, my sentence

Note: don't skip the r prefix, or your regex would be corrupt: \b would be interpreted as backspace.

You can use regex with lambda function that receives the match object:

0    qqq--++www++
1      1234+5678-
dtype: object

s.str.replace(pat=r"\+|-", repl= lambda mo: "+" if mo.group()=="-" else "-", regex=True)

0    qqq++--www--
1      1234-5678+
dtype: object

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

You should use:

word = word.replace(word[i],'7', 1)

to indicate that you want to make one character replacement. Calling replace() without indicating how many replacements you wish to make will replace any occurrence of the character "e" (as found at word[i]) by "7".