使用sklearn构建决策树前，为何选LabelEncoder/OneHotEncoder而非pd.get_dummies？

Great question! A lot of folks new to scikit-learn wonder the same thing—why go through the multi-step LabelEncoder + OneHotEncoder process when pandas' get_dummies() does it in one line? The short answer is that scikit-learn's tools are built specifically for the robustness and workflow integration needed in machine learning projects, whereas pandas is focused more on data manipulation convenience. Let's break down the key reasons:

1. Seamless integration with scikit-learn's Pipeline workflow #

In real-world ML projects, we rarely just encode data once and call it done. We usually need to package preprocessing steps (encoding, scaling, feature selection) and model training into a Pipeline. This offers two huge benefits:

• Prevents data leakage: If you use get_dummies() on the full dataset before splitting into train/test sets, you risk encoding information from the test set into your training data. Scikit-learn's encoders follow the fit-then-transform pattern: you fit on the training data only, then apply the same encoding rules to the test set—no leakage, no inconsistency.
• Eases reuse and deployment: A saved Pipeline can be directly applied to new, unseen data for prediction, eliminating the need to rewrite get_dummies logic manually (and the bugs that come with it).

Here's a quick example of how this works:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.compose import ColumnTransformer

# Define preprocessing for categorical columns
preprocessor = ColumnTransformer(
    transformers=[
        ('cat_encoder', OneHotEncoder(drop='first'), ['col1', 'col2'])
    ], remainder='passthrough')

# Package preprocessing and model into a single pipeline
ml_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier())
])

# Train the entire pipeline (encoding happens automatically on training data)
ml_pipeline.fit(X_train, y_train)

# Predict on new data (uses the same encoding rules from training)
ml_pipeline.predict(X_new)

Trying to shoehorn get_dummies() into this workflow would require manual handling of train/test encoding consistency—something that's easy to mess up.

2. Handles unseen categories gracefully #

When you deploy your model, new data might contain categories that weren't present in your training set. Scikit-learn's OneHotEncoder lets you handle this with the handle_unknown='ignore' parameter, which simply ignores new categories instead of throwing an error.

With get_dummies(), new categories would generate entirely new columns, making your feature set incompatible with the trained model (since it expects the same number of features it was trained on).

Example of handling unseen categories:

from sklearn.preprocessing import OneHotEncoder

# Initialize encoder to ignore unknown categories
encoder = OneHotEncoder(handle_unknown='ignore', drop='first')
encoder.fit(X_train[['col1']])

# Test data has a category not seen in training—no error, just ignores it
encoder.transform(X_test[['col1']])

3. Better support for ordinal categorical variables #

You mentioned get_dummies() is clunky for ordered categories—and you're right! Scikit-learn has OrdinalEncoder specifically for ordered variables, which lets you explicitly define the category order (critical for models that can leverage ordinal information, like decision trees).

For example, if you have an ordered column like ['low', 'medium', 'high']:

from sklearn.preprocessing import OrdinalEncoder

encoder = OrdinalEncoder(categories=[['low', 'medium', 'high']])
encoder.fit_transform(df[['ordinal_col']])

With get_dummies(), you'd have to manually map categories to integers first, which is error-prone and less readable.

4. Consistent API with other scikit-learn tools #

All scikit-learn preprocessing tools follow the same fit-transform interface, which plays nicely with other components like GridSearchCV (for hyperparameter tuning) or SelectKBest (for feature selection). You don't have to convert pandas DataFrames to numpy arrays manually to make everything work together—scikit-learn handles it seamlessly.

Don't get me wrong—get_dummies() is still great for quick exploratory analysis or small, fixed datasets where you don't need to worry about deployment or workflow consistency. But for building robust, production-ready ML models, scikit-learn's encoder pipeline is the way to go.

内容的提问来源于stack exchange，提问作者jacob