Question

我有一个数据框，需要根据列名称的后缀_x或_y进行拆分。后缀为_x的列名称应构成一个数据框，后缀为_y的列名称应构成另一数据框。任何帮助，将不胜感激。谢谢！

例如：

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randint(0,10,size=(10, 4)), columns=list('ABCD'))
df.rename(columns={'A':'A_x', 'B':'B_y','C':'C_x', 'D':'D_y'}, inplace=True)

df
   A_x  B_y  C_x  D_y
0    8    8    0    8
1    3    2    9    8
2    2    6    7    9
3    4    1    7    7
4    9    6    3    2
5    3    3    0    3
6    9    5    6    8
7    3    7    9    0
8    4    2    6    4
9    8    5    8    2

想要的输出：

df1

   A_x  C_x
0    8    0
1    3    9
2    2    7
3    4    7
4    9    3
5    3    0
6    9    6
7    3    9
8    4    6
9    8    8

df2

 B_y  D_y
0    8    8
1    2    8
2    6    9
3    1    7
4    6    2
5    3    3
6    5    8
7    7    0
8    2    4
9    5    2

Answer 1

最简单，最容易与正则表达式df.filter一起使用：

您可以参考Documentation here

实际数据框架：

>>> df
   A_x  B_y  C_x  D_y
0    8    9    5    1
1    3    4    0    6
2    9    7    0    4
3    6    7    5    9
4    4    3    7    5
5    6    1    6    9
6    5    4    5    4
7    8    3    0    1
8    7    4    4    4
9    9    2    4    4

应用dataFrame.filter：

>>> df1 = df.filter(regex='_x')
>>> df2 = df.filter(regex='_y')

您拆分后的新数据框df1

>>> df1
   A_x  C_x
0    8    5
1    3    0
2    9    0
3    6    5
4    4    7
5    6    6
6    5    5
7    8    0
8    7    4
9    9    4

您拆分后的新数据框df2

>>> df2
   B_y  D_y
0    9    1
1    4    6
2    7    4
3    7    9
4    3    5
5    1    9
6    4    4
7    3    1
8    4    4
9    2    4

或：DataFrame.filter与regex一起在引擎盖下使用re.search。

>>> df1 = df.filter(regex='x$', axis=1)
>>> df2 = df.filter(regex='y$', axis=1)

或：DataFrame.filter与参数like

df1, df2 = df.filter(like='_x'), df.filter(like='_y')

或：使用dataFrame.loc + contains

df1 = df.loc[:, df.columns.str.contains('_x')]
df2 = df.loc[:, df.columns.str.contains('_x')]

或：将dataFrame.loc + map与lambda和endswith一起使用

df1 = df.loc[:,df.columns.map(lambda x: x.endswith('_x'))]
df2 = df.loc[:,df.columns.map(lambda x: x.endswith('_y'))]

Answer 2

只需将split与列一起使用，我们将groupby保存到dict中。请注意，此方法易于应用更多情况，例如：您有1000多个具有不同后缀的列，例如_x _y _z _c _a .....

d={x:y for x, y in df.groupby(df.columns.str.split('_').str[1],axis=1)}
d['x']
   A_x  C_x
0    8    0
1    3    9
2    2    7
3    4    7
4    9    3
5    3    0
6    9    6
7    3    9
8    4    6
9    8    8

Answer 3

好吧，只需：

def bfs_modified(G,src,des):
    intialize d(src)=0, and d(!src) = inf
    visited[all_vertex]=False
    q=queue(src)

    while q is not empty: 
        u=q.pop()
        if(not visited[u]):
            visited[u]=True
            for all v connected to u:
                  q.insert(v)
                  if(d[v]>d[u]+adj[u][v]):
                      d[v]=d[u]+adj[u][v]
    return d[des]

那么现在df1=df[['A_x','C_x']] df2=df[['B_y','D_y']]和df1是预期的数据帧。

更多不确定的内容：

df2

Answer 4

使用endswith作为列名如何？

df1 = df[[c for c in df.columns if c.endswith('_x')]]
df2 = df[[c for c in df.columns if c.endswith('_y')]]

Answer 5

方法1：由于python中的索引从0开始，因此您可以使用

df1 = df.iloc[:, [0,2]]
df2 = df.iloc[:, [1,3]]

方法2：由于列名是已知的，因此您也可以使用

df1=df[['A_x','C_x']]
df2=df[['B_y','D_y']]

这两种方法都会给出相同的答案

分割具有特定后缀的数据帧

5 个答案: