没有矢量方法，使用两列Mapin。需要在此循环：

mask = [a in b for a,b in zip(df_1['A'], df_1['B'])]

df_1.loc[mask]

输出：

A      B
0  a  a x d
2  c  q m c

速度比较（3000行）

# operator.contains
518 µs ± 4.61 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# list comprehension
554 µs ± 3.84 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# numpy.apply_along_axis
7.32 ms ± 58.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

# apply
20.7 ms ± 379 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

可爱!

from operator import contains

df_1.loc[map(contains, *map(df_1.get, ['B', 'A']))]

   A      B
0  a  a x d
2  c  q m c

没有进口，但有一个丑陋的邓德.../-：

df_1.loc[map(str.__contains__, *map(df_1.get, ['B', 'A']))]

另外，对于OP ...不要接受这个答案。我只是在打高尔夫球。你不应该在产品代码中使用这个，因为它是不透明的，由于使用2个Map和一个飞溅。
我先说清楚...
mozway's is the better one

您可以尝试：

out = df_1.loc[df_1.apply(lambda x: x['A'] in x['B'], axis=1)]
print(out)

# Output
   A      B
0  a  a x d
2  c  q m c

numpy的替代方案：

df_1.loc[np.apply_along_axis(lambda x: x[0] in x[1], axis=1, arr=df_1)]

当访问panda中的两个不同列时，可以使用.apply（）

df.apply(lambda row: row['A'] in row['B'], axis = 1)

这将创建一个布尔级数，可用于只选择'A'在'B'中的列的loc条件：

df.loc[df.apply(lambda row: row['A'] in row['B'], axis = 1)]

df_1[df_1.apply(lambda x:x['A'] in x['B'],axis=1)]

import pandas as pd 

df_1 = pd.DataFrame(data={
    "A":['a','b','c'],
    "B":['a x d','z y w','q m c'] #string values not a list
})

m = df_1['B'].str.contains('|'.join(df_1['A']), case=True, regex=True)
print(df_1.loc[m])

#    A      B
# 0  a  a x d
# 2  c  q m c