Maybe there is a more elegant way, but I would do in this way:

df['C'] = df['B'].apply(lambda x: f(x)[0])
df['D'] = df['B'].apply(lambda x: f(x)[1])

Applying the function to the columns and get the first and the second value of the outputs. It returns:

   A  B   C   D
0  1  O  Ok  On
1  2  P  Pk  Pn
2  3  Q  Qk  Qn
3  4  R  Rk  Rn

EDIT:

In a more concise way, thanks to this answer:

df[['C','D']] = df['B'].apply(lambda x: pd.Series([f(x)[0],f(x)[1]]))

you want to replace

print df.loc[df['Col1'].isnull(),['Col1','Col2', 'Col3']]

  Col1 Col2 Col3
2  NaN  NaN  NaN
3  NaN  NaN  NaN

With:

replace_with_this = df.loc[df['Col1'].isnull(),['col1_v2','col2_v2', 'col3_v2']]
print replace_with_this

  col1_v2 col2_v2 col3_v2
2       a       b       d
3       d       e       f

Seems reasonable. However, when you do the assignment, you need to account for index alignment, which includes columns.

So, this should work:

df.loc[df['Col1'].isnull(),['Col1','Col2', 'Col3']] = replace_with_this.values

print df

  Col1 Col2 Col3 col1_v2 col2_v2 col3_v2
0    A    B    C     NaN     NaN     NaN
1    D    E    F     NaN     NaN     NaN
2    a    b    d       a       b       d
3    d    e    f       d       e       f

I accounted for columns by using .values at the end. This stripped the column information from the replace_with_this dataframe and just used the values in the appropriate positions.

You can return pd.Series:

dp_data_df = pd.DataFrame({'A':[3,5,6,6],
                           'B':[6,7,8,9],
                           'P':[5,6,7,0],
                           'Y':[1,2,3,4]})
print (dp_data_df)
   A  B  P  Y
0  3  6  5  1
1  5  7  6  2
2  6  8  7  3
3  6  9  0  4

def update_row(row):
    listy = [1,2,3]
    return pd.Series(listy)

dp_data_df[['A', 'P','Y']] = dp_data_df.apply(update_row, axis=1)
print (dp_data_df)
   A  B  P  Y
0  1  6  2  3
1  1  7  2  3
2  1  8  2  3
3  1  9  2  3

Try modifying df["col_1","col_2","col_3"]=df["col_1","col_2","col_3"].apply(funcgetsh) to df[["col_1","col_2","col_3"]]=df[["col_1","col_2","col_3"]].apply(funcgetsh). See example below.

import pandas as pd

data1 = {"col_1": [1, 2, 3],
        "col_2": [4, 5, 6],
        'col_3': [7, 8, 9]}

df1 =pd.DataFrame(data1)

print(df1)

   col_1  col_2  col_3
0      1      4      7
1      2      5      8
2      3      6      9

def times10(x):
    return 10*x

df1[['col_1', 'col_2']] = df1[['col_1', 'col_2']].apply(times10)

print(df1)

   col_1  col_2  col_3
0     10     40      7
1     20     50      8
2     30     60      9

This workaround should work for you, replace your function with the example.

import pandas as pd

data1 = {"col_1": [1, 2, 3],
        "col_2": [4, 5, 6],
        'col_3': [7, 8, 9]}

df1 =pd.DataFrame(data1)

# combine columns you want to apply the function to
working_data = df1[['col_1', 'col_2']]

# drop the original values from the columns being altered
# keep unaltered columns
df2 = df1.drop(['col_1', 'col_2'], axis = 1)

# your function here
def times10(x):
    return 10*x

# apply function to the columns/values desired
working_data = working_data.apply(times10)

# merge post function columns/values with the original unaltered columns/values
final_df = pd.merge(working_data, df2, how = 'inner', left_index = True, right_index = True)

print(final_df)

   col_1  col_2  col_3
0     10     40      7
1     20     50      8
2     30     60      9

This should achieve what you want:

import pandas

df = pandas.DataFrame(data=[[0, 1, 2], [1, 2, 3]], columns=['a', 'b', 'c'])

def process(val):
    return (val + 1, val + 2)

df[['d', 'e']] = df['c'].apply(process)

The function will return two series in a tuple. If you assign it to a tuple of df['A'] and df['B'] this will work:

(df['A'], df['B']) = my_function(df['C'])

Output:

I usually do this using zip:

>>> df = pd.DataFrame([[i] for i in range(10)], columns=['num'])
>>> df
    num
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9

>>> def powers(x):
>>>     return x, x**2, x**3, x**4, x**5, x**6

>>> df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
>>>     zip(*df['num'].map(powers))

>>> df
        num     p1      p2      p3      p4      p5      p6
0       0       0       0       0       0       0       0
1       1       1       1       1       1       1       1
2       2       2       4       8       16      32      64
3       3       3       9       27      81      243     729
4       4       4       16      64      256     1024    4096
5       5       5       25      125     625     3125    15625
6       6       6       36      216     1296    7776    46656
7       7       7       49      343     2401    16807   117649
8       8       8       64      512     4096    32768   262144
9       9       9       81      729     6561    59049   531441