可以手动使用 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'])

也许还有更好的办法，但以下是我过去所做的，而且效果相当不错:

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 将拥有您需要的一切——属性、目标变量和列名

from sklearn.datasets import load_iris
import pandas as pd


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

这个教程可能有点意思: http://www.neural.cz/dataset-exploration-boston-house-pricing.html

工作的最佳答案和解决我的意见，这里是一个功能的转换

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)

这对我有用。

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

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

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()

作为一般功能:

def sklearn_to_df(sklearn_dataset):
df = pd.DataFrame(sklearn_dataset.data, columns=sklearn_dataset.feature_names)
df['target'] = pd.Series(sklearn_dataset.target)
return df


df_boston = sklearn_to_df(datasets.load_boston())

作为一种替代方案，我可以更容易地理解:

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

基本上不需要从一开始就连接，只需要用特性矩阵创建一个数据框架，然后只需要添加目标列和数据[‘ whatvername’] ，并从数据集中获取目标值

我花了两个小时才想明白

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)

为我的熊猫找回物种

其他结合特性和目标变量的方法可以使用 np.column_stack(详情)

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的字符串标签，那么您可以通过将 target_names转换为 dictionary并添加一个新列来使用 replace:

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

这个片段只是构建在 TomDLT 和 rolyat已经提供和解释的基础上的 语法糖。唯一的区别是 load_iris将返回元组而不是字典，并且列名是枚举的。

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

不管 TomDLT 的回答是什么，可能对你们中的一些人不起作用，因为

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

因为 iris [‘ Feature _ Names’]返回一个 numpy 数组。在 numpy 数组中，不能仅通过 + 运算符添加数组和 list [‘ target’]。因此，您需要首先将它转换为一个列表，然后再添加。

你可以的

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

这将工作的罚款，虽然. 。

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()

最好的方法之一:

data = pd.DataFrame(digits.data)

Digits 是 sklearn 数据框架，我把它转换成了熊猫数据框架

基本上，您需要的是“数据”，并且它在 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)

我从你的回答中得到了一些想法，但我不知道如何使它更简短:)

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']

这样就得到了一个熊猫数据框架(Panda DataFrame) ，它具有 Feature _ name 加上 target 作为列和 RangeIndex (start = 0，stop = len (df) ，step = 1)。 我想有一个较短的代码，我可以有’目标’直接添加。

否则使用 海运数据集，这是实际的熊猫数据帧:

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']

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

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

根据我对 临时释放通知书的理解，这适用于乳腺癌、糖尿病、手指、虹膜、红酒和加利福尼亚的数据集。

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)

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

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 作为熊猫 DataFrame 和 目标 iris _ y 作为熊猫系列导入。

最新消息

可以使用参数 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)

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()

这个方法对我来说很简单。

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

但是这也可以应用于 load _ iris。

你可以用警察局。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'])

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

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()

故障

• 由于某些原因，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种类型的字符串数据。

许多解决方案要么缺少列名，要么缺少物种目标名。

@ Ankit-mathanker 的解决方案可以工作，但是它会迭代 Dataframe Series‘ target _ Names’以替换整数标识符的虹膜种类。

根据格言“ 如果没有必要，不要迭代数据框架”，下面的解决方案使用 pd.place ()更简洁地完成替换。

import pandas as pd
from sklearn.datasets import load_iris


iris = load_iris()
df = pd.DataFrame(iris['data'], columns = iris['feature_names'])
df['target'] = pd.Series(iris['target'], name = 'target_values')
df['target_name'] = df['target'].replace([0,1,2],
['iris-' + species for species in iris['target_names'].tolist()])


df.head(3)

这是一个简单的方法，并与大多数数据集在 sklearn 工作

import pandas as pd
from sklearn import datasets


# download iris data set
iris = datasets.load_iris()


# load feature columns to DataFrame
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


# add a column to df called 'target_c' then asign the target data of iris data
df['target_c'] = iris.target


# view final DataFrame
df.head()

我尝试了一种更简单、更平易近人的方式

import pandas as pd
from sklearn import datasets


iris = load_iris()


X= pd.DataFrame(iris['data'], columns= iris['feature_names'])
y = pd.DataFrame(iris['target'],columns=['target'])
df = X.join(y)