I think you have a few issues with the RegEx's.

As @Abdou just said use either '\\2 \\1' or better r'\2 \1', as '\1' is a symbol with ASCII code 1

Your solution should work if you will use correct RegEx's:

In [193]: df
Out[193]:
              name
0        John, Doe
1  Max, Mustermann

In [194]: df.name.replace({r'(\w+),\s+(\w+)' : r'\2 \1'}, regex=True)
Out[194]:
0          Doe John
1    Mustermann Max
Name: name, dtype: object

In [195]: df.name.replace({r'(\w+),\s+(\w+)' : r'\2 \1', 'Max':'Fritz'}, regex=True)
Out[195]:
0            Doe John
1    Mustermann Fritz
Name: name, dtype: object

You could use Series.str.replace:

import pandas as pd

df = pd.DataFrame(['$40,000*','$40000 conditions attached'], columns=['P'])
print(df)
#                             P
# 0                    $40,000*
# 1  $40000 conditions attached

df['P'] = df['P'].str.replace(r'\D+', '', regex=True).astype('int')
print(df)

yields

       P
0  40000
1  40000

since \D matches any character that is not a decimal digit.

The problem is that your regex matches the entire string, so the entire string is replaced by the empty string. Instead what you need is to capture the numbers of interest in your string and replace the match with the captured values of the dates:

import pandas as pd
df = pd.DataFrame({'date':['2016-03-26 17:47:46', '2018-03-26 17:47:46']})
re_express = re.compile('([\d]{4}).([\d]{2}).([\d]{2}).*')
df['date'] = df['date'].str.replace(re_express, r'\1\2\3')

Note the r'\1\2\3' part that refers to the first, second and third capture group respectively, which (using the modified pattern) refer to exactly the values you're interested in. If the strings can only ever contain hyphens between the date components then I'd suggest matching exactly that (-) rather than any character (.).

If you really want to stick with the "match and delete" approach, you could write a regex to catch "a hyphen or anything starting with a space":

re_express = re.compile('-| .*')
df['date'] = df['date'].str.replace(re_express, '')

But explicit is better than implicit, and the former method will more reliably ensure that malformed data won't silently be truncated in unexpected ways.

Use a callable for repl

new_data = data.str.replace('(\d+[A-Z])', lambda m: m.group(1).lower())

Out[49]:
0        21st StNew York
1    Exampe BlvdSt Louis
2                 1st Rd
dtype: object

You could match as least word chars using \w*? and then capture in group 1 matching an optional A followed by BC (A?BC) followed by a word boundary.

\w*?(A?BC)\b

Regex demo

In there replacement use group 1

df.Col.str.replace(r'\w*?(A?BC)\b', r'\1')