You're iterating through the elements within the DataFrame, in which case I'm assuming it's type str (or being coerced to str when you replace). str.replace doesn't have an argument for inplace=....

You should be doing this instead:

dataset['ver'] = dataset['ver'].str.replace('.', '')

I've run some tests here and I think I've found the answer.

My var self.name has a <class 'PyQt4.QtCore.QString'> type, since I'm getting it from a QtWidget. Someone, please, correct me if I'm wrong but from the tests I run and from the docs (http://doc.qt.io/qt-5/qstring.html#replace) it seems that the replace method in <class 'PyQt4.QtCore.QString'> happens inplace. Whereas for the Python str, it does not since python strings are immutable.

So, in short:

• Python str: inplace=False (Python strings are immutable)
• PyQt4.QtCore.QString: inplace=True

Anyway, hope this can be helpful

You can create the function create_frame without inplace=True.

if you use inplace=True, it will return None from the func create_frame.

similarly, Pandas dataframe: set_index with inplace=True returns a NoneType, why??

import pandas as pd

def create_frame(path):
    df1 = pd.read_excel(path)
    return df1.replace(('Visit 2: Day 1','Day 1'))

df = create_frame('example.xlsx')
df.to_csv('test.csv')

when you use df2 = df1.replace(('Visit 2: Day 1','Day 1')), it will not affect df1.

so without use func, you can do like this:

df1 = pd.read_excel(path)
df2 = df1.replace(('Visit 2: Day 1','Day 1'))
df2.to_csv('test.csv')

df1 = pd.read_excel(path)
df1.replace(('Visit 2: Day 1','Day 1'), inplace=True)
df1.to_csv('test.csv')

When you select the columns for replacement with df[col_list], a slice (a copy) of your dataframe is created. The copy is updated, but never written back into the original dataframe.

You should either replace one column at a time or use nested dictionary mapping:

df.replace(to_replace={'col1' : {99 : 0}, 'col2' : {99 : 0}}, 
           inplace=True)

The nested dictionary for to_replace can be generated automatically:

d = {col : {99:0} for col in col_list}

Don't use a string, use something mutable like bytearray:

#!/usr/bin/python

s = bytearray("my dog has fleas")
for n in xrange(len(s)):
    s[n] = chr(s[n]).upper()
print s

Results in:

MY DOG HAS FLEAS

Edit:

Since this is a bytearray, you aren't (necessarily) working with characters. You're working with bytes. So this works too:

s = bytearray("\x81\x82\x83")
for n in xrange(len(s)):
    s[n] = s[n] + 1
print repr(s)

gives:

bytearray(b'\x82\x83\x84')

If you want to modify characters in a Unicode string, you'd maybe want to work with memoryview, though that doesn't support Unicode directly.

Because .replace('=', '') requires the cell value to be exactly '=' which is obviously not true in your case.

You may instead use it with regex:

df = pd.DataFrame({'a': ['="abc"', '="bcd"'], 'b': ['="uef"', '="hdd"'], 'c':[1,3]})
df.replace([r'^="', r'"$'], '', regex=True, inplace=True)
print(df)

     a    b  c
0  abc  uef  1
1  bcd  hdd  3

Two regular expressions are used here, with the first taking care of the head and the second the tail.

When inplace=True is passed, the data is renamed in place (it returns nothing), so you'd use:

df.an_operation(inplace=True)

When inplace=False is passed (this is the default value, so isn't necessary), performs the operation and returns a copy of the object, so you'd use:

df = df.an_operation(inplace=False) 

Use fileinput.FileInput, with inplace=True. printed line will be used as a replacement string for each line.

myfile = fileinput.FileInput("inputRegex.txt", inplace=True)

for line in myfile:
    line = re.sub(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?",
                  "foundValue",
                  line.rstrip())
    print(line)

UPDATE

re.sub can accept a function as replacement. It will be called with match object and the return value of the function is used as a replacement string.

The following is slightly modified version to use captured groups (to use in replacement function).

line = re.sub(r"([+-]? *)(\d+(?:\.\d*)?|\.\d+)([eE][+-]?\d+)?",
              lambda m: m.group(1) + re.sub('(\..{4}).*', r'\1', m.group(2)) + (m.group(3) or ''),
              line.rstrip())