更新：2020

Question

如何将数据从Scikit-learn Bunch对象转换为Pandas DataFrame？

from sklearn.datasets import load_iris
import pandas as pd
data = load_iris()
print(type(data))
data1 = pd. # Is there a Pandas method to accomplish this?

Answer 1

手动，您可以使用pd.DataFrame构造函数，给出一个numpy数组（data）和列的名称列表（columns）。要将所有内容都放在一个DataFrame中，您可以将功能和目标连接成一个带有np.c_[...]的numpy数组（注意[]）：

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

# save load_iris() sklearn dataset to iris
# if you'd like to check dataset type use: type(load_iris())
# if you'd like to view list of attributes use: dir(load_iris())
iris = load_iris()

# np.c_ is the numpy concatenate function
# which is used to concat iris['data'] and iris['target'] arrays 
# for pandas column argument: concat iris['feature_names'] list
# and string list (in this case one string); you can make this anything you'd like..  
# the original dataset would probably call this ['Species']
data1 = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                     columns= iris['feature_names'] + ['target'])

Answer 2

from sklearn.datasets import load_iris
import pandas as pd

data = load_iris()
df = pd.DataFrame(data.data, columns=data.feature_names)
df.head()

本教程可能很有意思：http://www.neural.cz/dataset-exploration-boston-house-pricing.html

Answer 3

TOMDLt的解决方案对于scikit-learn中的所有数据集都不够通用。例如，它不适用于波士顿住房数据集。我提出了一个更普遍的不同解决方案。也不需要使用numpy。

a: function(a) {
    a = a.attributes;
    a.href && a.href.match(/^file:\/\/\/[\S]+#/i) && (a.href = a.href.replace(/^file:\/\/\/[^#]+/i, ""))
}

作为一般功能：

from sklearn import datasets
import pandas as pd

boston_data = datasets.load_boston()
df_boston = pd.DataFrame(boston_data.data,columns=boston_data.feature_names)
df_boston['target'] = pd.Series(boston_data.target)
df_boston.head()

Answer 4

否则请使用seaborn data sets，它们是实际的熊猫数据帧：

import seaborn
iris = seaborn.load_dataset("iris")
type(iris)
# <class 'pandas.core.frame.DataFrame'>

与scikit学习数据集比较：

from sklearn import datasets
iris = datasets.load_iris()
type(iris)
# <class 'sklearn.utils.Bunch'>
dir(iris)
# ['DESCR', 'data', 'feature_names', 'filename', 'target', 'target_names']

Answer 5

作为一种替代方案，我可以更容易地把头包裹起来：

data = load_iris()
df = pd.DataFrame(data['data'], columns=data['feature_names'])
df['target'] = data['target']
df.head()

基本上不是从get get连接，只需使用要素矩阵创建数据框，然后只需添加数据[＆＃39; whatvername＆＃39;]并从数据集中获取目标值< / p>

Answer 6

这适合我。

dataFrame = pd.dataFrame(data = np.c_[ [iris['data'],iris['target'] ],
columns=iris['feature_names'].tolist() + ['target'])

Answer 7

花了我2个小时来弄明白

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()
##iris.keys()


df= pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= iris['feature_names'] + ['target'])

df['species'] = pd.Categorical.from_codes(iris.target, iris.target_names)

为我的大熊猫取回物种

Answer 8

这对我来说很简单。

boston = load_boston()
boston_frame = pd.DataFrame(data=boston.data, columns=boston.feature_names)
boston_frame["target"] = boston.target

但这也可以应用于load_iris。

Answer 9

组合功能和目标变量的其他方法可以使用np.column_stack（details）

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

data = load_iris()
df = pd.DataFrame(np.column_stack((data.data, data.target)), columns = data.feature_names+['target'])
print(df.head())

结果：

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)     target
0                5.1               3.5                1.4               0.2     0.0
1                4.9               3.0                1.4               0.2     0.0 
2                4.7               3.2                1.3               0.2     0.0 
3                4.6               3.1                1.5               0.2     0.0
4                5.0               3.6                1.4               0.2     0.0

如果您需要target的字符串标签，则可以通过将replace转换为target_names并添加新列来使用dictionary：

df['label'] = df.target.replace(dict(enumerate(data.target_names)))
print(df.head())

结果：

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)     target  label 
0                5.1               3.5                1.4               0.2     0.0     setosa
1                4.9               3.0                1.4               0.2     0.0     setosa
2                4.7               3.2                1.3               0.2     0.0     setosa
3                4.6               3.1                1.5               0.2     0.0     setosa
4                5.0               3.6                1.4               0.2     0.0     setosa

Answer 10

从0.23版开始，您可以使用as_frame参数直接返回DataFrame。例如，加载虹膜数据集：

from sklearn.datasets import load_iris
iris = load_iris(as_frame=True)
df = iris.data

据我了解，使用provisionally release notes，这适用于乳腺癌，糖尿病，手指，虹膜，linnerud，葡萄酒和california_houses数据集。

Answer 11

更新：2020

您可以使用参数as_frame=True来获取熊猫数据框。

如果as_frame参数可用（例如load_iris）

from sklearn import datasets
X,y = datasets.load_iris(return_X_y=True) # numpy arrays

dic_data = datasets.load_iris(as_frame=True)
print(dic_data.keys())

df = dic_data['frame'] # pandas dataframe data + target
df_X = dic_data['data'] # pandas dataframe data only
ser_y = dic_data['target'] # pandas series target only
dic_data['target_names'] # numpy array

如果as_frame参数不可用（例如load_boston）

from sklearn import datasets

fnames = [ i for i in dir(datasets) if 'load_' in i]
print(fnames)

fname = 'load_boston'
loader = getattr(datasets,fname)()
df = pd.DataFrame(loader['data'],columns= loader['feature_names'])
df['target'] = loader['target']
df.head(2)

Answer 12

这是另一个集成方法示例，可能会有所帮助。

from sklearn.datasets import load_iris
iris_X, iris_y = load_iris(return_X_y=True, as_frame=True)
type(iris_X), type(iris_y)

数据iris_X导入为pandas DataFrame和目标iris_y被导入为熊猫系列。

Answer 13

解决最佳答案并解决我的评论，这是转换功能

def bunch_to_dataframe(bunch):
  fnames = bunch.feature_names
  features = fnames.tolist() if isinstance(fnames, np.ndarray) else fnames
  features += ['target']
  return pd.DataFrame(data= np.c_[bunch['data'], bunch['target']],
                 columns=features)

Answer 14

from sklearn.datasets import load_iris
import pandas as pd

iris_dataset = load_iris()

datasets = pd.DataFrame(iris_dataset['data'], columns = 
           iris_dataset['feature_names'])
target_val = pd.Series(iris_dataset['target'], name = 
            'target_values')

species = []
for val in target_val:
    if val == 0:
        species.append('iris-setosa')
    if val == 1:
        species.append('iris-versicolor')
    if val == 2:
        species.append('iris-virginica')
species = pd.Series(species)

datasets['target'] = target_val
datasets['target_name'] = species
datasets.head()

Answer 15

您可以使用pd.DataFrame构造函数，提供一个numpy数组（数据）和列名称列表（列）。要将所有内容都放在一个DataFrame中，可以使用np.c _ [...]将要素和目标连接到一个numpy数组中（请注意方括号而不是括号）。另外，如果在串联之前不将功能名称（iris ['feature_names']）转换为列表，则会遇到一些麻烦：

import numpy as np
import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()

df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                     columns= list(iris['feature_names']) + ['target'])

Answer 16

最好的方法之一：

data = pd.DataFrame(digits.data)

数字是sklearn数据框，我将其转换为熊猫数据框

Answer 17

对这个问题有很多很好的回答；我在下面添加了我自己的。

import pandas as pd
from sklearn.datasets import load_iris

df = pd.DataFrame(
    # load all 4 dimensions of the dataframe EXCLUDING species data
    load_iris()['data'],
    # set the column names for the 4 dimensions of data
    columns=load_iris()['feature_names']
)

# we create a new column called 'species' with 150 rows of numerical data 0-2 signifying a species type. 
# Our column `species` should have data such `[0, 0, 1, 2, 1, 0]` etc.
df['species'] = load_iris()['target']
# we map the numerical data to string data for species type
df['species'] = df['species'].map({
    0 : 'setosa',
    1 : 'versicolor',
    2 : 'virginica'   
})

df.head()

sepal-df-head

故障

出于某种原因，load_iris['feature_names] 只有 4 列（萼片长度、萼片宽度、花瓣长度、花瓣宽度）；此外，load_iris['data'] 仅包含上述 feature_names 的数据。
相反，物种列名称存储在 load_iris()['target_names'] == array(['setosa', 'versicolor', 'virginica'] 中。
除此之外，物种行数据存储在load_iris()['target'].nunique() == 3
我们的目标只是添加一个名为 species 的新列，该列使用 map 函数将数值数据 0-2 转换为表示虹膜种类的 3 种类型的字符串数据。

Answer 18

API比建议的响应要干净一些。在这里，使用as_frame并确保还包括一个响应列。

import pandas as pd
from sklearn.datasets import load_wine

features, target = load_wine(as_frame=True).data, load_wine(as_frame=True).target
df = features
df['target'] = target

df.head(2)

Answer 19

我从您的答案中汲取了一些想法，但我不知道该如何缩短：）

import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris['feature_names'])
df['target'] = iris['target']

这将提供一个带有feature_names和target作为列以及RangeIndex（start = 0，stop = len（df），step = 1）的Pandas DataFrame。我想有一个较短的代码，可以直接添加“目标”。

Answer 20

基本上，您需要的是“数据”，并且已将其存储在scikit中，现在只需要其中的“目标”（预测）即可。

因此只需合并这两个即可使数据完整

  data_df = pd.DataFrame(cancer.data,columns=cancer.feature_names)
  target_df = pd.DataFrame(cancer.target,columns=['target'])

  final_df = data_df.join(target_df)

Answer 21

import pandas as pd
from sklearn.datasets import load_iris
iris = load_iris()
X = iris['data']
y = iris['target']
iris_df = pd.DataFrame(X, columns = iris['feature_names'])
iris_df.head()

Answer 22

无论TomDLT回答了什么，它可能对某些人都不起作用，因为

angular.json

因为iris ['feature_names']返回一个numpy数组。在numpy数组中，仅通过+运算符不能添加数组和列表['target']。因此，您需要先将其转换为列表，然后添加。

您可以

data1 = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                 columns= iris['feature_names'] + ['target'])

这可以正常工作。

Answer 23

此摘要仅基于syntactic sugar所做的贡献和解释而构建。唯一的不同是load_iris将返回一个元组而不是一个字典，并且列名被枚举。

df = pd.DataFrame(np.c_[load_iris(return_X_y=True)])

Answer 24

可能有更好的方法，但这是我过去所做的，而且效果很好：

items = data.items()                          #Gets all the data from this Bunch - a huge list
mydata = pd.DataFrame(items[1][1])            #Gets the Attributes
mydata[len(mydata.columns)] = items[2][1]     #Adds a column for the Target Variable
mydata.columns = items[-1][1] + [items[2][0]] #Gets the column names and updates the dataframe

现在mydata将拥有您需要的一切 - 属性，目标变量和列名

如何将Scikit-learn数据集转换为Pandas数据集？

24 个答案:

更新：2020

如果as_frame参数可用（例如load_iris）

如果as_frame参数不可用（例如load_boston）

故障