You can use the vectorised str method to split on '@' character and then join the left side with the new domain name:

In [42]:

df = pd.DataFrame({'email':['[email protected]', '[email protected]', '[email protected]']})
df
Out[42]:
                email
0      [email protected]
1    [email protected]
2  [email protected]

In [43]:

df['email'] = df.email.str.split('@').str[0] + '@newcompany.com'
df

Out[43]:
                     email
0    [email protected]
1     [email protected]
2  [email protected]

another method is to call the vectorised replace which accepts a regex as a pattern on the strings:

In [56]:

df['email'] = df['email'].str.replace(r'@.+', '@newcompany.com')
df
Out[56]:
                     email
0    [email protected]
1     [email protected]
2  [email protected]

Timings

In [58]:

%timeit df['email'] = df['email'].str.replace(r'@.+', '@newcompany.com')
1000 loops, best of 3: 632 µs per loop
In [60]:

%timeit df['email'] = df.email.str.split('@').str[0] + '@newcompany.com'
1000 loops, best of 3: 1.66 ms per loop

In [63]:

%timeit df['email'] = df['email'].replace(r'@.+', '@newcompany.com', regex=True)
1000 loops, best of 3: 738 µs per loop

Here we can see that the str.replace regex version is nearly 3x faster than the split method, interestingly the Series.replace method which would seem to be doing the same thing as the str.replace is slower.

According to the pandas documentation:

Regex substitution is performed under the hood with re.sub. The rules for substitution for re.sub are the same.

So, yes, any substitutions which can be performed with Python's re.sub (such as \1) can also be performed with pandas.DataFrame.replace. See the Python documentation for more information.

Python doesn't really deal with wildcards. You should read more on Regex, which isn't Python specific.

In any case, this should take care of it:

ex = "/Volumes/Obelix/5215.tif, /Volumes/Gemeinsam/25.tif, /Volumes/Obelix/5100.tif"
newex = re.sub(r'/Volumes/Gemeinsam/.+?,?(\s|$)', '', ex)

df_new = pd.DataFrame(np.ones(df.shape), columns=df.columns)

import numpy as np
import pandas as pd

d = [
    [1,1,1,1,1],
    [2,2,2,2,2],
    [3,3,3,3,3],
    [4,4,4,4,4],
    [5,5,5,5,5],
]

cols = ["A","B","C","D","E"]

%timeit df1 = pd.DataFrame(np.ones(df.shape), columns=df.columns)
10000 loops, best of 3: 94.6 µs per loop

%timeit df2 = df.copy(); df2.loc[:, :] = 1
1000 loops, best of 3: 245 µs per loop

%timeit df3 = df * 0 + 1
1000 loops, best of 3: 200 µs per loop

You can chain startswith and endswith masks or use contains - ^ is for match start of string, .* is for any string and $ for end:

mask = data['Safe'].str.startswith("CDS") & data['Safe'].str.endswith("DEFAULT-UNIX-ROOT")

Or regex:

mask = data['Safe'].str.contains("^CDS-.*DEFAULT-UNIX-ROOT$")

Sample:

data = pd.DataFrame({'Safe':['CDS-DEFAULT-UNIX-ROOT',
                             'CDS-NhjghOI-DEFAULT-UNIX-ROOT',
                             'CDS-NhjghOI-DEFAULT',
                             'ACDS-DEFAULT-UNIX-ROOT']})

print (data)
                            Safe
0          CDS-DEFAULT-UNIX-ROOT
1  CDS-NhjghOI-DEFAULT-UNIX-ROOT
2            CDS-NhjghOI-DEFAULT
3         ACDS-DEFAULT-UNIX-ROOT

mask = data['Safe'].str.contains("^CDS-.*DEFAULT-UNIX-ROOT$")
print (mask)
0     True
1     True
2    False
3    False
Name: Safe, dtype: bool

Nope, str.replace won't work. You need re.sub.

e.g.:

>>> re.sub(r'\(.*\)', '', 'foobar (###)')
'foobar '

You can perform this task by forming a |-separated string. This works because pd.Series.str.replace accepts regex:

Replace occurrences of pattern/regex in the Series/Index with some other string. Equivalent to str.replace() or re.sub().

This avoids the need to create a dictionary.

import pandas as pd

df = pd.DataFrame({'A': ['LOCAL TEST', 'TEST FOREIGN', 'ANOTHER HELLO', 'NOTHING']})

pattern = '|'.join(['LOCAL', 'FOREIGN', 'HELLO'])

df['A'] = df['A'].str.replace(pattern, 'CORP', regex=True)

#               A
# 0     CORP TEST
# 1     TEST CORP
# 2  ANOTHER CORP
# 3       NOTHING

Try with split

df['col4'] = df.col4.str.split('.').str[2]