1. A propos du module numpy.lib
Le module numpy.lib est une sous-bibliothèque de NumPy qui contient des fonctions utilitaires et des outils supplémentaires qui ne font pas partie du noyau principal de NumPy. Ces fonctions sont souvent spécialisées et fournissent des fonctionnalités avancées pour la manipulation de tableaux, le formatage, l'indexation, et d'autres opérations complémentaires. Bien que moins connu que le module principal numpy, numpy.lib est très utile pour des tâches spécifiques en science des données et calcul numérique.
2. Fonctions d'indexation et de découpage avancées
Le module numpy.lib offre des fonctions spécialisées pour l'indexation et le découpage des tableaux NumPy qui vont au-delà des fonctionnalités de base.
La fonction stride_tricks.as_strided
Cette fonction permet de créer des vues sur un tableau avec des pas (strides) personnalisés, ce qui est utile pour des opérations de fenêtrage ou de convolution sans copie de données.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import numpy as np from numpy.lib.stride_tricks import as_strided # Création d'un tableau simple arr = np.array([1, 2, 3, 4, 5, 6], dtype=np.int32) # Création d'une vue avec fenêtres glissantes shape = (4, 3) # 4 fenêtres de taille 3 strides = (arr.strides[0], arr.strides[0]) # Pas en octets windowed_view = as_strided(arr, shape=shape, strides=strides) print("Tableau original :", arr) print("\nVue fenêtrée (shape {}):".format(shape)) print(windowed_view) print("\nLes données ne sont pas copiées :", windowed_view.base is arr) |
Sortie :
|
1 2 3 4 5 6 7 8 9 |
Tableau original : [1 2 3 4 5 6] Vue fenêtrée (shape (4, 3)): [[1 2 3] [2 3 4] [3 4 5] [4 5 6]] Les données ne sont pas copiées : True |
La fonction index_tricks
Ce sous-module contient des outils comme r_ et c_ pour la construction rapide de tableaux.
|
1 2 3 4 5 6 7 8 9 10 |
from numpy.lib.index_tricks import r_, c_ # Construction rapide de vecteurs vecteur = r_[1:10:2, 15, 20:25] # Combinaison de plages et valeurs print("Vecteur construit avec r_ :", vecteur) # Construction de matrices colonnes colonne = c_[1:5, 10:14] print("\nMatrice colonne construite avec c_ :") print(colonne) |
Sortie :
|
1 2 3 4 5 6 7 |
Vecteur construit avec r_ : [ 1 3 5 7 9 15 20 21 22 23 24] Matrice colonne construite avec c_ : [[ 1 10] [ 2 11] [ 3 12] [ 4 13]] |
3. Fonctions de formatage et d'affichage
numpy.lib propose des outils pour le formatage des tableaux NumPy, particulièrement utiles pour l'affichage ou la génération de rapports.
La fonction format
Le module format contient des fonctions pour formater les tableaux NumPy de manière lisible.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
from numpy.lib import format # Création d'un tableau arr = np.random.rand(3, 3) # Formatage avec différentes options print("Formatage par défaut :") print(format.array_repr(arr)) print("\nFormatage avec précision réduite :") print(format.array_repr(arr, precision=2)) # Affichage d'un tableau plus grand avec limitation de lignes arr_large = np.arange(12).reshape(4, 3) print("\nTableau complet :") print(arr_large) print("\nReprésentation formatée avec max_line_width :") print(format.array_repr(arr_large, max_line_width=30)) |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
Formatage par défaut : array([[0.5488135 , 0.71518937, 0.60276338], [0.54488318, 0.4236548 , 0.64589411], [0.43758721, 0.891773 , 0.96366276]]) Formatage avec précision réduite : array([[0.55, 0.72, 0.6 ], [0.54, 0.42, 0.65], [0.44, 0.89, 0.96]]) Tableau complet : [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] Représentation formatée avec max_line_width : array([[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11]]) |
4. Fonctions de manipulation de type et utilitaires
Ces fonctions permettent de manipuler les types de données et d'effectuer des opérations utilitaires sur les tableaux.
Recherche de type commun
NumPy propose plusieurs façons de trouver des types de données compatibles entre différents tableaux.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import numpy as np # Tableaux avec différents types arr_int = np.array([1, 2, 3], dtype=np.int32) arr_float = np.array([1.5, 2.5, 3.5], dtype=np.float64) # Trouver le type commun via promotion de type resultat_operation = arr_int + arr_float print("Résultat de l'addition int32 + float64 :", resultat_operation) print("Type du résultat :", resultat_operation.dtype) # Vérification du type de résultat attendu print("\nTypes individuels :") print("Type de arr_int :", arr_int.dtype) print("Type de arr_float :", arr_float.dtype) # Utilisation de result_type pour prédire le type type_predit = np.result_type(arr_int, arr_float) print("\nType prédit par np.result_type :", type_predit) |
Sortie :
|
1 2 3 4 5 6 7 8 |
Résultat de l'addition int32 + float64 : [2.5 4.5 6.5] Type du résultat : float64 Types individuels : Type de arr_int : int32 Type de arr_float : float64 Type prédit par np.result_type : float64 |
Fonctions mathématiques étendues
NumPy fournit des fonctions mathématiques qui gèrent correctement différents types numériques.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import numpy as np # Calcul avec différents types numériques valeurs_int = np.array([4, 9, 16], dtype=np.int32) valeurs_float = np.array([4.0, 9.0, 16.0]) # Racines carrées avec gestion automatique des types racines_int = np.sqrt(valeurs_int) racines_float = np.sqrt(valeurs_float) print("Racines carrées de valeurs int32 :", racines_int) print("Type des résultats :", racines_int.dtype) print("\nRacines carrées de valeurs float64 :", racines_float) print("Type des résultats :", racines_float.dtype) # Mélange de types dans une opération melange = valeurs_int + valeurs_float print("\nMélange int32 + float64 :", melange) print("Type du mélange :", melange.dtype) |
Sortie :
|
1 2 3 4 5 6 7 8 |
Racines carrées de valeurs int32 : [2. 3. 4.] Type des résultats : float64 Racines carrées de valeurs float64 : [2. 3. 4.] Type des résultats : float64 Mélange int32 + float64 : [ 8. 18. 32.] Type du mélange : float64 |
5. Utilitaires de fichiers et d'E/S
numpy.lib contient des fonctions utilitaires pour la manipulation de fichiers et les opérations d'entrée/sortie spécifiques aux tableaux NumPy.
Chargement avec genfromtxt
La fonction genfromtxt est puissante pour charger des données textuelles avec de nombreuses options.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
from numpy.lib import npyio import io # Données texte avec valeurs manquantes data_text = """A,B,C,D 1,2,3,4 5,,7,8 9,10,11,12""" # Utilisation de StringIO pour simuler un fichier fichier_simule = io.StringIO(data_text) # Chargement avec gestion des valeurs manquantes donnees = npyio.genfromtxt(fichier_simule, delimiter=',', skip_header=1, filling_values=-999) print("Données chargées avec gestion des valeurs manquantes :") print(donnees) print("\nType des données :", donnees.dtype) # Version avec noms de colonnes fichier_simule.seek(0) # Retour au début du "fichier" donnees_nommes = npyio.genfromtxt(fichier_simule, delimiter=',', names=True, filling_values=-999) print("\nDonnées avec noms de colonnes :") print(donnees_nommes) print("\nNoms des colonnes :", donnees_nommes.dtype.names) |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 |
Données chargées avec gestion des valeurs manquantes : [[ 1. 2. 3. 4.] [ 5. -999. 7. 8.] [ 9. 10. 11. 12.]] Type des données : float64 Données avec noms de colonnes : [(1., 2., 3., 4.) (5., -999., 7., 8.) (9., 10., 11., 12.)] Noms des colonnes : ('A', 'B', 'C', 'D') |
6. Fonctions spécialisées et cas d'usage avancés
Génération de suites de nombres
NumPy offre plusieurs fonctions pour générer des séquences de nombres avec différents espacements.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import numpy as np # Génération de points linéairement espacés points_lineaires = np.linspace(0, 10, 5) print("Points linéairement espacés (0 à 10, 5 points) :", points_lineaires) # Génération de points logarithmiquement espacés points_log = np.logspace(1, 3, 5) # 10^1 à 10^3 print("\nPoints logarithmiquement espacés (10^1 à 10^3, 5 points) :", points_log) print("Log10 de ces points :", np.log10(points_log)) # Génération de grilles 2D x = np.array([1, 2, 3]) y = np.array([4, 5, 6]) X, Y = np.meshgrid(x, y) print("\nGrille X :") print(X) print("\nGrille Y :") print(Y) |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Points linéairement espacés (0 à 10, 5 points) : [ 0. 2.5 5. 7.5 10. ] Points logarithmiquement espacés (10^1 à 10^3, 5 points) : [ 10. 31.6227766 100. 316.22776602 1000. ] Log10 de ces points : [1. 1.5 2. 2.5 3. ] Grille X : [[1 2 3] [1 2 3] [1 2 3]] Grille Y : [[4 4 4] [5 5 5] [6 6 6]] |
Histogramme 2D
Pour l'analyse de distributions jointes de données.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import numpy as np # Génération de données corrélées np.random.seed(42) n_points = 1000 x = np.random.randn(n_points) y = 0.5 * x + np.random.randn(n_points) * 0.5 # Calcul de l'histogramme 2D hist, xedges, yedges = np.histogram2d(x, y, bins=10) print("Shape de l'histogramme 2D :", hist.shape) print("\nCompte total dans l'histogramme :", hist.sum()) print("Devrait être égal à n_points :", n_points) # Affichage d'une partie de l'histogramme print("\nPremières lignes de l'histogramme (5x5) :") print(hist[:5, :5]) print("\nBords des bins en X (premiers 6) :", xedges[:6]) print("Bords des bins en Y (premiers 6) :", yedges[:6]) |
Sortie :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Shape de l'histogramme 2D : (10, 10) Compte total dans l'histogramme : 1000.0 Devrait être égal à n_points : 1000 Premières lignes de l'histogramme (5x5) : [[ 5. 3. 0. 0. 0.] [ 7. 23. 17. 2. 0.] [ 1. 18. 58. 33. 2.] [ 0. 4. 38. 93. 47.] [ 0. 1. 6. 58. 94.]] Bords des bins en X (premiers 6) : [-3.50177459 -2.7691446 -2.03651461 -1.30388462 -0.57125463 0.16137536] Bords des bins en Y (premiers 6) : [-2.55013886 -2.00962864 -1.46911842 -0.9286082 -0.38809798 0.15241224] |
Younes Derfoufi
CRMEF OUJDA
