import pandas as pd

# Créer un DataFrame à partir d'un dictionnaire
donnees = {
    'nom': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'age': [25, 30, 35, 28],
    'ville': ['Paris', 'Lyon', 'Marseille', 'Toulouse'],
    'salaire': [50000, 60000, 70000, 55000]
}

df = pd.DataFrame(donnees)
print(df)

# Afficher les premières lignes
print(df.head())

# Informations sur le DataFrame
print(df.info())
print(df.describe())

# Sélectionner des colonnes
print(df['nom'])
print(df[['nom', 'age']])

# Filtrer les données
jeunes = df[df['age'] < 30]
print(jeunes)

# Ajouter une nouvelle colonne
df['salaire_annuel'] = df['salaire'] * 12
print(df)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Charger les données
df = pd.read_csv('donnees.csv')

# Statistiques descriptives
print(df.describe())  # Résumé statistique
print(df.info())      # Informations sur les types et valeurs manquantes

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

# Nuage de points
plt.scatter(df['taille'], df['poids'])
plt.xlabel('Taille')
plt.ylabel('Poids')
plt.show()

# Boîte à moustaches
df.boxplot(column='salaire', by='departement')
plt.show()

# Matrice de corrélation
correlation = df.corr()
sns.heatmap(correlation, annot=True, cmap='coolwarm')
plt.show()

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Séparer les données en features (X) et target (y)
X = df[['taille', 'age', 'experience']]
y = df['salaire']

# Diviser en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

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

# Faire des prédictions
y_pred = model.predict(X_test)

# Évaluer le modèle
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f'Erreur quadratique moyenne: {mse:.2f}')
print(f'Score R²: {r2:.2f}')

from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report

# Classification - Prédire une catégorie
X = df[['feature1', 'feature2', 'feature3']]
y = df['categorie']  # Variable catégorielle

# Diviser les données
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Modèle 1: Random Forest
rf_model = RandomForestClassifier(n_estimators=100)
rf_model.fit(X_train, y_train)
rf_pred = rf_model.predict(X_test)
print(f'Random Forest Accuracy: {accuracy_score(y_test, rf_pred):.2f}')

# Modèle 2: SVM
svm_model = SVC(kernel='rbf')
svm_model.fit(X_train, y_train)
svm_pred = svm_model.predict(X_test)
print(f'SVM Accuracy: {accuracy_score(y_test, svm_pred):.2f}')

# Modèle 3: Naive Bayes
nb_model = GaussianNB()
nb_model.fit(X_train, y_train)
nb_pred = nb_model.predict(X_test)
print(f'Naive Bayes Accuracy: {accuracy_score(y_test, nb_pred):.2f}')

# Rapport de classification détaillé
print(classification_report(y_test, rf_pred))

from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Clustering - Grouper des données similaires
X = df[['feature1', 'feature2', 'feature3']]

# Normaliser les données
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means Clustering
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X_scaled)

# Ajouter les clusters au DataFrame
df['cluster'] = clusters

# Visualiser les clusters
plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=clusters, cmap='viridis')
plt.scatter(kmeans.cluster_centers_[:, 0], 
            kmeans.cluster_centers_[:, 1], 
            s=200, c='red', marker='X')
plt.title('K-Means Clustering')
plt.show()

# Réduction de dimensionnalité avec PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
print(f'Variance expliquée: {pca.explained_variance_ratio_}')

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.metrics import confusion_matrix, roc_auc_score, roc_curve

# Validation croisée
scores = cross_val_score(model, X_train, y_train, cv=5)
print(f'Score moyen: {scores.mean():.2f} (+/- {scores.std() * 2:.2f})')

# Matrice de confusion
cm = confusion_matrix(y_test, y_pred)
print('Matrice de confusion:')
print(cm)

# Courbe ROC (pour classification binaire)
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
roc_auc = roc_auc_score(y_test, y_pred_proba)
print(f'AUC-ROC: {roc_auc:.2f}')

# Optimisation des hyperparamètres
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7]
}
grid_search = GridSearchCV(
    RandomForestClassifier(), 
    param_grid, 
    cv=5, 
    scoring='accuracy'
)
grid_search.fit(X_train, y_train)
print(f'Meilleurs paramètres: {grid_search.best_params_}')

# Fonction simple (sans paramètres)
def dire_bonjour():
    print("Bonjour !")

dire_bonjour()  # Appel de la fonction

# Fonction avec paramètres
def saluer(nom):
    return f"Bonjour, {nom} !"

message = saluer("data-science")
print(message)  # "Bonjour, data-science !"

# Fonction avec plusieurs paramètres
def additionner(a, b):
    return a + b

resultat = additionner(5, 3)
print(resultat)  # 8

# Fonction avec paramètres par défaut
def saluer_personne(nom, message="Bonjour"):
    return f"{message}, {nom} !"

print(saluer_personne("Bassirou"))              # "Bonjour, Bassirou !"
print(saluer_personne("Bassirou", "Salut"))     # "Salut, Bassirou !"

# Fonction avec arguments nommés
def creer_personne(nom, age, ville="Dakar"):
    return f"{nom}, {age} ans, habite à {ville}"

print(creer_personne("Bassirou", 25))
print(creer_personne(age=25, nom="Bassirou", ville="Thiès"))

# Fonction avec *args (arguments variables)
def additionner_nombres(*args):
    return sum(args)

print(additionner_nombres(1, 2, 3, 4, 5))  # 15

# Fonction avec **kwargs (arguments nommés variables)
def afficher_info(**kwargs):
    for cle, valeur in kwargs.items():
        print(f"{cle}: {valeur}")

afficher_info(nom="Bassirou", age=25, ville="Dakar")

# Fonction lambda (fonction anonyme)
carre = lambda x: x ** 2
print(carre(5))  # 25

# Utilisation de lambda avec map()
nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x ** 2, nombres))
print(carres)  # [1, 4, 9, 16, 25]

import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
import plotly.graph_objects as go

# Graphique en ligne
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Graphique linéaire')
plt.show()

# Histogramme
data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
plt.hist(data, bins=5)
plt.xlabel('Valeurs')
plt.ylabel('Fréquence')
plt.title('Histogramme')
plt.show()

# Nuage de points avec Seaborn
sns.scatterplot(data=df, x='taille', y='poids', hue='categorie')
plt.title('Nuage de points')
plt.show()

# Graphique interactif avec Plotly
fig = px.scatter(df, x='taille', y='poids', color='categorie',
                 size='age', hover_data=['nom'])
fig.update_layout(title='Visualisation interactive')
fig.show()

# Heatmap de corrélation
correlation_matrix = df.corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Matrice de corrélation')
plt.show()

# Box plot
sns.boxplot(data=df, x='categorie', y='salaire')
plt.title('Distribution des salaires par catégorie')
plt.show()

# ========== LISTES ==========
# Création de listes
nombres = [1, 2, 3, 4, 5]
fruits = ["pomme", "banane", "orange"]
liste_mixte = [1, "deux", 3.0, True]

# Accès aux éléments (index commence à 0)
print(fruits[0])        # "pomme" (premier élément)
print(fruits[-1])      # "orange" (dernier élément)

# Modification
fruits[1] = "mangue"    # Remplacer "banane" par "mangue"

# Méthodes des listes
fruits.append("kiwi")           # Ajouter à la fin
fruits.insert(1, "ananas")      # Insérer à l'index 1
fruits.remove("pomme")          # Supprimer un élément
fruits.pop()                    # Supprimer le dernier élément
fruits.pop(0)                   # Supprimer l'élément à l'index 0

# Autres méthodes utiles
print(len(fruits))              # Longueur de la liste
print(fruits.count("banane"))   # Compter les occurrences
fruits.sort()                   # Trier la liste
fruits.reverse()                # Inverser la liste

# Slicing (tranches)
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nombres[2:5])     # [2, 3, 4] (de l'index 2 à 4)
print(nombres[:3])      # [0, 1, 2] (du début à l'index 2)
print(nombres[3:])      # [3, 4, 5, 6, 7, 8, 9] (de l'index 3 à la fin)
print(nombres[::2])     # [0, 2, 4, 6, 8] (tous les 2 éléments)

# ========== DICTIONNAIRES ==========
# Création de dictionnaires
personne = {
    "nom": "Bassirou",
    "age": 25,
    "ville": "Dakar"
}

# Accès aux valeurs
print(personne["nom"])          # "Bassirou"
print(personne.get("age"))      # 25 (méthode get() plus sûre)
print(personne.get("email", "Non renseigné"))  # Valeur par défaut

# Modification et ajout
personne["age"] = 26            # Modifier
personne["email"] = "bassirou@example.com"  # Ajouter

# Méthodes des dictionnaires
print(personne.keys())          # Toutes les clés
print(personne.values())        # Toutes les valeurs
print(personne.items())         # Toutes les paires clé-valeur

# Parcourir un dictionnaire
for cle, valeur in personne.items():
    print(f"{cle}: {valeur}")

# Supprimer
del personne["email"]           # Supprimer une clé
personne.pop("ville")           # Supprimer et retourner la valeur

# Big Data et Data Science - Traitement à grande échelle

# PySpark pour le traitement distribué
from pyspark.sql import SparkSession
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.regression import LinearRegression

spark = SparkSession.builder.appName("BigDataDS").getOrCreate()

# Lire de grandes quantités de données
df = spark.read.csv("hdfs://data/large_dataset.csv", 
                   header=True, inferSchema=True)

# Traitement distribué
result = df.groupBy("region").agg({"amount": "sum", "count": "count"})

# Machine Learning distribué
assembler = VectorAssembler(inputCols=["feature1", "feature2"], 
                           outputCol="features")
df_features = assembler.transform(df)

lr = LinearRegression(featuresCol="features", labelCol="target")
model = lr.fit(df_features)

# Dask pour le traitement parallèle en mémoire
import dask.dataframe as dd

# Lire un grand fichier CSV en chunks
df_dask = dd.read_csv("large_file.csv")

# Opérations paresseuses (lazy evaluation)
result = df_dask.groupby("category").amount.sum().compute()

# Vaex pour les très grands datasets (out-of-core)
import vaex

# Lire un fichier HDF5 ou CSV très volumineux
df_vaex = vaex.open("very_large_file.hdf5")

# Opérations rapides sur des milliards de lignes
result = df_vaex.groupby("category", agg={"amount": "sum"})

# Déploiement de modèles avec Flask/FastAPI
from flask import Flask, request, jsonify
import pickle
import pandas as pd

app = Flask(__name__)

# Charger le modèle entraîné
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    df = pd.DataFrame([data])
    prediction = model.predict(df)
    return jsonify({'prediction': prediction[0]})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

# Alternative avec FastAPI
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class PredictionRequest(BaseModel):
    feature1: float
    feature2: float
    feature3: float

@app.post('/predict')
def predict(request: PredictionRequest):
    df = pd.DataFrame([request.dict()])
    prediction = model.predict(df)
    return {'prediction': float(prediction[0])}

# Déploiement avec Docker
# Dockerfile:
# FROM python:3.9
# COPY requirements.txt .
# RUN pip install -r requirements.txt
# COPY app.py model.pkl .
# CMD ["python", "app.py"]

# Définir une classe
class Personne:
    # Constructeur (méthode spéciale __init__)
    def __init__(self, nom, age):
        self.nom = nom      # Attribut d'instance
        self.age = age
    
    # Méthode d'instance
    def se_presenter(self):
        return f"Je m'appelle {self.nom} et j'ai {self.age} ans"
    
    def avoir_ans(self, annees):
        self.age += annees
        return f"Dans {annees} ans, j'aurai {self.age} ans"

# Créer des objets (instances)
personne1 = Personne("Bassirou", 25)
personne2 = Personne("Aminata", 30)

# Utiliser les méthodes
print(personne1.se_presenter())
print(personne2.se_presenter())
print(personne1.avoir_ans(5))

# Accéder aux attributs
print(personne1.nom)
print(personne1.age)

# Classe avec attributs de classe
class Voiture:
    # Attribut de classe (partagé par toutes les instances)
    nombre_voitures = 0
    
    def __init__(self, marque, modele):
        self.marque = marque
        self.modele = modele
        Voiture.nombre_voitures += 1
    
    def __str__(self):
        return f"{self.marque} {self.modele}"

voiture1 = Voiture("Toyota", "Corolla")
voiture2 = Voiture("Honda", "Civic")
print(f"Nombre de voitures créées : {Voiture.nombre_voitures}")

# Héritage
class Etudiant(Personne):
    def __init__(self, nom, age, ecole):
        super().__init__(nom, age)  # Appeler le constructeur parent
        self.ecole = ecole
    
    def etudier(self):
        return f"{self.nom} étudie à {self.ecole}"

etudiant = Etudiant("Bassirou", 25, "UCAD")
print(etudiant.se_presenter())  # Méthode héritée
print(etudiant.etudier())       # Méthode spécifique

# Bibliothèques essentielles pour la Data Science

# Manipulation de données
import pandas as pd          # DataFrames et manipulation
import numpy as np           # Calculs numériques

# Visualisation
import matplotlib.pyplot as plt  # Graphiques de base
import seaborn as sns            # Visualisations statistiques
import plotly.express as px      # Graphiques interactifs

# Machine Learning
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, mean_squared_error

# Deep Learning
import tensorflow as tf
from tensorflow import keras
import torch
import torch.nn as nn

# Traitement de texte
import nltk
from nltk.tokenize import word_tokenize
from sklearn.feature_extraction.text import TfidfVectorizer

# Traitement d'images
from PIL import Image
import cv2

# Big Data
from pyspark.sql import SparkSession
import dask.dataframe as dd

# Outils de déploiement
import flask
import fastapi
import streamlit  # Pour créer des dashboards interactifs