115

我有一个非常大的数据框(大约 100 万行),其中包含来自实验的数据(60 名受访者)。

我想将数据框拆分为 60 个数据框(每个参与者一个数据框)。

在数据框中,data有一个名为 的变量'name',它是每个参与者的唯一代码。

我尝试了以下方法,但没有任何反应(或执行不会在一小时内停止)。我打算做的是将它们拆分data成更小的数据框,并将它们附加到列表(datalist)中:

import pandas as pd

def splitframe(data, name='name'):
    
    n = data[name][0]

    df = pd.DataFrame(columns=data.columns)

    datalist = []

    for i in range(len(data)):
        if data[name][i] == n:
            df = df.append(data.iloc[i])
        else:
            datalist.append(df)
            df = pd.DataFrame(columns=data.columns)
            n = data[name][i]
            df = df.append(data.iloc[i])
        
    return datalist

我没有收到错误消息,脚本似乎永远运行!

有没有聪明的方法来做到这一点?

4

12 回答 12

89

我可以问为什么不通过切片数据框来做到这一点。就像是

#create some data with Names column
data = pd.DataFrame({'Names': ['Joe', 'John', 'Jasper', 'Jez'] *4, 'Ob1' : np.random.rand(16), 'Ob2' : np.random.rand(16)})

#create unique list of names
UniqueNames = data.Names.unique()

#create a data frame dictionary to store your data frames
DataFrameDict = {elem : pd.DataFrame for elem in UniqueNames}

for key in DataFrameDict.keys():
    DataFrameDict[key] = data[:][data.Names == key]

嘿,你有一个数据框字典,就像(我认为)你想要的那样。需要访问一个?只需输入

DataFrameDict['Joe']

希望有帮助

于 2013-11-05T14:28:44.703 回答
67

首先,您的方法效率低下,因为逐行附加到列表会很慢,因为当新条目的空间不足时,它必须定期增长列表,列表理解在这方面更好,因为大小已确定前面并分配一次。

但是,我认为从根本上讲,您的方法有点浪费,因为您已经有了一个数据框,那么为什么要为每个用户创建一个新的呢?

我会按列对数据框进行排序'name',将索引设置为此,如果需要,不要删除该列。

然后生成所有唯一条目的列表,然后您可以使用这些条目执行查找,关键是如果您只查询数据,请使用选择标准返回数据帧上的视图,而不会产生昂贵的数据副本。

使用pandas.DataFrame.sort_valuespandas.DataFrame.set_index

# sort the dataframe
df.sort_values(by='name', axis=1, inplace=True)

# set the index to be this and don't drop
df.set_index(keys=['name'], drop=False,inplace=True)

# get a list of names
names=df['name'].unique().tolist()

# now we can perform a lookup on a 'view' of the dataframe
joe = df.loc[df.name=='joe']

# now you can query all 'joes'
于 2013-11-06T10:29:02.150 回答
50

您可以将groupby对象转换为tuples,然后转换为dict

df = pd.DataFrame({'Name':list('aabbef'),
                   'A':[4,5,4,5,5,4],
                   'B':[7,8,9,4,2,3],
                   'C':[1,3,5,7,1,0]}, columns = ['Name','A','B','C'])

print (df)
  Name  A  B  C
0    a  4  7  1
1    a  5  8  3
2    b  4  9  5
3    b  5  4  7
4    e  5  2  1
5    f  4  3  0

d = dict(tuple(df.groupby('Name')))
print (d)
{'b':   Name  A  B  C
2    b  4  9  5
3    b  5  4  7, 'e':   Name  A  B  C
4    e  5  2  1, 'a':   Name  A  B  C
0    a  4  7  1
1    a  5  8  3, 'f':   Name  A  B  C
5    f  4  3  0}

print (d['a'])
  Name  A  B  C
0    a  4  7  1
1    a  5  8  3

推荐,但可以按组创建 DataFrame:

for i, g in df.groupby('Name'):
    globals()['df_' + str(i)] =  g

print (df_a)
  Name  A  B  C
0    a  4  7  1
1    a  5  8  3
于 2017-07-30T13:18:37.803 回答
34

简单的:

[v for k, v in df.groupby('name')]
于 2018-07-18T15:37:00.820 回答
18

Groupby 可以帮助您:

grouped = data.groupby(['name'])

然后,您可以与每个组一起工作,就像为每个参与者使用数据框一样。而DataFrameGroupBy对象方法如(apply, transform, aggregate, head, first, last)返回一个DataFrame对象。

或者您可以列出grouped并按索引获取所有 DataFrame:

l_grouped = list(grouped)

l_grouped[0][1]- 具有名字的第一组的 DataFrame。

于 2016-12-13T21:26:18.680 回答
11

除了 Gusev Slava 的回答,您可能还想使用 groupby 的组:

{key: df.loc[value] for key, value in df.groupby("name").groups.items()}

这将产生一个字典,其中包含您分组的键,指向相应的分区。优点是键被维护并且不会在列表索引中消失。

于 2017-05-16T09:52:02.913 回答
3
In [28]: df = DataFrame(np.random.randn(1000000,10))

In [29]: df
Out[29]: 
<class 'pandas.core.frame.DataFrame'>
Int64Index: 1000000 entries, 0 to 999999
Data columns (total 10 columns):
0    1000000  non-null values
1    1000000  non-null values
2    1000000  non-null values
3    1000000  non-null values
4    1000000  non-null values
5    1000000  non-null values
6    1000000  non-null values
7    1000000  non-null values
8    1000000  non-null values
9    1000000  non-null values
dtypes: float64(10)

In [30]: frames = [ df.iloc[i*60:min((i+1)*60,len(df))] for i in xrange(int(len(df)/60.) + 1) ]

In [31]: %timeit [ df.iloc[i*60:min((i+1)*60,len(df))] for i in xrange(int(len(df)/60.) + 1) ]
1 loops, best of 3: 849 ms per loop

In [32]: len(frames)
Out[32]: 16667

这是一种分组方式(您可以进行任意应用而不是求和)

In [9]: g = df.groupby(lambda x: x/60)

In [8]: g.sum()    

Out[8]: 
<class 'pandas.core.frame.DataFrame'>
Int64Index: 16667 entries, 0 to 16666
Data columns (total 10 columns):
0    16667  non-null values
1    16667  non-null values
2    16667  non-null values
3    16667  non-null values
4    16667  non-null values
5    16667  non-null values
6    16667  non-null values
7    16667  non-null values
8    16667  non-null values
9    16667  non-null values
dtypes: float64(10)

总和被cythonized,这就是为什么它如此之快

In [10]: %timeit g.sum()
10 loops, best of 3: 27.5 ms per loop

In [11]: %timeit df.groupby(lambda x: x/60)
1 loops, best of 3: 231 ms per loop
于 2013-11-05T14:26:01.600 回答
3
  • OP 中的方法有效,但效率不高。它可能似乎永远运行,因为数据集很长。
  • .groupby在列上使用,并使用唯一值作为键'method'创建 a dict,并使用. DataFrames'method'dict-comprehension
    • .groupby返回一个groupby对象,其中包含有关组的信息,其中g'method'每个组的唯一值,并且d是该DataFrame组的。
  • 每个in 的value,将是一个, 可以以标准方式访问 , 。keydf_dictDataFramedf_dict['key']
  • 原来的问题想要 a listof DataFrames,可以用 alist-comprehension
    • df_list = [d for _, d in df.groupby('method')]
import pandas as pd
import seaborn as sns  # for test dataset

# load data for example
df = sns.load_dataset('planets')

# display(df.head())
            method  number  orbital_period   mass  distance  year
0  Radial Velocity       1         269.300   7.10     77.40  2006
1  Radial Velocity       1         874.774   2.21     56.95  2008
2  Radial Velocity       1         763.000   2.60     19.84  2011
3  Radial Velocity       1         326.030  19.40    110.62  2007
4  Radial Velocity       1         516.220  10.50    119.47  2009


# Using a dict-comprehension, the unique 'method' value will be the key
df_dict = {g: d for g, d in df.groupby('method')}

print(df_dict.keys())
[out]:
dict_keys(['Astrometry', 'Eclipse Timing Variations', 'Imaging', 'Microlensing', 'Orbital Brightness Modulation', 'Pulsar Timing', 'Pulsation Timing Variations', 'Radial Velocity', 'Transit', 'Transit Timing Variations'])

# or a specific name for the key, using enumerate (e.g. df1, df2, etc.)
df_dict = {f'df{i}': d for i, (g, d) in enumerate(df.groupby('method'))}

print(df_dict.keys())
[out]:
dict_keys(['df0', 'df1', 'df2', 'df3', 'df4', 'df5', 'df6', 'df7', 'df8', 'df9'])
  • df_dict['df1].head(3)或者df_dict['Astrometry'].head(3)
  • 这个组只有2个
         method  number  orbital_period  mass  distance  year
113  Astrometry       1          246.36   NaN     20.77  2013
537  Astrometry       1         1016.00   NaN     14.98  2010
  • df_dict['df2].head(3)或者df_dict['Eclipse Timing Variations'].head(3)
                       method  number  orbital_period  mass  distance  year
32  Eclipse Timing Variations       1         10220.0  6.05       NaN  2009
37  Eclipse Timing Variations       2          5767.0   NaN    130.72  2008
38  Eclipse Timing Variations       2          3321.0   NaN    130.72  2008
  • df_dict['df3].head(3)或者df_dict['Imaging'].head(3)
     method  number  orbital_period  mass  distance  year
29  Imaging       1             NaN   NaN     45.52  2005
30  Imaging       1             NaN   NaN    165.00  2007
31  Imaging       1             NaN   NaN    140.00  2004

或者

  • DataFrames这是使用熊猫创建单独的手动方法:布尔索引
  • 这类似于接受的答案,但.loc不是必需的。
  • 这是创建一对额外的可接受的方法DataFrames
  • 创建多个对象的 Pythonic 方法是将它们放在容器中(例如dictlistgenerator等),如上所示。
df1 = df[df.method == 'Astrometry']
df2 = df[df.method == 'Eclipse Timing Variations']
于 2020-09-10T14:31:24.067 回答
2

基于列表理解的方法groupby- 它将所有拆分数据帧存储在列表变量中,并且可以使用索引进行访问。

例子

ans = [pd.DataFrame(y) for x, y in DF.groupby('column_name', as_index=False)]

ans[0]
ans[0].column_name
于 2019-02-28T10:57:42.340 回答
0

如果您的数据已经有一些标签,则可以使用 groupby 命令。

 out_list = [group[1] for group in in_series.groupby(label_series.values)]

这是一个详细的示例:

假设我们想使用一些标签将一个 pd 系列划分为一个块列表 例如,in_series是:

2019-07-01 08:00:00   -0.10
2019-07-01 08:02:00    1.16
2019-07-01 08:04:00    0.69
2019-07-01 08:06:00   -0.81
2019-07-01 08:08:00   -0.64
Length: 5, dtype: float64

而其对应label_series的是:

2019-07-01 08:00:00   1
2019-07-01 08:02:00   1
2019-07-01 08:04:00   2
2019-07-01 08:06:00   2
2019-07-01 08:08:00   2
Length: 5, dtype: float64

out_list = [group[1] for group in in_series.groupby(label_series.values)]

out_list它返回list两个pd.Series

[2019-07-01 08:00:00   -0.10
2019-07-01 08:02:00   1.16
Length: 2, dtype: float64,
2019-07-01 08:04:00    0.69
2019-07-01 08:06:00   -0.81
2019-07-01 08:08:00   -0.64
Length: 3, dtype: float64]

请注意,您可以使用in_series自身的一些参数对系列进行分组,例如,in_series.index.day

于 2019-07-04T22:53:31.150 回答
0

这是一个可能对某些人有所帮助的小功能(效率可能并不完美,但紧凑+或多或少易于理解):

def get_splited_df_dict(df: 'pd.DataFrame', split_column: 'str'):
    """
    splits a pandas.DataFrame on split_column and returns it as a dict
    """

    df_dict = {value: df[df[split_column] == value].drop(split_column, axis=1) for value in df[split_column].unique()}

    return df_dict

它通过选择给定列中的每个唯一值并将所有这些条目放入单独的 DataFrame 中,将 DataFrame 转换为多个 DataFrame。这.drop(split_column, axis=1)仅用于删除用于拆分 DataFrame 的列。删除不是必需的,但可以帮助减少操作后的内存使用量。

结果get_splited_df_dict是 a dict,这意味着可以像这样访问每个 DataFrame:

splitted = get_splited_df_dict(some_df, some_column)
# accessing the DataFrame with 'some_column_value'
splitted[some_column_value]
于 2021-08-10T08:59:25.310 回答
-1

我有类似的问题。我有 10 家不同商店和 50 种不同商品的每日销售时间序列。我需要将原始数据帧拆分为 500 个数据帧(10 个存储*50 个存储)以将机器学习模型应用于每个数据帧,而我无法手动完成。

这是数据框的头部:

数据框的头部:df

我创建了两个列表;一个用于数据帧的名称,一个用于一对数组 [item_number, store_number]。

    list=[]
    for i in range(1,len(items)*len(stores)+1):
    global list
    list.append('df'+str(i))

    list_couple_s_i =[]
    for item in items:
          for store in stores:
                  global list_couple_s_i
                  list_couple_s_i.append([item,store])

一旦这两个列表准备就绪,您就可以循环它们以创建您想要的数据框:

         for name, it_st in zip(list,list_couple_s_i):
                   globals()[name] = df.where((df['item']==it_st[0]) & 
                                                (df['store']==(it_st[1])))
                   globals()[name].dropna(inplace=True)

通过这种方式,我创建了 500 个数据框。

希望这会有所帮助!

于 2018-08-23T17:31:40.033 回答