代码之家  ›  专栏  ›  技术社区  ›  Ari

在pandas中选择列(如果它们的名称存在于列表中)[重复]

  •  0
  • Ari  · 技术社区  · 6 年前

    在我的一个脚本中,我根据列名列表来选择数据框的几列。以下代码有效:

    data = df[lst]
    

    只要列表中的所有元素都包含在数据帧中,它就可以正常工作。如果不是这样,它将返回错误“…”不在索引中。

    是否有可能仍然选择列表中包含列名的所有列,即使列表中的所有元素都不包含在数据帧中?

    0 回复  |  直到 6 年前
        1
  •  24
  •   jezrael    9 年前

    我想你需要 Index.intersection :

    df = pd.DataFrame({'A':[1,2,3],
                       'B':[4,5,6],
                       'C':[7,8,9],
                       'D':[1,3,5],
                       'E':[5,3,6],
                       'F':[7,4,3]})
    
    print (df)
       A  B  C  D  E  F
    0  1  4  7  1  5  7
    1  2  5  8  3  3  4
    2  3  6  9  5  6  3
    
    lst = ['A','R','B']
    
    print (df.columns.intersection(lst))
    Index(['A', 'B'], dtype='object')
    
    data = df[df.columns.intersection(lst)]
    print (data)
       A  B
    0  1  4
    1  2  5
    2  3  6
    

    另一个解决方案 numpy.intersect1d :

    data = df[np.intersect1d(df.columns, lst)]
    print (data)
       A  B
    0  1  4
    1  2  5
    2  3  6
    
        2
  •  3
  •   Zero    8 年前

    很少有其他方法,而且列表理解速度要快得多

    In [1357]: df[df.columns & lst]
    Out[1357]:
       A  B
    0  1  4
    1  2  5
    2  3  6
    
    In [1358]: df[[c for c in df.columns if c in lst]]
    Out[1358]:
       A  B
    0  1  4
    1  2  5
    2  3  6
    

    计时

    In [1360]: %timeit [c for c in df.columns if c in lst]
    100000 loops, best of 3: 2.54 µs per loop
    
    In [1359]: %timeit df.columns & lst
    1000 loops, best of 3: 231 µs per loop
    
    In [1362]: %timeit df.columns.intersection(lst)
    1000 loops, best of 3: 236 µs per loop
    
    In [1363]: %timeit np.intersect1d(df.columns, lst)
    10000 loops, best of 3: 26.6 µs per loop
    

    细节

    In [1365]: df
    Out[1365]:
       A  B  C  D  E  F
    0  1  4  7  1  5  7
    1  2  5  8  3  3  4
    2  3  6  9  5  6  3
    
    In [1366]: lst
    Out[1366]: ['A', 'R', 'B']
    
        3
  •  0
  •   Avinash    7 年前

    使用 * 带列表

    data = df[[*lst]]

    它将产生预期的结果。