use the apply method

In [80]: x = {'Value': ['Test', 'XXX123', 'XXX456', 'Test']}
In [81]: df = pd.DataFrame(x)
In [82]: df.Value.apply(lambda x: np.nan if x.startswith('XXX') else x)
Out[82]:
0    Test
1     NaN
2     NaN
3    Test
Name: Value, dtype: object

Performance Comparision of apply, where, loc

You'll want to use apply with the parameter axis=1 to insure the function passed to apply is applied to each row.

The referenced question has an answer that uses this loop.

for i, row in df.iterrows():
    if <something>:
        row['ifor'] = x
    else:
        row['ifor'] = y

    df.ix[i]['ifor'] = x

To use a lambda with the same logic

df['ifor'] = df.apply(lambda row: x if something else y, axis=1)

Given you dataframe is data, use the below apply() function:

For column with list of words separated by space:

data['New_instructions'] = data['instructions'].apply(lambda x: [i.split()[0].strip()for i in x])

For column with single list word:

data['New_instructions'] = data['instructions'].apply(lambda x: x.split()[0].strip())

I this you need to add axis=1 to your apply() call, to make the lambda function be executed for each row, instead of for each column, which is the default:

test["Structured Pos"] = test.apply(
    lambda x: "Freeform" if x["Coupa Type"] == "freeform" else "Structured PO",
    axis=1,
)

(You also need to use x["Coupa Type"] instead of test["Coupa Type"] in the Lambda function, as I've done above.)

A more efficient solution for this case though would be to do something link this:

test["Structured Pos"] = test["Coupa Type"].map({"freeform": "Freeform"}).fillna("Structured PO")

...because map replaces all values in the series that are keys in the dictionary with the values of the dictionary, and values in the Series that aren't in keys in the dictionary, it replaces with NaN, so you can use fillna to supply the default.

You can use str.split

data['TYPE'] = data['AIRCRAFT'].str.split().str[0]

You get

    AIRCRAFT    TYPE
0   B738 (C-GKWJ)   B738
1   A321 (C-FJNX)   A321

You can also use str.extract though split is ideal

 data['TYPE'] = data['AIRCRAFT'].str.extract('(\w+)\s\(', expand = False)

As @DSM points out, you can do this more directly using the vectorised string methods:

df['Date'].str[-4:].astype(int)

Or using extract (assuming there is only one set of digits of length 4 somewhere in each string):

df['Date'].str.extract('(?P<year>\d{4})').astype(int)

An alternative slightly more flexible way, might be to use apply (or equivalently map) to do this:

df['Date'] = df['Date'].apply(lambda x: int(str(x)[-4:]))
             #  converts the last 4 characters of the string to an integer

The lambda function, is taking the input from the Date and converting it to a year.
You could (and perhaps should) write this more verbosely as:

def convert_to_year(date_in_some_format):
    date_as_string = str(date_in_some_format)  # cast to string
    year_as_string = date_in_some_format[-4:] # last four characters
    return int(year_as_string)

df['Date'] = df['Date'].apply(convert_to_year)

Perhaps 'Year' is a better name for this column...

You have to add the = operator. DataFrames are not mutable like lists, therefore you have to store the value in the column: Energy['Energy Supply'] = ....

Energy['Energy Supply'] = Energy['Energy Supply'].apply(lambda x: x*(10**6))
Energy.head()

Given a sample dataframe df as:

   a  b
0  1  2
1  2  3
2  3  4
3  4  5

what you want is:

df['a'] = df['a'].apply(lambda x: x + 1)

that returns:

   a  b
0  2  2
1  3  3
2  4  4
3  5  5