Introduction aux Bibliothèques Data Science avec Python

"""
Exemple de module, test
"""

exemple_variable = 3

def exemple_fonction():
    """Exemple de fonction"""
    return 0

class ExempleClasse:
    """Exemple de classe"""
    def __str__(self):
        return "ExempleClasse"

import numpy as np

# Vérifier la version installée
print(f"Version de NumPy : {np.__version__}")

import numpy as np

print(f"Pi : {np.pi}")       # 3.141592653589793
print(f"Euler (e) : {np.e}") # 2.718281828459045
print(f"Infini : {np.inf}")   # inf (Infinity)
print(f"NaN : {np.nan}")       # nan (Not a Number - Valeur manquante)

import numpy as np

# Vecteur (1 Dimension)
liste_notes = [10, 15, 20]
arr_1d = np.array(liste_notes)
print("1D :", arr_1d)

# Matrice (2 Dimensions)
liste_2d = [[1, 2, 3], [4, 5, 6]]
arr_2d = np.array(liste_2d)
print("2D :\n", arr_2d)

import numpy as np

# Tableau de 5 zéros (souvent utilisé pour l'initialisation)
z = np.zeros(5, dtype=int)
print("Zeros :", z)

# Matrice 2x3 remplie de 1 (float par défaut)
o = np.ones((2, 3))
print("Ones :\n", o)

# Matrice 2x2 remplie de 7
f = np.full((2, 2), 7)
print("Full :\n", f)

# Matrice Identité (carrée avec des 1 sur la diagonale)
i = np.eye(3)
print("Identité :\n", i)

import numpy as np

# np.arange(début, fin, pas) - Comme range() mais renvoie un tableau
# Note : la fin est EXCLUE
seq1 = np.arange(0, 10, 2)
print("Arange :", seq1) # [0 2 4 6 8]

# np.linspace(début, fin, nombre_points)
# Note : la fin est INCLUSE. Très utile pour les graphiques.
seq2 = np.linspace(0, 1, 5)
print("Linspace :", seq2) # [0.   0.25 0.5  0.75 1.  ]

import numpy as np

# Fixer la graine pour avoir toujours les mêmes résultats (reproductibilité)
np.random.seed(42)

# 3 nombres aléatoires entre 0 et 1 (Distribution uniforme)
rand_uni = np.random.random(3)
print("Uniforme :", rand_uni)

# Matrice 2x2 d'entiers entre 0 et 10 (exclu)
rand_int = np.random.randint(0, 10, (2, 2))
print("Entiers :\n", rand_int)

# Distribution Normale (Gaussienne) : Moyenne=0, Écart-type=1
rand_norm = np.random.normal(0, 1, 5)
print("Normale :", rand_norm)

import numpy as np

arr = np.array([10, 20, 30, 40])

print(arr[0])   # 10 (Premier élément)
print(arr[-1])  # 40 (Dernier élément)

# Modification
arr[1] = 99
print(arr)      # [10 99 30 40]

import numpy as np

x = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]

print(x[:5])      # [0 1 2 3 4] (5 premiers)
print(x[5:])      # [5 6 7 8 9] (À partir de l'index 5)
print(x[4:7])     # [4 5 6] (De 4 inclus à 7 exclu)
print(x[::2])     # [0 2 4 6 8] (Un élément sur deux)
print(x[::-1])    # [9 8 ... 0] (Inverser le tableau)

import numpy as np

M = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
])

# Accéder à un élément précis (Ligne 1, Colonne 2)
# Rappel : les indices commencent à 0
print(M[1, 2])    # 7

# Extraire une ligne entière (Ligne 0)
print(M[0, :])    # [1 2 3 4] (ou simplement M[0])

# Extraire une colonne entière (Colonne 1)
print(M[:, 1])    # [2 6 10]

# Extraire un sous-bloc (2 premières lignes, 2 premières colonnes)
print(M[:2, :2])
# [[1 2]
#  [5 6]]

import numpy as np

# Créer un vecteur de 12 éléments
x = np.arange(1, 13)
print("Original :", x)

# Transformer en matrice 3 lignes x 4 colonnes
mat = x.reshape((3, 4))
print("3x4 :\n", mat)

# Astuce : Utiliser -1 pour que NumPy calcule la dimension manquante
col = x.reshape((-1, 1)) # "Autant de lignes que nécessaire, 1 colonne"
print("Colonne :\n", col)

import numpy as np

x = np.arange(16).reshape(4, 4)

# vsplit : Coupe horizontalement (sépare les lignes)
haut, bas = np.vsplit(x, 2)
print("Haut :\n", haut)

# hsplit : Coupe verticalement (sépare les colonnes)
gauche, droite = np.hsplit(x, 2)
print("Gauche :\n", gauche)

# split : Générique (ici axis=1 équivaut à hsplit)
p1, p2 = np.split(x, 2, axis=1)

import numpy as np

M = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Supprimer la ligne 1 (axis=0)
M_sans_L1 = np.delete(M, 1, axis=0)

# Supprimer la colonne 2 (axis=1)
M_sans_C2 = np.delete(M, 2, axis=1)

import numpy as np

arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])

# np.sort() : Renvoie une copie triée (l'original ne change pas)
trie = np.sort(arr)
print(trie) # [1 2 3 4 5 6 7 8]

# Tri en place (modifie l'original)
arr.sort()

import numpy as np

a = np.arange(4) # [0 1 2 3]

print("a     =", a)
print("a + 4 =", a + 4)  # [4 5 6 7]
print("a * 2 =", a * 2)  # [0 2 4 6]
print("a ** 2=", a ** 2) # [0 1 4 9]

import scipy
import numpy as np

print(f"Version de SciPy : {scipy.__version__}")

import numpy as np

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

# Sauvegarder
np.save('mon_tableau.npy', arr)

# Charger
loaded_arr = np.load('mon_tableau.npy')
print(loaded_arr)

from scipy import io
import numpy as np

# Créer un dictionnaire de données
data = {'vecteur': np.array([1, 2, 3]), 'label': 'expérience 1'}

# Sauvegarder au format MATLAB (.mat)
io.savemat('data.mat', data)

# Recharger
mat_data = io.loadmat('data.mat')
print(mat_data['vecteur'])

import pandas as pd

# Création d'une Série simple
data = pd.Series([0.25, 0.50, 0.75, 1.0])

print(data)
# 0    0.25
# 1    0.50
# 2    0.75
# 3    1.00
# dtype: float64

print("Valeurs :", data.values) # [0.25 0.5 0.75 1. ]
print("Index   :", data.index)  # RangeIndex(start=0, stop=4, step=1)

# Création à partir d'un dictionnaire
population_dict = {
    'Casablanca': 6200000,
    'Rabat': 1200000,
    'Marrakech': 950000,
    'Fès': 1100000
}
population = pd.Series(population_dict)

print(population)
# Casablanca    6200000
# Rabat         1200000
# ...

# 1. Créons une deuxième série (Superficie)
area_dict = {
    'Casablanca': 1615,
    'Rabat': 118,
    'Marrakech': 230,
    'Fès': 240
}
area = pd.Series(area_dict)

# 2. Assemblons le tout dans un DataFrame
data = pd.DataFrame({
    'population': population,
    'superficie': area
})

print(data)
#             population  superficie
# Casablanca     6200000        1615
# Rabat          1200000         118
# Marrakech       950000         230
# Fès            1100000         240

print(data.index)
# Index(['Casablanca', 'Rabat', 'Marrakech', 'Fès'], dtype='object')

print(data.columns)
# Index(['population', 'superficie'], dtype='object')

print(data.values)
# [[6200000    1615]
#  [1200000     118] ... ]

# Les 2 premières lignes
print(data.head(2))

# Les dimensions
print(data.shape) 
# (4, 2) -> 4 lignes, 2 colonnes

# Infos techniques
data.info()
# class 'pandas.core.frame.DataFrame'
# Index: 4 entries, Casablanca to Fès
# Data columns (total 2 columns): ...

# --- EXEMPLE AVEC .LOC ---
# Sélectionner le salaire de Alice
print(df_employes.loc['Alice', 'Salaire']) # 45000

# Sélectionner de Alice à Charlie, colonnes Departement et Ville
print(df_employes.loc['Alice':'Charlie', ['Departement', 'Ville']])

# --- EXEMPLE AVEC .ILOC ---
# Sélectionner la 2ème ligne (Bob), 3ème colonne (Salaire) -> Index 1, 2
print(df_employes.iloc[1, 2]) # 60000

# Sélectionner les 3 premières lignes et les 2 dernières colonnes
print(df_employes.iloc[0:3, -2:])

# 1. Créer un masque (Filtre)
# Qui gagne plus de 50 000 ?
masque_salaire = df_employes['Salaire'] > 50000

# 2. Appliquer le masque
riches = df_employes[masque_salaire]
print(riches)
# Affiche Bob, Charlie, David

# 3. Conditions multiples (Et=&, Ou=|)
# Salaire > 50000 ET Ville est Paris
top_paris = df_employes[(df_employes['Salaire'] > 50000) & (df_employes['Ville'] == 'Paris')]

# 1. Identifier les manques
print(df.isnull().sum())
# Age: 1, Salaire: 1

# 2. Stratégie radicale : Supprimer les lignes avec au moins un NaN
df_clean = df.dropna()

# 3. Stratégie douce : Remplacer (Imputation)
# Remplir l'âge manquant par la moyenne des âges
age_moyen = df['Age'].mean()
df['Age'] = df['Age'].fillna(age_moyen)

# Remplir le salaire par 0 ou une valeur fixe
df['Salaire'] = df['Salaire'].fillna(0)

# Vérifier les doublons complets (toutes les colonnes identiques)
print(df.duplicated())

# Supprimer les doublons (garde la première occurrence par défaut)
df = df.drop_duplicates()

# Supprimer basé sur une seule colonne (ex: Nom unique)
df.drop_duplicates(subset=['Nom'], keep='last')

# Deux équipes de vente
equipe_A = pd.DataFrame({'Vendeur': ['A1', 'A2'], 'Vente': [100, 200]})
equipe_B = pd.DataFrame({'Vendeur': ['B1'], 'Vente': [50]})

# Rassembler tout le monde (axe 0 par défaut = vertical)
total = pd.concat([equipe_A, equipe_B], ignore_index=True)

print(total)
#   Vendeur  Vente
# 0      A1    100
# 1      A2    200
# 2      B1     50

# Inner Join : Charlie va disparaître (Dept 99 inconnu)
print(pd.merge(df_staff, df_depts, on='Dept_ID', how='inner'))

# Left Join : Charlie reste, mais Nom_Dept sera NaN
print(pd.merge(df_staff, df_depts, on='Dept_ID', how='left'))

# 1. Grouper par Département
groupes = df_employes.groupby('Departement')

# 2. Appliquer une agrégation (Moyenne sur le Salaire)
moyennes = groupes['Salaire'].mean()

print(moyennes)
# Departement
# Finance      52000.0
# IT           59000.0
# ...

# Plusieurs métriques d'un coup
stats = df_employes.groupby('Departement')['Salaire'].agg(['mean', 'max', 'count'])

# 1. Vers CSV (Le classique)
# index=False évite d'écrire la colonne d'index (0, 1, 2...) dans le fichier
df.to_csv('resultat_final.csv', index=False, sep=',')

# 2. Vers Excel
df.to_excel('bilan_2024.xlsx', sheet_name='Bilan')

# 3. Vers JSON (Pour le web)
df.to_json('data.json', orient='records', indent=4)

# Somme cumulée des ventes au fil du temps
df_ventes = df_ventes.sort_values('Date')
df_ventes['Cumul'] = df_ventes['Montant'].cumsum()

print(df_ventes[['Date', 'Montant', 'Cumul']])

import matplotlib.pyplot as plt
import numpy as np

# 1. Création des données
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 2. Création du tracé (Line plot)
plt.plot(x, y, label='Sinus', color='blue')

# Ajout de titres et légendes
plt.title("Mon Premier Graphique")
plt.xlabel("Axe X")
plt.ylabel("Axe Y")
plt.legend()

# 3. Affichage
plt.show()

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

# Générer des données suivant une loi normale
data = np.random.normal(size=1000)

# Création du graphique (histplot)
# kde=True ajoute la courbe de densité
sns.histplot(data, kde=True, color='teal')

plt.title("Distribution Normale avec Seaborn")
plt.show()

import nltk
from nltk.tokenize import word_tokenize

# Note : Il faut parfois télécharger les ressources NLTK au préalable
# nltk.download('punkt')

sentence = "L'OFPPT a développé au cours de la dernière décennie une coopération fructueuse avec de nombreux pays. Une politique volontariste qui s'est concrétisée par des projets allant de missions d'assistance technique, la formation, jusqu'à l'amélioration des compétences des formateurs."

tokens = word_tokenize(sentence)

print(tokens)