The issue with some of the other answers is that they don't work with all Dataframes, only with Series, or Dataframes that can be implicitly converted to a Series. I understand this is because the .str construct exists in the Series class, but not in the Dataframe class.

To work with Dataframes, you can make your regular expression case insensitive with the (?i) extension. I don't believe this is available in all flavors of RegEx but it works with Pandas.

d = {'a':['test', 'Test', 'cat'], 'b':['CAT', 'dog', 'Cat']}
df = pd.DataFrame(data=d)

    a       b
0   test    CAT
1   Test    dog
2   cat     Cat

Then use replace as you normally would but with the (?i) extension:

df.replace('(?i)cat', 'MONKEY', regex=True)

    a       b
0   test    MONKEY
1   Test    dog
2   MONKEY  MONKEY

The case argument is actually a convenience as an alternative to specifying flags=re.IGNORECASE. It has no bearing on replacement if the replacement is not regex-based.

So, when regex=True, these are your possible choices:

pd.Series('Jr. eng').str.replace(r'jr\.', 'jr', regex=True, case=False)
# pd.Series('Jr. eng').str.replace(r'jr\.', 'jr', case=False)

0    jr eng
dtype: object

Or,

pd.Series('Jr. eng').str.replace(r'jr\.', 'jr', regex=True, flags=re.IGNORECASE)
# pd.Series('Jr. eng').str.replace(r'jr\.', 'jr', flags=re.IGNORECASE)

0    jr eng
dtype: object

You can also get cheeky and bypass both keyword arguments by incorporating the case insensitivity flag as part of the pattern as ?i. See

pd.Series('Jr. eng').str.replace(r'(?i)jr\.', 'jr')
0    jr eng
dtype: object

Note
You will need to escape the period \. in regex mode, because the unescaped dot is a meta-character with a different meaning (match any character). If you want to dynamically escape meta-chars in patterns, you can use re.escape.

For more information on flags and anchors, see this section of the docs and re HOWTO.

From the source code, it is clear that the "case" argument is ignored if regex=False. See

# Check whether repl is valid (GH 13438, GH 15055)
if not (is_string_like(repl) or callable(repl)):
    raise TypeError("repl must be a string or callable")

is_compiled_re = is_re(pat)
if regex:
    if is_compiled_re:
        if (case is not None) or (flags != 0):
            raise ValueError("case and flags cannot be set"
                             " when pat is a compiled regex")
    else:
        # not a compiled regex
        # set default case
        if case is None:
            case = True

        # add case flag, if provided
        if case is False:
            flags |= re.IGNORECASE
    if is_compiled_re or len(pat) > 1 or flags or callable(repl):
        n = n if n >= 0 else 0
        compiled = re.compile(pat, flags=flags)
        f = lambda x: compiled.sub(repl=repl, string=x, count=n)
    else:
        f = lambda x: x.replace(pat, repl, n)

You can see the case argument is only checked inside the if statement.

IOW, the only way is to ensure regex=True so that replacement is regex-based.

Series.str.contains has a case parameter that is True by default. Set it to False to do a case insensitive match.

df2 = df1['company_name'].str.contains("apple", na=False, case=False)

Either str.replace or replace can be used. Just make sure the pattern matches the start (^) and end ($) of the string for whole cell matches.

str.replace:

for val in valold:
    dfPA[col] = dfPA[col].str.replace(rf'^{val}$', key, case=False, regex=True)

replace:

for val in valold:
    dfPA[col] = dfPA[col].replace(rf'(?i)^{val}$', key, regex=True)

*regex=False by default for replace so the regex case insensitivity modifier will not work for replace without setting regex=True as it will literally match the characters "(?i)".

Sample Data and Output:

import pandas as pd

dfPA = pd.DataFrame({
    'col': ['COM', 'COMMERCIAL', 'COmMErCIaL', 'Something else',
            'comical']
})

valold = ['COM', 'COMMERCIAL']
key = 'Commercial'
col = 'col'
for val in valold:
    dfPA[col] = dfPA[col].str.replace(rf'^{val}$', key, case=False, regex=True)

print(dfPA)

              col
0      Commercial
1      Commercial
2      Commercial
3  Something else
4         comical