Python 将数据帧拆分为10个相等的部分，并在循环中每次选取一个后合并9个部分

我需要将dataframe拆分为10个部分，然后使用一个部分作为测试集，剩下的9个部分（合并后用作训练集），我已经找到了下面的代码，在这里我可以拆分数据集，并且我尝试在选择这10个部分中的一个之后合并剩下的集。 第一次迭代进行得很顺利，但我在第二次迭代中遇到了以下错误

df = pd.DataFrame(np.random.randn(10, 4), index=list(xrange(10)))

for x in range(3):
    dfList = np.array_split(df, 3)
    testdf = dfList[x]
    dfList.remove(dfList[x])
    print testdf
    traindf = pd.concat(dfList)
    print traindf
    print "================================================"

---

好的，我是这样工作的：

df = pd.DataFrame(np.random.randn(10, 4), index=list(xrange(10)))

dfList = np.array_split(df, 3)
for x in range(3):
    trainList = []
    for y in range(3):
        if y == x :
            testdf = dfList[y]
        else:
            trainList.append(dfList[y])
    traindf = pd.concat(trainList)
    print testdf
    print traindf
    print "================================================"

但更好的方法是值得欢迎的

---

我认为您不必将数据帧拆分为10，只需将其拆分为2。 我使用此代码在训练集和验证集中拆分数据帧：

test_index=np.random.choice（df.index，int（len（df.index）/10），replace=False）

test_df=df.loc[test_索引]

---

train_df=df.loc[~df.index.isin（test_index）]

您可以从

numpy.random

import numpy as np
import pandas as pd
import math as mt
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
df = pd.DataFrame({'a': l, 'b': l})

洗牌数据帧索引

shuffled_idx = np.random.permutation(df.index)    

将乱序索引分成N个相等（ish）部分
对于本例，设N=4

N = 4
n = len(shuffled_idx) / N
parts = []
for j in range(N):
    parts.append(shuffled_idx[mt.ceil(j*n): mt.ceil(j*n+n)])

# to show each shuffled part of the data frame
for k in parts:
    print(df.iloc[k])

我写了一段脚本，用于随机拆分一个数据帧。这里是熊猫-合并、连接和连接功能

相同代码供您参考：

    import pandas as pd
    import numpy as np

    from xlwings import Sheet, Range, Workbook

    #path to file
    df = pd.read_excel(r"//PATH TO FILE//")

    df.columns = [c.replace(' ',"_") for c in df.columns]
    x = df.columns[0].encode("utf-8")

#number of parts the data frame or the list needs to be split into
    n = 7
    seq = list(df[x])
    np.random.shuffle(seq)
    lists1 = [seq[i:i+n] for i  in range(0, len(seq), n)]
    listsdf = pd.DataFrame(lists1).reset_index()

    dataframesDict = dict()

# calling xlwings workbook function 

    Workbook()

    for i in range(0,n):

      if Sheet.count() < n:

         Sheet.add()

         doubles[i] = 

           df.loc[df.Column_Name.isin(list(listsdf[listsdf.columns[i+1]]))]

         Range(i,"A1").value = doubles[i]

将熊猫作为pd导入
将numpy作为np导入
从xlwings导入工作表、范围、工作簿
#文件路径
df=pd.read_excel（r//文件路径/）
df.columns=[c.replace（“”，“\”）表示df.columns中的c]
x=df.columns[0]。编码（“utf-8”）
#数据框或列表需要拆分成的部分的数量
n=7
seq=列表（df[x]）
np.random.shuffle（序号）
列表1=[seq[i:i+n]表示范围内的i（0，len（seq），n）]
listsdf=pd.DataFrame（lists1）.reset_index（）
dataframesDict=dict（）
#调用xlwings工作簿函数
工作簿（）
对于范围（0，n）内的i：
如果Sheet.count（）

看起来你是在尝试打字，而不是一次性的。这段代码应该有帮助。您还可能会发现SKLearn k-fold功能在您的案例中有效，这也值得一看

# Split dataframe by rows into n roughly equal portions and return list of 
# them.
def splitDf(df, n) :
    splitPoints = list(map( lambda x: int(x*len(df)/n), (list(range(1,n)))))     
    splits = list(np.split(df.sample(frac=1), splitPoints))
    return splits

# Take splits from splitDf, and return into test set (splits[index]) and training set (the rest)
def makeTrainAndTest(splits, index) :
   # index is zero based, so range 0-9 for 10 fold split
   test = splits[index]

   leftLst = splits[:index]
   rightLst = splits[index+1:]

   train = pd.concat(leftLst+rightLst)

   return train, test

然后，您可以使用这些功能制作折叠

df = <my_total_data>
n = 10
splits = splitDf(df, n)
trainTest = []
for i in range(0,n) :
     trainTest.append(makeTrainAndTest(splits, i))

 # Get test set 2
 test2 = trainTest[2][1].shape

 # Get training set zero
 train0 = trainTest[0][0]

df=
n=10
splits=splitDf（df，n）
列车测试=[]
对于范围（0，n）内的i：
trainTest.append（makeTrainAndTest（splits，i））
#获取测试集2
test2=列车测试[2][1]。形状
#将训练设置为零
列车0=列车试验[0][0]

scikit为什么不学习交叉验证？作为课程的一部分，我正在做这项作业，并试图实施验证。这是一个更好的方法solution@HaleemurAli--如果我只需要将其分为1:9，这很好-----这是随机选择1/10作为测试集，但我正在尝试实现k倍验证，据我所知：将数据分解为K块。然后，对于K=1到X，将第K个块作为测试块，其余数据成为训练数据。训练、测试、记录然后更新K。您可以将数据帧索引拆分为块并循环。看见