# JSON en science des données : Analyse, transformation et machine learning

JSON est largement utilisé en science des données pour l'échange, le stockage et l'analyse de données. Ce guide montre comment exploiter JSON efficacement.

JSON et pandas

Charger JSON en DataFrame

import pandas as pd

# Depuis fichier
df = pd.read_json('data.json')

# Depuis chaîne
json_str = '[{"nom":"Alice","age":30},{"nom":"Bob","age":25}]'
df = pd.read_json(json_str)

# Depuis URL
df = pd.read_json('https://api.example.com/data')

JSON orientations

# Format records (liste d'objets)
data = [
    {"nom": "Alice", "age": 30},
    {"nom": "Bob", "age": 25}
]
df = pd.DataFrame(data)

# Format columns (colonnes comme clés)
data = {
    "nom": ["Alice", "Bob"],
    "age": [30, 25]
}
df = pd.DataFrame(data)

# Format index
data = {
    "0": {"nom": "Alice", "age": 30},
    "1": {"nom": "Bob", "age": 25}
}
df = pd.DataFrame.from_dict(data, orient='index')

JSON imbriqué

# Normaliser JSON imbriqué
data = {
    "utilisateurs": [
        {
            "nom": "Alice",
            "adresse": {"ville": "Paris", "code": "75001"}
        }
    ]
}

df = pd.json_normalize(
    data['utilisateurs'],
    sep='_'
)
# Résultat: colonnes 'nom', 'adresse_ville', 'adresse_code'

Analyse de données JSON

Statistiques descriptives

import pandas as pd

df = pd.read_json('users.json')

# Statistiques de base
print(df.describe())

# Info colonnes
print(df.info())

# Valeurs manquantes
print(df.isnull().sum())

# Valeurs uniques
print(df['ville'].value_counts())

Filtrage et transformation

# Filtrer par âge
adultes = df[df['age'] >= 18]

# Grouper par ville
par_ville = df.groupby('ville')['age'].mean()

# Ajouter colonne calculée
df['categorie_age'] = pd.cut(
    df['age'],
    bins=[0, 18, 35, 60, 100],
    labels=['jeune', 'adulte', 'senior', 'retraite']
)

Nettoyage de données JSON

Gérer valeurs manquantes

# Supprimer lignes avec null
df_clean = df.dropna()

# Remplir avec valeur par défaut
df['age'].fillna(df['age'].mean(), inplace=True)

# Remplir avec méthode
df.fillna(method='ffill', inplace=True)  # Forward fill

Nettoyer types de données

# Convertir types
df['age'] = pd.to_numeric(df['age'], errors='coerce')
df['date'] = pd.to_datetime(df['date'])

# Nettoyer strings
df['nom'] = df['nom'].str.strip().str.title()

Visualisation

Avec matplotlib

import matplotlib.pyplot as plt

# Histogramme
df['age'].hist(bins=20)
plt.title('Distribution des âges')
plt.xlabel('Âge')
plt.ylabel('Fréquence')
plt.show()

# Bar chart
df['ville'].value_counts().plot(kind='bar')
plt.title('Utilisateurs par ville')
plt.show()

Avec seaborn

import seaborn as sns

# Boxplot
sns.boxplot(x='ville', y='age', data=df)
plt.title('Âge par ville')
plt.show()

# Heatmap corrélation
corr = df.corr()
sns.heatmap(corr, annot=True)
plt.show()

Machine Learning

Préparation données

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder

# Encoder variables catégorielles
le = LabelEncoder()
df['ville_encoded'] = le.fit_transform(df['ville'])

# Split données
X = df[['age', 'ville_encoded']]
y = df['target']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

Entraîner modèle

from sklearn.ensemble import RandomForestClassifier

# Créer et entraîner modèle
model = RandomForestClassifier()
model.fit(X_train, y_train)

# Prédictions
predictions = model.predict(X_test)

# Score
score = model.score(X_test, y_test)
print(f"Accuracy: {score}")

API et collecte de données

Récupérer données API

import requests
import pandas as pd

# API request
response = requests.get('https://api.example.com/data')
data = response.json()

# Convertir en DataFrame
df = pd.DataFrame(data['results'])

# Sauvegarder
df.to_csv('data.csv', index=False)

Pagination

def fetch_all_pages(base_url):
    all_data = []
    page = 1

    while True:
        response = requests.get(f"{base_url}?page={page}")
        data = response.json()

        if not data['results']:
            break

        all_data.extend(data['results'])
        page += 1

    return pd.DataFrame(all_data)

df = fetch_all_pages('https://api.example.com/users')

Gros volumes JSON

Lecture par chunks

# JSON Lines format
chunks = []
for chunk in pd.read_json('large.jsonl', lines=True, chunksize=1000):
    # Traiter chunk
    processed = process_chunk(chunk)
    chunks.append(processed)

df = pd.concat(chunks, ignore_index=True)

Dask pour Big Data

import dask.dataframe as dd

# Lire avec Dask
ddf = dd.read_json('large_data/*.json')

# Opérations lazy
result = ddf[ddf['age'] > 30].compute()

Export et sauvegarde

Vers différents formats

# JSON
df.to_json('output.json', orient='records', indent=2)

# CSV
df.to_csv('output.csv', index=False)

# Excel
df.to_excel('output.xlsx', index=False)

# Parquet (efficace)
df.to_parquet('output.parquet')

# Pickle (Python)
df.to_pickle('output.pkl')

Cas d'usage pratiques

Analyse de logs

# Logs JSON
logs = pd.read_json('app_logs.json', lines=True)

# Parser timestamp
logs['datetime'] = pd.to_datetime(logs['timestamp'])

# Analyser par heure
logs.set_index('datetime', inplace=True)
errors_per_hour = logs[logs['level'] == 'ERROR'].resample('H').size()

# Visualiser
errors_per_hour.plot()
plt.title('Erreurs par heure')
plt.show()

Analyse sentiment

from textblob import TextBlob

# Données reviews JSON
reviews = pd.read_json('reviews.json')

# Analyse sentiment
reviews['sentiment'] = reviews['text'].apply(
    lambda x: TextBlob(x).sentiment.polarity
)

# Catégoriser
reviews['categorie'] = pd.cut(
    reviews['sentiment'],
    bins=[-1, -0.1, 0.1, 1],
    labels=['négatif', 'neutre', 'positif']
)

# Distribution
print(reviews['categorie'].value_counts())

Time Series

# Données temporelles JSON
ts_data = pd.read_json('timeseries.json')
ts_data['date'] = pd.to_datetime(ts_data['date'])
ts_data.set_index('date', inplace=True)

# Resampling
monthly = ts_data.resample('M').mean()

# Rolling average
ts_data['ma_7'] = ts_data['value'].rolling(window=7).mean()

# Prédiction simple
from statsmodels.tsa.arima.model import ARIMA
model = ARIMA(ts_data['value'], order=(1,1,1))
fitted = model.fit()
forecast = fitted.forecast(steps=30)

Meilleures pratiques

Toujours valider JSON avant traitement

Normaliser structures imbriquées

Gérer valeurs manquantes explicitement

Typer colonnes correctement

Optimiser pour gros volumes (Dask, chunking)

Documenter transformations

Versionner données et code

Conclusion

JSON en data science :

Format flexible pour données
Excellente intégration pandas
Support API et streaming
Adapté ML et analytics
Outils puissants disponibles

Points clés :

pd.read_json() pour charger
json_normalize() pour imbriqué
pandas pour analyse
sklearn pour ML
Dask pour big data

Exploitez JSON pour vos projets data science !

JSON en science des données : Analyse, transformation et machine learning

Big JSON Team