交叉验证的原理放在后面，先看函数。
    设X是一个93的矩阵，即9个样本，3个特征，y是一个9维列向量，即9个标签。现在我要进行3折交叉验证。

    执行kFold = KFold(n_splits=3) ：其中KFold是一个类，n_split=3表示，当执行KFold的split函数后，数据集被分成三份，两份训练集和一份验证集。*

    执行index = kFold.split(X=X)：index是一个生成器，每个元素是一个元组，元组里面有两个元素，第一个是训练集的索引，第二个是验证集的索引。因为这里将9个样本分成三份，所以index中有三个这样的元组

    之后便可以迭代index来获得训练集和验证集的索引，从而获得训练集和测试集了

    下面是代码示例

    1. import numpy as np
    2. from sklearn.model_selection import KFold
    4. a = np.arange(27).reshape(9, 3)
    5. print(a)
    6. b = np.arange(9).reshape(9, 1)
    7. kfold = KFold(n_splits=3, shuffle=True)
    8. index = kfold.split(X=a)
    9. print(list(index))
    10. print(type(index))
    11. index = kfold.split(X=a, y=b)
    12. for train_index, test_index in index:
    13.     print("-------------------------------------------------")
    14.     print(a[train_index]) #注意如果a是datafram类型就得用a.iloc[tain_index], 因为a[train_index]会被认为是访问列
    15.     print(a[test_index])

    运行结果如下：

    1. [[ 0 1 2]
    2. [ 3 4 5]
    3. [ 6 7 8]
    4. [ 9 10 11]
    5. [12 13 14]
    6. [15 16 17]
    7. [18 19 20]
    8. [21 22 23]
    9. [24 25 26]]
    10. [(array([0, 1, 3, 4, 5, 6]), array([2, 7, 8])), (array([1, 2, 3, 4, 7, 8]), array([0, 5, 6])), (array([0, 2, 5, 6, 7, 8]), array([1, 3, 4]))]
    11. <class 'generator'>
    12. -------------------------------------------------
    13. [[ 6 7 8]
    14. [ 9 10 11]
    15. [12 13 14]
    16. [18 19 20]
    17. [21 22 23]
    18. [24 25 26]]
    19. [[ 0 1 2]
    20. [ 3 4 5]
    21. [15 16 17]]
    22. -------------------------------------------------
    23. [[ 0 1 2]
    24. [ 3 4 5]
    25. [ 9 10 11]
    26. [15 16 17]
    27. [21 22 23]
    28. [24 25 26]]
    29. [[ 6 7 8]
    30. [12 13 14]
    31. [18 19 20]]
    32. -------------------------------------------------
    33. [[ 0 1 2]
    34. [ 3 4 5]
    35. [ 6 7 8]
    36. [12 13 14]
    37. [15 16 17]
    38. [18 19 20]]
    39. [[ 9 10 11]
    40. [21 22 23]
    41. [24 25 26]]
    42. Process finished with exit code 0

    原理补充：

    在机器学习建模过程中，通行的做法通常是将数据分为训练集和测试集。测试集是与训练独立的数据，完全不参与训练，用于最终模型的评估。在训练过程中，经常会出现过拟合的问题，就是模型可以很好的匹配训练数据，却不能很好在预测训练集外的数据。如果此时就使用测试数据来调整模型参数，就相当于在训练时已知部分测试数据的信息，会影响最终评估结果的准确性。通常的做法是在训练数据再中分出一部分做为验证(Validation)数据，用来评估模型的训练效果。

    验证数据取自训练数据，但不参与训练，这样可以相对客观的评估模型对于训练集之外数据的匹配程度。模型在验证数据中的评估常用的是交叉验证，又称循环验证。它将原始数据分成K组(K-Fold)，将每个子集数据分别做一次验证集，其余的K-1组子集数据作为训练集，这样会得到K个模型。这K个模型分别在验证集中评估结果，最后的误差MSE(Mean Squared Error)加和平均就得到交叉验证误差。交叉验证有效利用了有限的数据，并且评估结果能够尽可能接近模型在测试集上的表现，可以做为模型优化的指标使用。