10 Best Python Libraries for Data Science

I once helped a small U.S. company replace an HR leave tracker built in Excel. Ten employees emailed requests, one manager updated the workbook, and conflicting edits caused regular confusion. We first built a local Python leave request app that stored each request in an SQLite database.

Once the app collected reliable data, HR wanted useful answers. Which months had the most absences? How many days did each department request? Could historical patterns help with staffing? That work introduced the team to the best Python libraries for data science.

This practical list explains where each library fits, using the same leave data from setup through analysis and prediction.

How I Chose the Best Python Libraries for Data Science

I did not choose libraries because they appear in every generic Python tutorial. Each recommendation solves a real part of a data science workflow on a local Windows, macOS, or Linux machine.

The list covers five jobs: numerical calculation, data cleaning, visualization, statistical testing, and machine learning. I also considered beginner learning time and how well each library works with the others.

Assume Python 3.11 or newer for the examples. Create a virtual environment, which is an isolated place for project packages, before installing anything:

python -m venv .venv

# Windows
.venv\Scripts\activate

# macOS or Linux
source .venv/bin/activate

pip install numpy pandas matplotlib seaborn scipy scikit-learn statsmodels plotly tensorflow torch

Use this small project structure while learning:

leave_data_project/
├── app.py
├── analysis.py
├── leave_requests.db
└── charts/

app.py handles CRUD operations, meaning create, read, update, and delete actions. analysis.py loads and studies the data. The charts folder stores exported reports. This separation keeps database code away from analysis code without creating too many modules.

Prepare a Practical Leave Request Dataset

Python includes sqlite3, so you do not need a separate database server. A database stores structured records in tables, while SQLite keeps the entire database in one local file.

The following code creates a table for a U.S. company. It stores dates in the ISO YYYY-MM-DD format, which sorts correctly and avoids confusion between U.S. and international date formats.

# app.py
import sqlite3
from datetime import datetime

DB_PATH = "leave_requests.db"

def create_database():
    with sqlite3.connect(DB_PATH) as connection:
        connection.execute("""
            CREATE TABLE IF NOT EXISTS leave_requests (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                employee_name TEXT NOT NULL,
                department TEXT NOT NULL,
                start_date TEXT NOT NULL,
                end_date TEXT NOT NULL,
                leave_type TEXT NOT NULL,
                status TEXT NOT NULL DEFAULT 'Pending'
            )
        """)

A function groups reusable instructions under a name. The next function validates both dates and calculates calendar-day duration with datetime before saving the request.

def add_request():
    name = input("Enter employee name: ").strip()
    department = input("Enter department: ").strip()
    start_text = input("Enter start date (YYYY-MM-DD): ")
    end_text = input("Enter end date (YYYY-MM-DD): ")
    leave_type = input("Enter leave type: ").strip()

    start = datetime.strptime(start_text, "%Y-%m-%d").date()
    end = datetime.strptime(end_text, "%Y-%m-%d").date()

    if end < start:
        raise ValueError("End date cannot be before start date.")

    duration = (end - start).days + 1

    with sqlite3.connect(DB_PATH) as connection:
        connection.execute("""
            INSERT INTO leave_requests
            (employee_name, department, start_date, end_date, leave_type)
            VALUES (?, ?, ?, ?, ?)
        """, (name, department, start_text, end_text, leave_type))

    print(f"Saved a {duration}-day leave request for {name}.")

Question-mark placeholders protect the SQL statement from unsafe text input. Here are the read and approval functions needed for a simple command-line application:

def list_requests():
    with sqlite3.connect(DB_PATH) as connection:
        rows = connection.execute("""
            SELECT id, employee_name, department,
                   start_date, end_date, status
            FROM leave_requests
            ORDER BY start_date
        """).fetchall()

    for row in rows:
        print(row)

def approve_request(request_id):
    with sqlite3.connect(DB_PATH) as connection:
        connection.execute("""
            UPDATE leave_requests
            SET status = 'Approved'
            WHERE id = ?
        """, (request_id,))

You now have realistic data for the ten libraries below. If you later add a desktop interface, this guide to Python GUI programming provides a logical next step.

Pro Tip: In my experience, storing dates as MM/DD/YYYY causes painful sorting and parsing bugs. I always store ISO dates and format them for U.S. users only when displaying results.

10 Best Python Libraries for Data Science Projects

1. NumPy for Fast Numerical Work

NumPy provides multidimensional arrays and optimized mathematical operations. An array resembles a Python list, but it handles large numeric datasets much faster and uses less memory.

Use NumPy when you need averages, percentiles, matrix operations, simulations, or data transformations. In our HR example, it quickly summarizes leave durations:

import numpy as np

durations = np.array([2, 5, 1, 3, 10, 2, 4])

print("Average:", durations.mean())
print("Median:", np.median(durations))
print("90th percentile:", np.percentile(durations, 90))

You can see the output in the screenshot below.

The median often describes typical leave better than the average because one long absence can pull the average upward. NumPy also powers many other libraries in this list. You can explore array plotting in this Matplotlib and NumPy array example.

2. pandas for Cleaning and Analyzing Tables

pandas is my first choice for spreadsheet-like data. Its main object, a DataFrame, stores rows and named columns like an Excel table.

pandas can read the SQLite table directly, convert text to dates, calculate durations, and group results by department:

import sqlite3
import pandas as pd

with sqlite3.connect("leave_requests.db") as connection:
    df = pd.read_sql_query(
        "SELECT * FROM leave_requests",
        connection
    )

df["start_date"] = pd.to_datetime(df["start_date"])
df["end_date"] = pd.to_datetime(df["end_date"])
df["duration_days"] = (
    df["end_date"] - df["start_date"]
).dt.days + 1

department_totals = (
    df.groupby("department")["duration_days"]
      .sum()
      .sort_values(ascending=False)
)

print(department_totals)

This code performs several manual Excel steps in one repeatable script. Learn more about importing files with pandas read CSV and summarizing categories with pandas groupby aggregation.

3. Matplotlib for Complete Chart Control

Matplotlib creates static charts and gives you detailed control over labels, axes, colors, and output files. I use it for reports that must look consistent each month.

import matplotlib.pyplot as plt

department_totals.plot(
    kind="bar",
    color="#2878B5",
    title="Approved Leave Days by Department"
)
plt.xlabel("Department")
plt.ylabel("Calendar Days")
plt.xticks(rotation=0)
plt.tight_layout()
plt.savefig("charts/leave_by_department.png", dpi=150)
plt.show()

You can see the output in the screenshot below.

The chart communicates staffing pressure faster than a table. tight_layout() prevents labels from getting cut off, while dpi=150 produces a clear image for an internal report. See these practical guides for Matplotlib bar charts and saving Matplotlib charts as PNG files.

4. Seaborn for Better Statistical Visuals

Seaborn sits on top of Matplotlib and creates polished statistical charts with less formatting code. It works especially well with pandas DataFrames.

Use a box plot to compare leave duration across departments:

import seaborn as sns
import matplotlib.pyplot as plt

sns.set_theme(style="whitegrid")
sns.boxplot(
    data=df,
    x="department",
    y="duration_days",
    hue="department",
    legend=False
)
plt.title("Leave Duration Distribution")
plt.tight_layout()
plt.show()

You can see the output in the screenshot below.

A box plot shows the median, spread, and unusual values. That makes it more informative than a basic average when leave lengths vary widely. Seaborn is a strong beginner choice because good defaults reduce chart-formatting work.

5. SciPy for Scientific and Statistical Tests

SciPy adds advanced mathematics, optimization, signal processing, and statistical tests. Use it after exploratory analysis raises a question that requires formal testing.

Suppose HR asks whether Engineering and Sales have different average leave durations:

from scipy.stats import ttest_ind

engineering = df.loc[
    df["department"] == "Engineering", "duration_days"
]
sales = df.loc[
    df["department"] == "Sales", "duration_days"
]

statistic, p_value = ttest_ind(
    engineering,
    sales,
    equal_var=False
)
print(f"p-value: {p_value:.3f}")

A p-value estimates how surprising the observed difference would be if both groups had the same average. Do not make policy decisions from a tiny sample. First check data quality and sample size. This SciPy t-test example explains the test in more detail.

6. scikit-learn for Practical Machine Learning

scikit-learn provides consistent tools for preprocessing, training models, and measuring results. Machine learning means teaching an algorithm patterns from historical examples instead of writing every rule manually.

For example, a model could estimate whether a request may need staffing review:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

features = pd.get_dummies(
    df[["department", "leave_type", "duration_days"]],
    drop_first=True
)
target = (df["status"] == "Approved").astype(int)

X_train, X_test, y_train, y_test = train_test_split(
    features, target, test_size=0.25, random_state=42
)

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, predictions))

This example demonstrates the workflow, not an automatic approval system. Human policy should decide leave requests. Study scikit-learn logistic regression and scikit-learn accuracy scores before evaluating a real model.

7. Statsmodels for Explainable Statistics

Statsmodels focuses on statistical models, tests, confidence intervals, and detailed result tables. Choose it when you care about explaining relationships, not only predicting an outcome.

import statsmodels.formula.api as smf

model = smf.ols(
    "duration_days ~ C(department) + C(leave_type)",
    data=df
).fit()

print(model.summary())

Ordinary least squares, or OLS, estimates how categories relate to a numeric result. The summary includes coefficients, uncertainty measures, and diagnostic values. Statsmodels suits analysts who must explain assumptions to HR or leadership.

8. Plotly for Interactive Charts

Plotly creates interactive charts that users can hover, zoom, and filter. Choose it when managers need to explore details instead of viewing a fixed image.

import plotly.express as px

figure = px.bar(
    department_totals.reset_index(),
    x="department",
    y="duration_days",
    title="Leave Days by Department",
    labels={"duration_days": "Calendar Days"}
)
figure.write_html("charts/leave_dashboard.html")

The HTML file opens locally in a browser and does not require a web server. Plotly adds more overhead than Matplotlib, so I reserve it for reports where interaction provides real value.

9. TensorFlow for Production Deep Learning

TensorFlow supports deep learning, a machine learning approach built from layered neural networks. It handles large datasets, specialized hardware, and production model deployment.

import tensorflow as tf

network = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(features.shape[1],)),
    tf.keras.layers.Dense(16, activation="relu"),
    tf.keras.layers.Dense(1, activation="sigmoid")
])

network.compile(
    optimizer="adam",
    loss="binary_crossentropy",
    metrics=["accuracy"]
)

This network is unnecessary for ten employees. Consider TensorFlow when you have thousands of clean records or unstructured data such as text and images. Beginners can review the broader TensorFlow ecosystem before building complex models.

10. PyTorch for Flexible Deep Learning Experiments

PyTorch also builds neural networks, but many developers prefer its direct, Python-friendly training workflow. It works well for research, custom model logic, and rapid experiments.

import torch
from torch import nn

network = nn.Sequential(
    nn.Linear(features.shape[1], 16),
    nn.ReLU(),
    nn.Linear(16, 1),
    nn.Sigmoid()
)

sample = torch.tensor(
    features.astype("float32").values
)
output = network(sample)
print(output[:3])

A tensor is a multidimensional numeric container similar to a NumPy array. Do not learn TensorFlow and PyTorch simultaneously at first. Compare their workflows, then choose one. This guide on TensorFlow versus PyTorch helps with that decision.

Which Python Data Science Library Should You Learn First?

Start with NumPy, pandas, and Matplotlib. Together, they cover calculations, table cleaning, and charts. Add Seaborn when you need clearer statistical visuals.

Learn SciPy or Statsmodels when your work requires formal analysis. Add scikit-learn after you can clean the data and explain your target variable. Save TensorFlow and PyTorch for problems that truly need deep learning.

For the leave request project, pandas offers the highest immediate value. It replaces repeated spreadsheet work and prepares data for every later library.

Things to Keep in Mind

• Validate dates early: Reject missing dates, impossible ranges, and inconsistent formats before analysis.
• Protect employee data: Leave records may contain sensitive details. Restrict file access and avoid collecting unnecessary notes.
• Avoid hard-coded paths: Use pathlib.Path so the project works across Windows, macOS, and Linux.
• Back up SQLite: Copy the database file before schema changes or bulk updates.
• Measure models correctly: Accuracy alone can mask poor results when a single outcome dominates the dataset.
• Keep approvals human: Use analysis for planning support, not automatic employment decisions.

Frequently Asked Questions

We covered 10 practical libraries and used a local HR leave dataset to integrate data collection, analysis, visualization, statistics, and machine learning. Start with pandas, NumPy, and Matplotlib, then add specialized tools only when the problem demands them. I hope you found this article helpful.

You May Also Like:

• Create a DataFrame from a Python dictionary
• Convert pandas strings to datetime values
• Build a Matplotlib time series plot
• Understand a scikit-learn confusion matrix
• Create an expense tracker with Python Tkinter

Bijay Kumar

Bijay Kumar is an experienced Python and AI professional who enjoys helping developers learn modern technologies through practical tutorials and examples. His expertise includes Python development, Machine Learning, Artificial Intelligence, automation, and data analysis using libraries like Pandas, NumPy, TensorFlow, Matplotlib, SciPy, and Scikit-Learn. At PythonGuides.com, he shares in-depth guides designed for both beginners and experienced developers. More about us.

enjoysharepoint.com/