You can use the str.startswith DataFrame method to give more consistent results:

In [11]: s = pd.Series(['a', 'ab', 'c', 11, np.nan])

In [12]: s
Out[12]:
0      a
1     ab
2      c
3     11
4    NaN
dtype: object

In [13]: s.str.startswith('a', na=False)
Out[13]:
0     True
1     True
2    False
3    False
4    False
dtype: bool

and the boolean indexing will work just fine (I prefer to use loc, but it works just the same without):

In [14]: s.loc[s.str.startswith('a', na=False)]
Out[14]:
0     a
1    ab
dtype: object

.

It looks least one of your elements in the Series/column is a float, which doesn't have a startswith method hence the AttributeError, the list comprehension should raise the same error...

For row wise comparison, we can use DataFrame.apply:

m = df.apply(lambda x: x['A'].startswith(x['B']), axis=1)
df[m]

       A    B
0  apple  app
2     aa   aa

The reason your code is not working is because Series.str.startswith accepts a character sequence (a string scalar), and you are using a pandas Series. Quoting the docs:

pat : str
Character sequence. Regular expressions are not accepted.

I would use something like df[~df.B.str.startswith('336')], using the str accessor. For instance,

>>> df = pd.DataFrame({'B': ['3360', '3365', 'yes', 'maybe', 'no']})
>>> df[~df.B.str.startswith('336')]
       B
2    yes
3  maybe
4     no

And if you have multiple strings to check, startswith accepts a tuple of prefixes.

>>> df[~df.B.str.startswith(('112', '336', 'n'))]
       B
2    yes
3  maybe

I suggest create each boolean mask separately for better readable code and then chain them by &:

prefixes = ['E','L','N']

m1 = ~dfTest_Data['trading_book'].str.startswith(tuple(prefixes))
m2 = dfTest_Data['state'].str.contains('Traded')

cols = ['originating_system_id','rbc_security_type1','state','trading_book']
df_Traded_Away_User = dfTest_Data.loc[m1 & m2, cols]
print (df_Traded_Away_User)
  originating_system_id rbc_security_type1        state trading_book
3                  RBCL               CORP  Traded Away      PDFEFGR

Just for a and c

df = df[df["col1"].str.match('^[ac]')]

You can include as many letters in the square brackets that you need to match on.

df = df[df["col1"].str.match('^[abcdefg]')]

Try this: df[df.Device.str.startswith('ABC')]

With pandas, you can use series.str to utilize several useful functions for string manipulation.

Series.str.startswith, the one I showed above, is to select (return bool values) indices that starts with a specific pattern.

BTW, the answer using contains with ^ is basically the same thing but, instead of using a function provided by pandas, it uses regex to define the pattern on what should be the first character of your input string.

You can using startswith , the ~ in the front will convert from in to not in

prefixes = ['IM','JE','GE','GV','CHE','MCO']

df[~df.Name.str.startswith(tuple(prefixes))]
Out[424]: 
        Name  Remains
1  RT6000996     True
2  RT6000994     True
3  RT6000467     True
4  RT6000431     True

You can use a Boolean mask to select the rows you require:

m1 = df['state'].diff() == 1
m2 = df['state'].shift(-1).diff() == -1

res  = df[m1 | m2]

print(res)

    id  state  type
2   a1      1  high
5   a1      1  high
8   a2      1  high
10  a2      1   low

You can use a list comprehension to split into 2 dataframes:

df1, df2 = [res.iloc[i::2] for i in range(int(len(res.index)/2))]

print(df1, df2, sep='\n\n')

   id  state  type
2  a1      1  high
8  a2      1  high

    id  state  type
5   a1      1  high
10  a2      1   low

Just perform a list comprehension to create your columns:

In [28]:

filter_col = [col for col in df if col.startswith('foo')]
filter_col
Out[28]:
['foo.aa', 'foo.bars', 'foo.fighters', 'foo.fox', 'foo.manchu']
In [29]:

df[filter_col]
Out[29]:
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
3     4.7         0             0        0          0
4     5.6         0             0        0          0
5     6.8         1             0        5          0

Another method is to create a series from the columns and use the vectorised str method startswith:

In [33]:

df[df.columns[pd.Series(df.columns).str.startswith('foo')]]
Out[33]:
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
3     4.7         0             0        0          0
4     5.6         0             0        0          0
5     6.8         1             0        5          0

In order to achieve what you want you need to add the following to filter the values that don't meet your ==1 criteria:

In [36]:

df[df[df.columns[pd.Series(df.columns).str.startswith('foo')]]==1]
Out[36]:
   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      NaN       1       NaN           NaN      NaN        NaN     NaN
1      NaN     NaN       NaN             1      NaN        NaN     NaN
2      NaN     NaN       NaN           NaN        1        NaN     NaN
3      NaN     NaN       NaN           NaN      NaN        NaN     NaN
4      NaN     NaN       NaN           NaN      NaN        NaN     NaN
5      NaN     NaN         1           NaN      NaN        NaN     NaN

EDIT

OK after seeing what you want the convoluted answer is this:

In [72]:

df.loc[df[df[df.columns[pd.Series(df.columns).str.startswith('foo')]] == 1].dropna(how='all', axis=0).index]
Out[72]:
   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      5.0     1.0         0             0        2         NA      NA
1      5.0     2.1         0             1        4          0       0
2      6.0     NaN         0           NaN        1          0       1
5      6.8     6.8         1             0        5          0       0