There is a clean, one-line way of doing this in Pandas:

df['col_3'] = df.apply(lambda x: f(x.col_1, x.col_2), axis=1)

This allows f to be a user-defined function with multiple input values, and uses (safe) column names rather than (unsafe) numeric indices to access the columns.

Example with data (based on original question):

import pandas as pd

df = pd.DataFrame({'ID':['1', '2', '3'], 'col_1': [0, 2, 3], 'col_2':[1, 4, 5]})
mylist = ['a', 'b', 'c', 'd', 'e', 'f']

def get_sublist(sta,end):
    return mylist[sta:end+1]

df['col_3'] = df.apply(lambda x: get_sublist(x.col_1, x.col_2), axis=1)

Output of print(df):

  ID  col_1  col_2      col_3
0  1      0      1     [a, b]
1  2      2      4  [c, d, e]
2  3      3      5  [d, e, f]

If your column names contain spaces or share a name with an existing dataframe attribute, you can index with square brackets:

df['col_3'] = df.apply(lambda x: f(x['col 1'], x['col 2']), axis=1)

As far as the defining columns twice part goes, you should define the ones to be zfilled once and then reference it in both places. Then you can use applymap and ditch one lambda:

zfill_cols = ['Date', 'Departure time', 'Arrival time']
df[zfill_cols] = df[zfill_cols].applymap(lambda s: s.zfill(4))

Or on the entire dataframe:

df = df.applymap(lambda s: s.zfill(4))

EDIT: You can also use DataFrame.apply and Series.str.zfill which is probably faster because it takes advantage of vector functions (unlike Series.apply and DataFrame.applymap:

df[zfill_cols] = df[zfill_cols].apply(lambda se: se.str.zfill(4))

Or

df = df.apply(lambda se: se.str.zfill(4))

You need to use axis=1 to tell Pandas you want to apply a function to each row. The default is axis=0.

tp['col'] = tp.apply(lambda row: row['source'] if row['target'] in ['b', 'n'] else 'x',
                     axis=1)

However, for this specific task, you should use vectorised operations. For example, using numpy.where:

tp['col'] = np.where(tp['target'].isin(['b', 'n']), tp['source'], 'x')

pd.Series.isin returns a Boolean series which tells numpy.where whether to select the second or third argument.

First for test missing values or None use isna, for elementwise processing use DataFrame.applymap:

def pad_value(item):
    if pd.isna(item):
        return None
    else:
        return str(item).zfill(7)

cols = ['A', 'B']
df[cols] = df[cols].applymap(pad_value)

With sample data are created floats, here is solution for convert to strings without .0 and NaN and None to Nones, last processing Series.str.zfill (working also with None/NaNs)

df = pd.DataFrame({
    'A':[123,None,456],
    'B':[3698,598,None]})

cols = ['A', 'B']
df[cols] = (df[cols].astype('Int64')
                    .astype(str)
                    .mask(df.isna(), None)
                    .apply(lambda x: x.str.zfill(7))
print (df)
         A        B
0  0000123  0003698
1     None  0000598
2  0000456     None