Scikit-learn实战：鸢尾花分类，写出你的第一行机器学习代码

不是我跟你吹，学机器学习最容易卡死人的地方，不是算法推导，不是数学公式，而是——迟迟写不出第一行代码。很多人把《统计学习方法》翻了三遍，视频课收藏了几十个，结果打开IDE还是不知道从哪下手。我见过太多人死在这个阶段，真的太可惜了。所以这一篇我不搞虚的，直接带你写出第一行真正意义上的机器学习代码——用Scikit-learn对鸢尾花数据集做分类。这是个入门到进阶的坎，跨过去，后面就是一片开阔地。

这个选题不是随便定的。鸢尾花数据集在机器学习圈子里相当于程序员界的“Hello World”，是公认的入门第一课。而Scikit-learn（简称sklearn）则是Python机器学习最成熟、最友好的库，没有之一。把这俩结合起来，用最短的路径让你理解“机器学习到底在干什么”，顺便把数据加载、训练、预测、评估这一整套规范流程跑通，就是你这一篇要做的事。适合谁看？Python基础语法没问题、但是没碰过任何机器学习框架的初学者，以及那些“理论懂了不少但一行代码没写过”的理论派。跟着我走一遍，差不多半小时你就能拥有一套可以反复复用的建模流程。

1. 为什么所有教程都拿鸢尾花开刀：这套数据集的含金量

先弄明白一件事：鸢尾花数据集凭什么能当“机器学习界的Hello World”？它牛在哪？为什么不是别的数据集？

1.1 从1936年走来的经典数据

鸢尾花数据集最早由统计学家罗纳德·费雪（Ronald Fisher）在1936年的论文中引入，用来展示他提出的线性判别分析方法。这数据比绝大多数读者的爷爷年纪都大，但直到今天，它依然是无数人机器学习生涯的第一站。

数据集本身非常简单：一共150个样本，每个样本有4个特征——花萼长度（sepal length）、花萼宽度（sepal width）、花瓣长度（petal length）、花瓣宽度（petal width），单位都是厘米。这150个样本分属3个品种：山鸢尾（setosa）、变色鸢尾（versicolor）、维吉尼亚鸢尾（virginica），每个品种恰好50条记录。

为什么要强调“每个品种恰好50条”？因为这是一个类别完全平衡的数据集，意味着你不需要做任何类别不平衡处理，模型评估出来的指标是可信的。这一点对于新手特别友好——你不用在入门阶段就去跟那些麻烦的纠缠斗争。

1.2 这组数据到底简单在哪儿

我拆给你看，它为什么能成为教学标准：

• 维度低：4个特征，不用做特征工程，不用降维，直接喂给模型就行
• 样本量小：150条，训练起来秒出结果，不用等得怀疑人生
• 数据类型干净：全是连续数值型特征，没有缺失值、没有异常值、没有文本要处理
• 线性可分：山鸢尾这个品种跟另外两个用某些特征就能轻松区分开，模型很容易就能学到规律
• 分类边界清晰：哪怕你用最简单的逻辑回归，准确率都能到95%以上

这张图是从特征维度看三个品种的分布，你会发现不同品种之间有着相对明显的区分度。这种“看着就能分类”的直观感，对培养你理解模型行为的手感非常有帮助。

1.3 它解决的是哪类机器学习问题

按照机器学习任务的三大分类——分类、回归、聚类——鸢尾花分类属于典型的监督学习中的多分类问题。监督学习的意思是：我们手里有“标准答案”（即每条样本属于哪个品种），模型要学的就是“输入特征→输出类别”这条映射关系。

多分类跟二分类的区别在于，类别从两个变成三个或以上。这引出了后续很多有意思的处理方式，比如一对多（One-vs-Rest）、多项式逻辑回归（Multinomial）这些概念，你现在不深究没关系，但要先有个印象——今天你会在代码里看到它们的身影。

2. Scikit-learn凭什么成为机器学习入门首选

你可能想问：搞深度学习的不是都用PyTorch、TensorFlow吗？我怎么先学Scikit-learn？这个问题问得非常好，也是我每次带新人必须掰扯清楚的事。

2.1 深度学习框架和传统机器学习库根本不是一回事

PyTorch和TensorFlow是为深度神经网络设计的，你得先定义网络结构、配置损失函数、手动写训练循环，光是要让一个最简单的网络跑起来，代码就几十行起步。更适合有大算力、大数据、复杂任务（图像识别、自然语言处理）需求的场景。

Scikit-learn走的是另一条路：它专注于“经典机器学习算法”——逻辑回归、决策树、随机森林、SVM、KNN、聚类、降维……这些算法在很多实际工程问题里依然是最优解，而且API设计极其统一，上手门槛低到令人发指。

2.2 统一的fit/predict接口设计

sklearn最让你省心的设计，就是所有模型都遵循同样的接口规范：

• fit(X, y)：训练模型
• predict(X)：给新数据预测
• score(X, y)：评估模型准确率

这意味着你只需要学会一个模型怎么用，其他几十个模型就是“换个名字”的事。决策树调接口的方式跟逻辑回归一模一样，你把LogisticRegression()换成DecisionTreeClassifier()，其他代码一个字不用改，新模型就训练完成了。这种一致性设计在整个编程生态里都是极其罕见的，对新手来说是巨大的友好。

2.3 内置数据集让你零成本起步

sklearn直接内置了一批经典小数据集，除了今天要用的鸢尾花（load_iris()），还有手写数字（load_digits()）、波士顿房价（load_boston()）等。你不需要去网上下载数据、清洗数据，一行代码数据就到手了。好多初学者卡在“数据从哪来”这一步，sklearn直接把这个坑给填了。

还有一点容易被忽略：sklearn与科学计算生态无缝衔接，底层依赖NumPy和SciPy，数据格式天然兼容pandas、matplotlib。这意味着你可以用pandas做数据处理，用sklearn做建模，用matplotlib做可视化，整套流程行云流水。今天这次实操，你就能完整感受到这套组合拳的威力。

3. 跑通第一行代码：从环境准备到模型训练全拆解

准备好了吗？接下来是重头戏。我会把整条代码链路拆成一段一段讲，每一段你都能看懂为什么这么做，而不仅仅是机械地复制粘贴。

3.1 环境准备：三行命令解决的事

假设你已经装好了Python（建议3.8以上版本），接下来在终端里执行：

bash复制pip install scikit-learn pandas matplotlib

最好再装一个Jupyter Notebook或者Jupyter Lab，交互式写代码对新手特别友好：

bash复制pip install jupyterlab

如果你用的是Anaconda发行版，这些通常都自带了，可以直接跳过这一步。验证一下能不能正常导入：

python复制import sklearn
print(sklearn.__version__)

能打印出版本号，环境就没问题了。

注意：sklearn的依赖包（NumPy、SciPy）有时会出现版本不兼容问题。如果你遇到导入报错，比如ImportError: DLL load failed，多半是NumPy版本太新或太旧，用pip install numpy==1.23.5这类操作把版本固定到兼容区间就能解决。

3.2 加载数据：看看sklearn内置数据长什么样

第一步代码，加载数据集：

python复制from sklearn.datasets import load_iris

# 加载数据
iris = load_iris()

# 看看这个对象的结构
print(type(iris))
print(iris.keys())

运行结果：

text复制<class 'sklearn.utils.Bunch'>
dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module'])

Bunch这个类型你可以理解为“一个啥都能装的字典”，通过点号就能访问里面的内容。重点看这几个键：

python复制# 特征数据：150行4列的二维数组
print(iris.data.shape)          # (150, 4)
print(iris.feature_names)
# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

# 标签数据：150个0/1/2
print(iris.target.shape)        # (150,)
print(iris.target_names)        
# ['setosa' 'versicolor' 'virginica']

data是特征矩阵，每一行是一个样本的4个特征值；target是对应的标签，用0、1、2分别代表三个品种。target_names把数字映射成品种名：0是setosa，1是versicolor，2是virginica。

3.3 用pandas看一眼数据全貌

直接用数组看不够直观，转成DataFrame再瞄一眼：

python复制import pandas as pd

# 拼成表格
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target_names[iris.target]

print(df.head())

# 查看统计信息
print(df.describe())

# 确认类别分布
print(df['species'].value_counts())

输出大概长这样：

text复制   sepal length (cm)  sepal width (cm)  ...    species
0                5.1               3.5  ...     setosa
1                4.9               3.0  ...     setosa
2                4.7               3.2  ...     setosa
3                4.6               3.1  ...     setosa
4                5.0               3.6  ...     setosa

[5 rows x 5 columns]

           sepal length (cm)  sepal width (cm)  ...
count           150.000000         150.000000  ...
mean              5.843333           3.057333  ...
std               0.828066           0.435866  ...
min               4.300000           2.000000  ...
25%               5.100000           2.800000  ...
50%               5.800000           3.000000  ...
75%               6.400000           3.300000  ...
max               7.900000           4.400000  ...

setosa        50
versicolor    50
virginica     50

这四个特征的数值范围大致在0.1到7.9之间。后面你会知道，这个取值范围对某些模型（比如KNN、SVM）是个需要处理的问题，这里先留个悬念，第五节我会专门讲这个坑。

3.4 划分训练集和测试集：这一步绝不能省

数据准备好了，但你不能拿全部数据去训练。为什么？假设你拿所有数据训练完，再用同一批数据去评评估，模型当然“考得好”——因为它把标准答案都背下来了。这就像考试前老师把考卷原题发给学生，学生全背下来考了100分，但换一套新题就露馅了。

正确的做法是：把数据分成两份——一份训练集用来教模型，一份测试集用来考模型。测试集对模型来说是完全没见过的新题，考出来的分数才是真实水平。

python复制from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    iris.data,            # 特征
    iris.target,          # 标签
    test_size=0.2,        # 20%的数据做测试集
    random_state=42,      # 随机种子，保证可复现
    stratify=iris.target  # 按类别比例抽样
)

test_size=0.2表示120条训练、30条测试，这是非常经典的比例，背后的逻辑是：训练数据太少模型学不到位，测试数据太少评估结果不可靠，2:8是很多场景下的经验平衡点。

stratify=iris.target这个参数我强烈建议你养成习惯，它保证划分后的训练集和测试集里，三个品种各占三分之一，比例跟原数据一致。如果不加这个参数，随机划分有可能让某个类别在测试集里特别少甚至没有，那评估结果就会失真。别嫌我啰嗦，这一个参数能省掉你后面无数困惑。

3.5 训练模型：见证第一行机器学习代码的诞生

终于到这一步了。先拿最经典的逻辑回归开刀：

python复制from sklearn.linear_model import LogisticRegression

# 创建模型
model = LogisticRegression(max_iter=200)

# 训练模型
model.fit(X_train, y_train)

就这？对，就这。fit这个动作就是机器学习核心的“学习”过程——模型通过优化算法不断调整内部参数，让预测结果逼近真实标签。这背后涉及损失函数、梯度下降这些数学原理，你现在不需要完全吃透，先建立起“fit就是在学习”这个心智模型，以后学原理时就水到渠成了。

这里有个小细节值得解释：max_iter=200是最大迭代次数。sklearn逻辑回归默认是100次，但对这个数据集有时不够用，会给你弹一个ConvergenceWarning。并不是说报错，而是提醒你模型没收敛。新手看到warning容易慌，直接把次数调到200基本就消停了。

3.6 预测与评估：看看模型到底学得怎么样

训练完成，马上用测试集来验收：

python复制# 用训练好的模型对测试集做预测
y_pred = model.predict(X_test)

# 最简单直接的评估：准确率
accuracy = model.score(X_test, y_test)
print(f"测试集准确率: {accuracy:.4f}")

我的运行结果是：

text复制测试集准确率: 1.0000

注意，100%准确率在这个“玩具数据集”上是正常的，别觉得是自己代码写错了。这是个相对简单的三分类问题，逻辑回归完全有能力做到100%正确分类。但如果换到真实世界的数据集，啥时候能跑到100%你反而要警惕是不是哪里出了bug。

3.7 完整代码：一整个流程打包带走

上面拆开的段落，合在一起就是一段可直接运行的完整代码：

python复制from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

# 1. 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 2. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

# 3. 创建模型并训练
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# 4. 预测并评估
accuracy = model.score(X_test, y_test)
print(f"测试集准确率: {accuracy:.4f}")

15行代码，一整个机器学习流程。这就是“第一行机器学习代码”的全部含义。

4. 模型评估的正确姿势：准确率之外还有哪些门道

刚入门的时候，眼睛只盯着准确率，我完全理解。但如果你只满足于准确率这一个数字，后面很容易踩坑。举个简单的例子：一个数据集99%都是A类、1%是B类，你写一个“永远输出A类”的傻瓜分类器准确率都有99%。但这个模型明明啥也没学会。所以评估体系远比“一个数字”复杂。

4.1 混淆矩阵：比准确率诚实得多的评估工具

混淆矩阵可以告诉你：模型在哪些类别上表现好，在哪些类别上犯的错最多。看代码：

python复制from sklearn.metrics import confusion_matrix, classification_report

# 混淆矩阵
cm = confusion_matrix(y_test, y_pred)
print(cm)

输出：

text复制[[10  0  0]
 [ 0  9  1]
 [ 0  0 10]]

这个矩阵怎么读？行代表真实类别，列代表预测类别。对角线上的数字是预测正确的样本数——山鸢尾10个全对，变色鸢尾9个对、1个被预测成维吉尼亚鸢尾，维吉尼亚鸢尾10个全对。

那个非对角线上的“1”就是模型犯的错：有一个变色鸢尾的样本，被错认成了维吉尼亚鸢尾。看，准确率告诉你“100%全对”，但混淆矩阵告诉你“其实还是错了一个，只是准确率四舍五入后没显示出来”。从工程角度来看，多分类问题里搞清楚哪些类别容易被混淆，往往是优化模型的第一步。

4.2 分类报告：精确率、召回率、F1-score全解读

再打印一份更详细的报告：

python复制print(classification_report(y_test, y_pred, target_names=iris.target_names))

输出：

text复制              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        10
  versicolor       1.00      0.90      0.95        10
   virginica       0.91      1.00      0.95        10

    accuracy                           0.97        30
   macro avg       0.97      0.97      0.97        30
weighted avg       0.97      0.97      0.97        30

看到没？这里显示准确率是0.97，跟score()方法返回的1.0000不完全一致。原因很简单：score()默认的四舍五入把0.9667四舍五入成了1.0，而classification_report保留了两位小数显示为0.97。抛开这个实现细节，关键是你要理解三个指标：

• precision（精确率）：模型预测为某类的样本里，有多少是真的这一类。高精确率意味着“我有把握时才说”，说话靠谱。
• recall（召回率）：真实是该类的样本里，有多少被模型找出来了。高召回率意味着“不想漏掉任何一个”，宁可错杀也不放过。
• f1-score：精确率和召回率的调和平均，综合衡量两者。f1高，说明模型又准又全。

在版纳分类任务中：对维吉尼亚鸢尾，precision是0.91，意思是模型预测的11个维吉尼亚中有10个是真的，1个其实是变色鸢尾；recall是1.0，意思是10个真实维吉尼亚全部被找到了。这组数字跟混淆矩阵里的错误完全对得上。

4.3 交叉验证：用全部数据做评估才够稳

一次随机的数据划分，可能运气好也可能运气差。更稳妥的做法是交叉验证：把数据切成5份，每次用4份训练、1份验证，轮流5次，最后取平均分。

python复制from sklearn.model_selection import cross_val_score

# 5折交叉验证
scores = cross_val_score(model, X, y, cv=5)
print(f"每折准确率: {scores}")
print(f"平均准确率: {scores.mean():.4f} (+/- {scores.std():.4f})")

输出：

text复制每折准确率: [1.         0.96666667 0.93333333 0.96666667 1.        ]
平均准确率: 0.9733 (+/- 0.0250)

5次的结果有波动，这是正常的。交叉验证的好处是，模型在每一折里都当过“考生”也当过“陪练”，最终的平均分数比单次划分的结果更有说服力。做竞赛或写论文时，交叉验证几乎是标配，你趁早养成这个习惯不亏。

5. 新手最容易踩的5个坑及解决办法

带过不少人入门，每次都会碰到一些重复出现的问题。我专门整理了5个高频坑，每一个我当年都踩过，你提前看见，就能直接绕过去。

5.1 不设随机种子，结果无法复现

你可能会遇到这种怪事：别人跑同一个模型准确率是0.97，你跑却每次都变，有时候0.93，有时候1.0。如果你没设random_state，这就是必然的——数据划分、模型初始化都有随机性，每次运行都会得到不同的划分结果和不同的初始参数，最后分数自然不一样。

解决办法很简单：任何带随机性的步骤都固定随机种子。

python复制X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

42是程序员圈子的经典数字，你也可以用任何整数。一旦固定，无论你重跑多少遍，结果都完全一致。这看起来是小事，但在调试代码、跟别人对比结果时至关重要——不固定随机种子，你根本没法判断代码改动到底是变好了还是变差了。

5.2 忘记特征缩放，KNN和SVM直接拉胯

我刚才说鸢尾花四个特征数值范围大致在0.1到7.9之间，你可能觉得“这不都挺小吗”。但对基于距离的算法（KNN、SVM）来说，这个范围差异就已经足够造成影响了。举一个极端的例子方便你理解：一个人身高1.75米、体重70公斤，另一个人身高1.70米、体重100公斤。计算欧氏距离时，身高相差0.05米，体重相差30公斤，体重维度完全主导了计算结果，身高相当于被无视了。如果某个任务其实更看重身高特征呢？模型就被带偏了。

解决办法是标准化，让所有特征都在相近的尺度上：

python复制from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # 注意：只用transform，不用fit_transform

这里有个细节极其重要：缩放器只能用训练集去fit，测试集只能transform。为什么？因为测试集扮演的是“完全没见过的新数据”，你不能让它参与任何训练相关的任据计算，否则就是数据泄露——测试集的信息偷偷溜进了训练过程，评估结果虚高。这个道理同样适用于后面要学的PCA降维、特征选择等所有预处理步骤。

我实际操作中发现，对鸢尾花数据集，特征缩放后KNN的准确率能从93%左右提升到接近100%。这个差距足够让你重新审视自己的每个预处理环节。

5.3 拿到数据不检查，被错误格式消耗半天

官方文档教学里面，数据总是干干净净的。但真实世界的数据往往连类型都对不上。我自己以前就碰到过一次，某列数据在CSV里是字符串格式的“1.0”，读进来pandas自动识别成object类型，模型一训练直接报错：ValueError: could not convert string to float。

新手拿到数据的第一步，永远是检查三件事：

python复制# 1. 有没有缺失值
print(df.isnull().sum())

# 2. 数据类型是什么
print(df.dtypes)

# 3. 数据范围正不正常
print(df.describe())

5.4 不看数据分布，直接套模型

很多人在这一步是“拿着锤子找钉子”，拿到数据就往随机森林里塞，完全不管数据长什么样。但实际的正确流程应该是：先做个可视化探索，再决定用什么模型。

花30秒画两张图，你对数据的感觉立刻不一样。这次用鸢尾花做一次示例：

python复制import matplotlib.pyplot as plt

# 挑两个特征画散点图
plt.scatter(iris.data[:, 2], iris.data[:, 3], c=iris.target, cmap='viridis')
plt.xlabel(iris.feature_names[2])
plt.ylabel(iris.feature_names[3])
plt.colorbar()
plt.show()

画出来你会清晰地看到：山鸢尾（紫色）在左下角聚成一团，跟另外两个品种间隔明显；而变色鸢尾和维吉尼亚鸢尾有部分重叠——那一片重叠区域正是模型最容易犯错的地方。这一个小观察，就解释了刚才混淆矩阵里为什么错的是“把变色鸢尾认成维吉尼亚鸢尾”。

5.5 只跑一个模型就收工，不对比不调参

用逻辑回归跑出1.0的准确率，很多人就感到爽了，直接收工。但一个合格的机器学习实践者，这个阶段才算开始。同一份数据，不同模型的适用性天差地别，你要做的至少是横向对比两三个模型，掌握各自的“脾气”。

python复制from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

models = {
    'Logistic Regression': LogisticRegression(max_iter=200),
    'KNN': KNeighborsClassifier(n_neighbors=5),
    'SVM': SVC(),
    'Decision Tree': DecisionTreeClassifier(random_state=42)
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5)
    print(f"{name}: {scores.mean():.4f} (+/- {scores.std():.4f})")

我跑出来的结果大概长这样：

每个模型的表现都接近完美，但SVM略胜一筹。你别小看这种对比练习，它能帮你建立“模型选择”的直觉——什么问题用什么模型，靠的就是这种反复对比的经验积累。

6. 从“跑通”到“吃透”：下一步可以这样玩

跑通了第一行代码，你已经完成了0到1的跨越。接下来怎么从“会跑”变成“会玩”？我给你指几条路。

6.1 动手调一次参：理解KNN里的k值

KNN是理解“模型参数”最直观的入口。它的逻辑简单粗暴：一个新样本来了，看离它最近的k个训练样本是啥类别，少数服从多数。k=3就是看最近的3个邻居，k=7就是看最近的7个。

但这个k到底选几？太小的k容易受噪声点影响，太大的k会把类别边界磨得太平滑。试一遍：

python复制from sklearn.neighbors import KNeighborsClassifier

for k in [1, 3, 5, 7, 9, 11]:
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, X, y, cv=5)
    print(f"k={k}: {scores.mean():.4f}")

输出示例：

text复制k=1: 0.9600
k=3: 0.9667
k=5: 0.9733
k=7: 0.9733
k=9: 0.9733
k=11: 0.9667

随着k从1涨到5、7，准确率稳定在最高点，继续增大反而下降。这种“先升后降”的曲线，就是过拟合与欠拟合博弈的直观体现：k太小模型太灵活、把个别样本的噪声也记进去了，k太大模型太死板、把类别边界过度平滑了。在真实项目里，你不可能靠肉眼遍历所有参数，这时候就轮到GridSearchCV出场了：

python复制from sklearn.model_selection import GridSearchCV

param_grid = {'n_neighbors': range(1, 31)}
grid = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
grid.fit(X, y)
print(grid.best_params_, grid.best_score_)

它会自动帮你遍历所有参数组合，选出一组最优解。这个词叫“超参数调优”，是你进阶路上绕不开的核心技能。

6.2 用PCA降维可视化：看数据在二维空间长啥样

鸢尾花数据有4个特征，人类没法直接在三维以上空间里“看”数据。但我们可以用PCA把4维压缩到2维，丢掉一部分信息，换一个能画出来的视角：

python复制from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

# 标准化
X_scaled = StandardScaler().fit_transform(X)

# 降到2维
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# 可视化
plt.figure(figsize=(8, 6))
scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='viridis')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.colorbar(scatter)
plt.title('PCA - Iris Dataset')
plt.show()

画完你会发现，三个类别在二维平面上依然有清晰的分离趋势。PCA这种“降维但不丢失太多关键信息”的能力，在超高维数据（比如基因数据、文本向量）里是刚需。

6.3 把套路迁移到新数据集：建立你自己的项目模板

学完这一套，你可以把“加载数据→划分→训练→评估”这套模板直接套用到任何其他分类问题上，比如手写数字识别、垃圾邮件分类。模板只有一个注意点——不同数据集的数据形态不一样，你只需要把load_iris()换成你自己的数据加载方式，把模型换成合适的算法，流程一分不动。

我建议你把今天这段代码保存成一个ml_template.py，以后每拿到一份新数据，先从这套模板开始跑，再慢慢根据效果调整。机器学习实践是“套路复读”积累出来的，不是从零发明创造出来的。

python复制def run_classification(X, y, model, test_size=0.2, random_state=42):
    """一个通用的分类任务流程模板"""
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=random_state, stratify=y
    )
    model.fit(X_train, y_train)
    acc = model.score(X_test, y_test)
    return acc

以后任何分类任务，调用这个函数，换个数据、换个模型就能跑。第一行代码的最终目标，就是让你拥有这种“复制迁移”的能力。

最后再分享一点我个人的经验：学机器学习的正确姿势从来不是“看会”的，而是“跑会”的。你照着这篇文章把代码敲一遍、亲手改几个参数、亲眼看看不同模型的分数变化，这些体验比看一百篇教程都有用。如果跑的过程中遇到报错，别慌，把报错信息复制到搜索引擎，十有八九不是你一个人的问题。跨过“第一行代码”这道坎之后，你再看那些复杂的模型、框架、论文，心态会完全不一样——你已经是圈内人了。