Nest if .. elses:

lambda x: x*10 if x<2 else (x**2 if x<4 else x+10)

In [1]: df
Out[1]:
   data
0     1
1     2
2     3
3     4

You want to apply a function that conditionally returns a value based on the selected dataframe column.

In [2]: df['data'].apply(lambda x: 'true' if x <= 2.5 else 'false')
Out[2]:
0     true
1     true
2    false
3    false
Name: data

You can then assign that returned column to a new column in your dataframe:

In [3]: df['desired_output'] = df['data'].apply(lambda x: 'true' if x <= 2.5 else 'false')

In [4]: df
Out[4]:
   data desired_output
0     1           true
1     2           true
2     3          false
3     4          false

is that what you want?

In [300]: frame[['b','c']].apply(lambda x: x['c'] if x['c']>0 else x['b'], axis=1)
Out[300]:
0   -1.099891
1    0.582815
2    0.901591
3    0.900856
dtype: float64

Apply across columns

Use pd.DataFrame.apply instead of pd.Series.apply and specify axis=1:

df['one'] = df.apply(lambda row: row['one']*100 if row['two']>8 else \
                     (row['one']*1 if row['two']<8 else row['one']**2), axis=1)

Unreadable? Yes, I agree. Let's try again but this time rewrite as a named function.

Using a function

Note lambda is just an anonymous function. We can define a function explicitly and use it with pd.DataFrame.apply:

def calc(row):
    if row['two'] > 8:
        return row['one'] * 100
    elif row['two'] < 8:
        return row['one']
    else:
        return row['one']**2

df['one'] = df.apply(calc, axis=1)

Readable? Yes. But this isn't vectorised. We're looping through each row one at at at time. We might as well have used a list. Pandas isn't just for clever table formatting, you can use it for vectorised calculations using arrays in contiguous memory blocks. So let's try one more time.

Vectorised calculations

Using numpy.where:

df['one'] = np.where(row['two'] > 8, row['one'] * 100,
                     np.where(row['two'] < 8, row['one'],
                              row['one']**2))

There we go. Readable and efficient. We have effectively vectorised our if / else statements. Does this mean that we are doing more calculations than necessary? Yes! But this is more than offset by the way in which we are performing the calculations, i.e. with well-defined blocks of memory rather than pointers. You will find an order of magnitude performance improvement.

Another example

Well, we can just use numpy.where again.

df['one'] = np.where(df['name'].isin(['a', 'b']), 100, df['two'])

By default, df.apply(...) applies on columns. To apply your lambda on each row, specify:

df.apply(..., axis=1)

Aside from that, this looks very inefficient and can be made much faster without any lambda. A more efficient method is to vectorize your logic:

cond_wkend = df['dow'].isin({'Saturday', 'Sunday'})
cond_holdy = pd.to_datetime(df['date']).isin(holidays)

df['is_workday'] = ~(cond_wkend | cond_holdy)

Your

testdata.map(lambda x: x if (x < 30 or x > 60) else 0)

already returns what you want.

The easiest way to do this is:

df["pk_day"] = df["Date"].dt.weekday.lt(5)

Now, for why your second statement does not work. You're using:

df[(df['Date'].dt.strftime('%a')=='Sat')|(df['Date'].dt.strftime('%a')=='Sun')] 

This returns the rows in the DataFrame where the day is a weekend. Hence, it is not boolean. You could use:

lambda pkday:False if ((df['Date'].dt.strftime('%a')=='Sat')|(df['Date'].dt.strftime('%a')=='Sun')) else True 

Your last statement works without any errors.

This issue was that you were first filling the NaN and then using .str.split(), so the equality should be with a list, not the element of the list. You can see this by first checking what x is in your lambda function.

dfs['freq'].str.split(',')
#0                                       [text1]
#1                         [text1, text2, text1]
#2                         [text1, text2, text3]
#3                                       [text1]
#4           [text1, text2, text3, text4, text5]
#5                                    [no_guide]
#6    [text1, text2, text3, text4, text5, text6]

The correct equality to check is whether x is a list whose only element is 'no_guide':

lambda x: 0 if x == ['no_guide'] else len(set(x))

Since len(set(x)) returns a number, you may also want to return 0 and not the string '0'.