They should be one regular expression, and should be in one string:

"nt|nv"  # rather than "nt" | " nv"
f_recs[f_recs['Behavior'].str.contains("nt|nv", na=False)]

Python doesn't let you use the or (|) operator on strings:

In [1]: "nt" | "nv"
TypeError: unsupported operand type(s) for |: 'str' and 'str'

You need to set the regex flag (to interpret your search as a regular expression):

whatIwant = df['Column_with_text'].str.contains('value1|value2|value3',
                                                 case=False, regex=True)

df['New_Column'] = np.where(whatIwant, df['Column_with_text'])

------ Edit ------

Based on the updated problem statement, here is an updated answer:

You need to define a capture group in the regular expression using parentheses and use the extract() function to return the values found within the capture group. The lower() function deals with any upper case letters

df['MatchedValues'] = df['Text'].str.lower().str.extract( '('+pattern+')', expand=False)        

One option is just to use the regex | character to try to match each of the substrings in the words in your Series s (still using str.contains).

You can construct the regex by joining the words in searchfor with |:

>>> searchfor = ['og', 'at']
>>> s[s.str.contains('|'.join(searchfor))]
0    cat
1    hat
2    dog
3    fog
dtype: object

As @AndyHayden noted in the comments below, take care if your substrings have special characters such as $ and ^ which you want to match literally. These characters have specific meanings in the context of regular expressions and will affect the matching.

You can make your list of substrings safer by escaping non-alphanumeric characters with re.escape:

>>> import re
>>> matches = ['$money', 'x^y']
>>> safe_matches = [re.escape(m) for m in matches]
>>> safe_matches
['\\$money', 'x\\^y']

The strings with in this new list will match each character literally when used with str.contains.

Basic implementation

Generally, you use split() to split a string of words into a list of them. If the list has more than one element, it's True (i.e. you could print yes)

def contains_multiple_words(s):
  return len(s.split()) > 1

Punctuation support

To support punctuation etc as well, you can split on a regular expression, via the re module's split command:

import re

def contains_multiple_words(s):
  return len(re.compile('\W').split(s)) > 1

The regular expression character class \W means any single non-word character, e.g. punctuation or spaces (see the Python regex syntax guide for details).

Thus, splitting on this instead of just space (the default in the first example) allows for a more realistic idea of "words".