NUMPY À PARTIR DE ZÉRO

1. Introduction
2. Pour commencer
3. Tableau Numpy
4. Remodelage de tableaux
5. Opérations arithmétiques
6. Indexation et découpage
7. Diffusion
8. Fonctions universelles (uFuncs)
9. Tri et recherche
10. Empilement et découpage de tableaux
11. Module aléatoire de Numpy
12. Algèbre linéaire avec Numpy
13. Aide-mémoire
rapide Remarques
finales
Verdict final

1. Introduction
Qu'est-ce que Numpy ?

NumPy (Numerical Python) est une bibliothèque Python utilisée pour effectuer des calculs
numériques rapides et efficaces avec des tableaux.

Pourquoi utiliser Numpy ?

NumPy est une bibliothèque Python qui vous permet de stocker, de manipuler et d'effectuer
efficacement des opérations mathématiques rapides sur de grands tableaux de nombres.

NUMPY FAIT MAISON 1

 À qui s'adresse-t-elle ?

NumPy s'adresse à tous ceux qui travaillent avec des données numériques en Python,
notamment :

Les data scientists – qui analysent des ensembles de données, calculent des statistiques
et préparent les données pour l'apprentissage automatique

Ingénieurs en apprentissage automatique / IA – gestion des tenseurs, des matrices

et des données d'entrée pour les modèles

Les scientifiques et chercheurs – qui réalisent des simulations et des expériences

Installation de NumPy

NumPy est préinstallé avec Anaconda/Jupyter. Il suffit de taper

ceci en haut de votre notebook :

import numpy as np

Vous êtes prêt à commencer.

Si vous n'avez pas Anaconda :

Ouvrez votre terminal ou votre invite de commande et exécutez :

Ensuite, importez-le de la même manière :

import numpy as np

Que signifie ? C'est juste un raccourci.

Vérifiez qu'il est bien installé :

Et pour vérifier qu'il est bien installé, vous pouvez ajouter ceci dans votre script dans votre
notebook Jupyter ou votre script Python ; nous y reviendrons plus tard, mais pour l'instant
:

import numpy as np
print(np. version )

#Exemple de résultat :
2.4.3

NUMPY FAIT MAISON 2

 Cela affichera la version que vous utilisez actuellement ; il se peut que ce ne soit pas la

2. Pour commencer
Importer NumPy :

Je sais que je l'ai déjà mentionné, mais c'est vraiment important : avant de pouvoir utiliser
NumPy, vous devez l'importer dans votre script Python. C'est la toute première chose à
faire pour commencer.

import numpy as np

C'est tout.

La partie n'est qu'un raccourci, ou plutôt un alias, pour qu'au lieu de taper à
chaque fois, il suffit de type np ..

numpy

Votre premier tableau NumPy :

Un tableau est simplement une liste de nombres avec laquelle NumPy peut travailler. Voici
comment en créer un :

import numpy as np
my_array = [Link]([10, 20, 30, 40, 50])
print(my_array)

Résultat :
[10 20 30 40 50]

Il s'agit de votre premier tableau numpy. Pour approfondir le sujet, nous allons examiner les
différents types de tableaux : les tableaux 1D, 2D et 3D.

import numpy as np
a = [Link]([10, 20, 30]) # Tableau 1D

NUMPY FAIT MAISON 3

 Cas d'utilisation : configuration d'un environnement NumPy pour un projet d'analyse de
données

Lorsqu'on démarre un projet d'analyse de données, NumPy est utilisé pour mettre en place un
environnement rapide et efficace permettant de travailler avec des données numériques.

Après avoir installé et importé NumPy, comme indiqué précédemment, vous chargez ou créez
votre ensemble de données sous forme de tableau NumPy de la manière suivante :

data = [Link]([10, 20, 30, 40, 50])

Et une fois les données dans un tableau, vous pouvez rapidement effectuer des opérations
comme celle-ci :

print([Link]()) # moyenne #
print([Link]()) total
print([Link]) # structure des données

3. Tableau Numpy
Création de tableaux :
Les tableaux Numpy peuvent être créés de plusieurs façons :

À partir d'une liste :

import numpy as np
arr1 = [Link]([1, 2, 3, 4])

Tableau 2D (matrice) :

import numpy as np

NUMPY FAIT MAISON 4

 arr2 = [Link]([[1, 2], [3, 4]])

Tableau 3D

import numpy as np a = [Link]([[[1, 2, 3], [1, 2, 3], [4, 5,

6]]])
[Link] #le résultat est 3

Plage de nombres :

est une fonction NumPy utilisée pour générer une séquence de nombres,
généralement pour les boucles.

import numpy as np
arr = [Link](1, 10, 2) #début #fin #pas arr
#résultat : est un tableau([1, 3, 5, 7,
9])

Linspace :

est une fonction NumPy utilisée pour créer des nombres régulièrement
espacés sur une plage spécifiée (crée des valeurs régulièrement espacées entre
deux points).

import numpy as np
arr = [Link](0, 1, 5) #début #fin #nombre de nombres à
générer
arr #résultat array([0. , 0.25, 0.5 , 0.75, 1.
]) :

Logspace :

est une fonction NumPy utilisée pour créer des valeurs espacées sur
une échelle logarithmique.

import numpy as np
arr = [Link](1, 3, 3) # tableau à échelle logarithmique ->
1 0^1 -> 10^3 .... 3 points
arr #résultat : tableau([ 10., 100., 1000.])

Zeros :
est une fonction NumPy utilisée pour créer un tableau rempli de 0.

NUMPY FAIT MAISON 5

 Ones :

est une fonction NumPy utilisée pour créer un tableau rempli de 1.

import numpy as np
arr = [Link]((2, 3))
arr #résultat :array([[1., 1., 1.],[1., 1., 1.]])

Full :

est une fonction NumPy utilisée pour créer un tableau d'une forme spécifiée
rempli avec la valeur de votre choix.

Elle est plus générale que ou .

import numpy as np
arr = [Link](10, 4) #tableau rempli de n'importe quelle
valeur
arr #Résultat : array([4, 4, 4, 4, 4, 4,
4, 4, 4, 4])

AUSSI
arr=[Link]([2,4],7) #deux lignes, quatre colonnes de
sept
[lignes, colonnes], valeur par défaut
tableau #tableau([[7, 7, 7, 7],[7, 7, 7,
7]])

Types de données des tableaux et conversion de types :

NUMPY FAIT MAISON 6

 Bon, rapidement, je vais vous montrer quelque chose et vous expliquer pourquoi c'est le
cas en ce qui concerne les types de données, alors accrochez-vous :

import numpy as np
arr = [Link]([1, 2, 3.1, 4, 5])

Autre exemple :

import numpy as np
arr = [Link]([1.1, 2.1, 3.1, 4.1, 5])
arr #array([1.1, 2.1, 3.1, 4.1, 5. ])

Encore un autre exemple :

import numpy as np arr = [Link](["book", 1, 2,

3, 4.6])
arr #array(['book', '1', '2', '3', '4.6'], dtype='<U3
2')

TYPE DE DONNÉES DESCRIPTION EXEMPLES DE VALEURS

Entier 32 bits (nombres

np.int32 -2, 0, 45, 100000
entiers)

Entier 64 bits (plage plus -5000000000, 42,

np.int64
large) 900000000000

Nombre à virgule flottante 32

np.float32 3,14, -0,5, 2,7
bits (décimales, moins de
précision)

Nombre à virgule flottante 64 3,1415926535,

np.float64
bits (plus précis, par défaut) -0,123456789

np.bool_ Booléen (vrai/faux) Vrai, Faux

np.str_ Chaîne de caractères « hello », « data »

(données textuelles)

Objets Python mixtes ou

np.object_ [1, « texte », 3,5]
complexes

Vous pouvez également modifier le type de données d'un tableau

NUMPY FAIT MAISON 7

 import numpy as np

arr = [Link]([1, 2.4, 3.1, 4, 5], dtype=np.int64)

[Link]

Conversion de type
Donc oui, dans NumPy, le transtypage (également appelé conversion de type de
données) est le processus qui consiste à changer le type de données d'un tableau pour en
attribuer un autre. Le transtypage peut entraîner une perte de données (par exemple, la
conversion d'un float en int supprime les décimales).

Conversion explicite de type :

import numpy as np

arr = [Link]([1, 2.4, 3.1, 4, 5])

print([Link]) # float64 (par défaut en raison des valeurs
2,4 et 3,1)

# Conversion en entiers
arr_int = [Link](np.int64)
print(arr_int) # [1 2 3 4 5]
print(arr_int.dtype) # int64

# Conversion en float32
arrfl32 = [Link](np.float32)
print(arrfl32) # [1. 2.4 3.1 4. 5.]
print([Link]) # float32

Conversion implicite de type :

arr1 = [Link]([1, 2, 3], dtype=int)

arr2 = [Link]([1.5, 2.5, 3.5], dtype=float)

result = arr1 + arr2

print(result) # [2.5 4.5 6.5]
print([Link]) # float64

NUMPY FAIT MAISON 8

 Erreur de conversion de type :

arr = [Link](["1", "2", "hello"]) # impossible de convertir

une chaîne de caractères en entier ou en nombre à virgule
flottante arr2 = [Link](np.int64)
arr2

Attributs du tableau :
Shape

Voici comment vérifier les dimensions du tableau ; renvoie un tuple représentant la taille
le long de chaque axe.

import numpy as np
arr = [Link]([[1, 2, 3], [4, 5, 6]])
print([Link]) #(2, 3) 2
lignes, 3 colonnes

Taille.

Cela donne le nombre total d'éléments et le produit (*) des dimensions

import numpy as np
print([Link]) 6 # 2*3

ndim

Cela donne le nombre de dimensions

*

print([Link]) 2 # Tableau 2D

dtype

NUMPY FAIT MAISON 9

 arr = [Link]([1, 2, 3], dtype=np.float32) print([Link])
#float32

4. Remodelage de tableaux
Dans NumPy, le remodelage d'un tableau consiste à modifier la forme (les dimensions) d'un
tableau sans en modifier les données.
NumPy propose trois méthodes principales pour y parvenir : reshap, ravel et flatten
,

Reshape :

modifie la structure d'un tableau sans en modifier le contenu et renvoie

également une vue (sans allouer de nouvelle mémoire) lorsque cela est possible ; vous devez
fournir une structure compatible avec le nombre d'éléments.

import numpy as np

arr = [Link]([[1, 2], [3, 4], [5, 6]])

# forme = (3,2) → nombre total d'éléments = 6

reshaped = [Link](2, 3) # nouvelle forme (2,3)

print(reshaped)
# [[1 2 3]
# [4 5 6]]

Ravel :

aplatit le tableau en un tableau 1D, renvoie une vue lorsque cela est possible
(les modifications apportées au tableau aplati peuvent affecter le tableau d'origine).

flat_view = [Link]() print(flat_view)

NUMPY FAIT MAISON 10

 # [1 2 3 4 5 6]

flat_view[0] = 100 print(arr)

# [100 2 ...] → le tableau d'origine est modifié car ravel
renvoie souvent une vue

Flatten :

est utilisé pour aplatir un tableau en 1D. Renvoie toujours une copie, de sorte que
le tableau d'origine n'est pas affecté.

flat_copy = [Link]() flat_copy[0] =

100
print(arr) # tableau d'origine inchangé
print(flat_copy) # premier élément modifié

5. Opérations arithmétiques
Cette section traite des calculs sur les tableaux Numpy. Les opérations sont vectorisées
(aucune boucle n'est nécessaire).

Opérations élément par , , , , ):

élément (

-Addition

-Soustraction

-Multiplication

-Division

-Division par étage

a = [Link]([1, 2, 3, 4, 5, 6])
b = [Link]([2, 3, 5, 3.1, 8, 9])

print(a+b) #[ 3. 5. 8. 7,1 13, 15. ]

print(a-b) #[-1. -1. -2. 0,9 -3, -3. ]
print(a/b) #[0,5 0,66666667 0,6 1,29032
258 0,625 0,66666667]

NUMPY FAIT MAISON 11

 print(a * b) #[ 2. 6,15 12,4 40, 54. ]
print(a // b) #[0. 0. 0. 1. 0. 0.]

Puissance et module :

Puissance (``) → élève les nombres

Module ( ) → donne le reste

print(b%a) #[0. 1. 2. 3,1 3. 3. ]

print(a ** 2) #[ 1 4 9 16 25 36]

arr = [Link]([1, 2, 3])

print([Link](arr)) #6
print([Link](arr)) #2,0
print([Link](arr)) #0,816496580927726
print([Link](arr)) #1

NUMPY FAIT MAISON 12

 print([Link](arr)) #3
print([Link](arr)) #0,6666666666666666

6. Indexation et découpage
L'indexation et le découpage vous permettent d'accéder à des éléments ou sous-tableaux
spécifiques d'un tableau NumPy, ou de les extraire. Cela s'apparente aux listes Python, mais
fonctionne également pour les tableaux multidimensionnels. L'indexation NumPy est plus
rapide et prend en charge l'accès multidimensionnel.

arr = [Link]([10, 20, 30, 40, 50, 60])

Indexation d'un tableau 1D :

import numpy as np

arr = [Link]([10, 20, 30, 40, 50])

# Accéder à un élément unique (indexation à

partir de 0) print(arr[0]) # 10
print(arr[3]) #40

Tranchage d'un tableau 1D :

Indexation d'un tableau 2D :

arr2d = [Link]([[1, 2, 3],

[4, 5, 6],
[7, 8, 9]])

# Accéder à un élément unique : arr2d[ligne, colonne]

NUMPY FAIT MAISON 13

 print(arr2d[0, 1]) # 2
print(arr2d[2, 2]) # 9

Tranchage d'un tableau 2D :

# Tronçonnage des lignes

print(arr2d[0:2, :]) # 2 premières lignes
# [[1 2 3]
# [4 5 6]]

# Tronçonnage des colonnes

print(arr2d[:, 1:3]) # 2 dernières colonnes
# [[2 3]
# [5 6]
# [8 9]]

# Extraire un sous- tableau

print(arr2d[1:3, 0:2])
# [[4 5]
# [7 8]]

Indexation booléenne (conditionnelle)

# Sélectionner des éléments en fonction

d'une condition print(arr[arr > 30]) #
[40 50]

Découpage multidimensionnel :

import numpy as np

matrix = [Link]([[1, 2, 3, 4],

[4, 5, 6, 7],
[7, 8, 9, 10]])

Modification des valeurs :

NUMPY FAIT MAISON 14

 Vous pouvez modifier les valeurs directement

arr = [Link]([10, 20, 30])

arr[1] = 100
print(arr) # [10 100 30]

Fonctionne également avec le découpage :

arr[0:2] = 0
print(arr) # [0 0 30]

Indexation avancée :

Une autre façon de sélectionner des éléments à l'aide d'indices.

arr = [Link]([10, 20, 30, 40])

print([Link](arr, [1, 3])) # [20 40]

Indexation avec plusieurs tableaux (spécifique au 2D) :

arr2d = [Link]([[1, 2],

[3, 4]])

print(arr2d[[0, 1], [1, 0]]) # [2 3]

7. Diffusion
La diffusion est une fonctionnalité de NumPy qui permet d'utiliser ensemble des tableaux de
formes différentes dans des opérations arithmétiques. Concrètement, NumPy étend
automatiquement le plus petit tableau pour qu'il corresponde à la forme du plus grand. La
diffusion évite la copie de données, ce qui rend les opérations plus efficaces en termes de
mémoire.

Règles de diffusion :

NumPy compare les formes élément par élément à partir de la dimension la plus à droite :

Si les dimensions sont égales, elles sont compatibles.

NUMPY FAIT MAISON 15

 Si une dimension est égale à 1, elle est étirée pour correspondre à l'autre.

Si les dimensions diffèrent et qu'aucune n'est égale à 1, le broadcasting échoue.

Diffusion scalaire simple

arr = [Link]([1, 2, 3, 4])

arr + 10 #[11,12,13,14] <------ 10 est diffusé
diffusé sur tous les éléments
arr * 2 #[2,4,6,8]
arr **2 #[1,4,9,16]

Diffusion 1D + scalaire

a = [Link]([1, 2, 3]) b
= 5
print(a + b) #[6,7,8]

#décomposition de la
forme :
#a ->(3,)
#b --->() <----- Scalaire étendu à (3,)

Tableau 2D + tableau 1D

matrix = [Link]([[1,2,3],[4,5,6]])
row = [Link]([10, 20, 30])

matrice + ligne
#[[11,22,33],[14,25,36]]

#Décomposition de la
forme :

NUMPY FAIT MAISON 16

 #matrice -----> (2,3)
#ligne ------> (3,) <------diffusion le long de l'axe 0

Diffusion de vecteurs de colonnes

matrix = [Link]([[1,2,3],[4,5,6]])
col = [Link]([10, 20])

matrice + col
#[[11,12,13],[24,25,26]]

#Décomposition de la forme
#matrice ->(2,3)
#col -> (2,1) <-----diffusion le long de l'axe 1

Exemple d'échec de diffusion

a = [Link]([[1, 2, #forme (1,3)

3]])
# forme (1,2)
b=[Link]([[1,2]])

a + b # ValueError : les opérandes ne peuvent pas être diffusés

#3 et 2 sont incompatibles (1 ne l'est pas non plus)

8. Fonctions universelles (uFuncs)

Les fonctions universelles (ufuncs) sont des fonctions NumPy qui opèrent élément par
élément sur des tableaux sans boucles explicites. Elles sont implémentées en code C
optimisé, ce qui les rend très rapides.

Fonctions mathématiques

import numpy as np

arr = [Link]([1, 4, 9, 16])

print([Link](arr)) # [1. 2. 3. 4.]

NUMPY FAIT MAISON 17

 Fonctions trigonométriques

import numpy as np

angles = [Link]([0, [Link] / 2, [Link]])

print([Link](angles)) # [0. 1. 0.] (environ)

print([Link](angles)) # [ 1. 0. -1.]
print([Link](angles)) # [0. grand 0.]

Arrondi

import numpy as np

arr = [Link]([1,2, 2,7, 3,5, -1,8])

print([Link](arr)) # [ 1. 2. 3. -2.] (toujours en bas

)
print([Link](arr)) # [ 2. 3. 4. -1.] (toujours en
)
print([Link](arr)) # [ 1. 3. 4. -2.] (tours à ne
)

Fonctions de comparaison

NUMPY FAIT MAISON 18

 Méthodes des ufuncs
Principales fonctionnalités

Opérations élément par élément

Prise en charge de la diffusion

Conversion de types

Opérations de réduction

Exemple :

[Link](arr) # additionne tous les éléments

Méthodes

→ réduit un tableau à une seule valeur

→ résultats cumulés

→ opérations par paires

→ opérations sur place

Exemple :

[Link](arr) # somme cumulative

Exemple

import numpy as np

arr1 = [Link]([1, 2, 3])

NUMPY FAIT MAISON 19

 arr2 = [Link]([4, 5, 6])

result = [Link](arr1, arr2)

print(result) # [5 7 9]

Point clé :
Les ufuncs sont des opérations vectorielles rapides sur des tableaux qui fonctionnent
sans boucles.

9. Tri et recherche
Tri
Le tri consiste à classer les valeurs par ordre croissant (par défaut) ou décroissant.

renvoie une nouvelle copie triée et laisse le tableau d'origine

inchangé.

trie le tableau d'origine sur place et renvoie le , modifie le

tableau d'origine ; ne renvoie pas de nouveau tableau.

import numpy as np

arr = [Link]([3, 1, 4, 1, 5, 9, 2, 6])

sorted_arr = [Link](arr)
print(sorted_arr) # [1 1 2 3 4 5 6 9]
print(arr) # [3 1 4 1 5 9 2 6] (inchangé)

[Link]()
print(arr) # [1 1 2 3 4 5 6 9] (modifié)

Tri décroissant
Une méthode courante consiste à trier par ordre croissant, puis à inverser le résultat :

import numpy as np

arr = [Link]([3, 1, 4, 1, 5])

# Ordre décroissant

NUMPY FAIT MAISON 20

 desc = [Link](arr)[::-1] print(desc) #
[5 4 3 1 1]

Tri de tableaux 2D (axe)

Dans les tableaux 2D, axis indique à NumPy la direction du tri :

→ trier chaque colonne (de haut en bas)

→ trier chaque ligne (de gauche à droite)

import numpy as np

mat = [Link]([[3, 1],

[2, 4]])

print([Link](mat, axis=0)) #
[[2 1]
# [3 4]]

print([Link](mat, axis=1)) #
[[1 3]
# [2 4]]

argsort (index permettant le tri)

renvoie les indices qui permettraient de trier le tableau, ce qui peut être
utilisé pour réorganiser le tableau.

import numpy as np

arr = [Link]([30, 10, 20])

idx = [Link](arr)
print(idx) # [1 2 0]
print(arr[idx]) # [10 20 30] (utiliser les indices
pour obtenir les
triées)

NUMPY FAIT MAISON 21

 Cas d'utilisation puissant : trier un tableau à l'aide d'un autre

import numpy as np

names = [Link](["A", "B", "C"])

scores = [Link]([70, 50, 90])

idx = [Link](scores)
print(noms[idx]) # ['B' 'A' 'C']

Recherche
Rechercher signifie trouver où se trouvent certaines valeurs (par index).

(trouver des indices ou choisir des valeurs)

peut être utilisé à la fois pour le filtrage et le remplacement

conditionnel. Renvoie les indices où la conditio est true

renvoie un tableau dont chaque élément est si

Vrai, sinon .

import numpy as np

arr = [Link]([10, 20, 30, 40, 50])

print([Link](arr > 25))

# (array([2, 3, 4]),)

print([Link](arr > 25, arr, 0))

# [ 0 0 30 40 50]

Exemple concret : remplacer les valeurs négatives par 0

import numpy as np

arr = [Link]([-1, 2, -3, 4])

print([Link](arr < 0, 0, arr)) # [0 2 0 4]

NUMPY FAIT MAISON 22

 et (index de min ou max)
renvoie l'index de la plus petite valeur.
renvoie l'index de la plus grande valeur.

import numpy as np

arr = [Link]([10, 20, 30, 40, 50])

print([Link](arr)) # 0 (10 est le plus

petit)
print([Link](arr)) # 4 (50 est le plus
grand)

Comportement important en 2D (index aplati vs axe)

import numpy as np

mat = [Link]([[1, 5],

[3, 2]])

print([Link](mat)) # 1 (aplatit)
print([Link](mat, axis=0)) # [1 0] (par colonne)
print([Link](mat, axis=1)) # [1 0] (par ligne)

[Link](s
f oarctuedltatif mais fortement recommandé)
Renvoie l'index auquel une valeur doit être insérée pour conserver l'ordre trié.

import numpy as np

arr = [Link]([10, 20, 30, 40])

print([Link](arr, 25)) # 2

10. Empilement et fractionnement de

tableaux
L'empilement combine des tableaux en un seul tableau plus grand.

Le fractionnement divise un tableau en plusieurs tableaux plus petits.

NUMPY FAIT MAISON 23

 Empilement (combinaison de tableaux)

import numpy as np

# Exemples en 1D
a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])

[Link]([a, b]) # [1 2 3 4 5 6]
[Link]([a, b]) # [[1 2 3],
# [4 5 6]]

[Link]([a, b]) # [1 2 3 4 5 6]

Quelle est la différence ?

joint les tableaux le long des colonnes (axe=1 pour le 2D)

joint les tableaux par lignes (axe = 0)

est la fonction générale qui vous permet de choisir l'

Empiler des tableaux 2D + utilisaexer

m1 = [Link]([[1, 2],
[3, 4]])

m2 = [Link]([[5, 6],
[7, 8]])

[Link]([m1, m2]) # [[1 2 5 6],

# [3 4 7 8]]

[Link]([m1, m2]) # [[1 2],

# [3 4],
# [5 6],
# [7 8]]

NUMPY FAIT MAISON 24

 [Link]([m1, m2], axis=0) k # identique à
[Link]([m1, m2], axis=1) vstac
k # identique à
hstac

(ajoute une nouvelle

[Link]()
dimension)
est différent de et car il crée un nouveau
axe.

[Link]([a, b], axis=0) # [[1 2 3],

# [4 5 6]]

[Link]([a, b], axis=1) # [[1 4],

# [2 5],
# [3 6]]

Fractionnement (division de tableaux)

# Tableau 1D
arr = [Link]([1, 2, 3, 4, 5, 6])

[Link](arr, 3) # [tableau([1, 2]), tableau([3,

4]), tableau([5, 6])]
[Link](arr, [2, 4]) # division aux indices 2 et 4
# -> [tableau([1, 2]), tableau
([3, 4]), tableau([5, 6])]

Division en 2D et

NUMPY FAIT MAISON 25

 divise les colonnes

divise les lignes

mat = [Link]([[1, 2, 3, 4],

[5, 6, 7, 8]])

print([Link]) # (2, 4)

[Link](mat, 2) # deux tableaux de forme (2, 2) [un

rray([[1, 2], [5, 6]]),array([[3, 4],[7, 8]])]

[Link](mat, 2) # deux tableaux de forme (1, 4) [

array([[1, 2, 3, 4]]),array([[5, 6, 7, 8]])]

11. Module aléatoire de Numpy

Le module est utilisé pour générer des nombres aléatoires, des tableaux et
à partir de distributions de probabilité.

Définition d'une graine : pour vous assurer que vos résultats sont les mêmes à
chaque exécution de votre code, utilisez une graine aléatoire.

import numpy as np
rng = [Link].default_rng(42) # recommandé moderne a
pproach

Fonctions aléatoires courantes :

Distribution uniforme (0 à 1) :

[Link](3) # Tableau 1D
[Link]((2, 3)) # Matrice 2×3

NUMPY FAIT MAISON 26

 Distribution normale standard :

rng.standard_normal(4)

Nombres entiers aléatoires :

[Link](1, 10, 5)

Sélection aléatoire :

[Link]([10, 20, 30, 40], size=3)

Mélange de tableaux :

arr = [Link]([1, 2, 3, 4, 5])

[Link](arr) # modifie le tableau

print(arr) d'origine

Mélange vs permutation

[Link](arr) # renvoie un nouveau tableau mélangé

Distributions de probabilité :

Distribution normale :

[Link](loc=0, scale=1, size=5)

Distribution uniforme :

[Link](low=0, high=10, size=5)

Distribution binomiale

NUMPY FAIT MAISON 27

 [Link](n=10, p=0,5, taille=5)

Ancienne méthode Nouvelle méthode

[Link]() [Link]()

[Link]() rng.standard_normal()

[Link]() [Link]()

[Link]() [Link]()

12. Algèbre linéaire avec Numpy

NumPy fournit un puissant module d'algèbre linéaire, , utilisé pour les
matrices
dans le domaine de l'apprentissage automatique, de la science des données et de l'ingénierie.

Multiplication matricielle :

La multiplication matricielle combine deux tableaux selon les règles de l'algèbre

linéaire (et non élément par élément).

import numpy as np

A = [Link]([[1, 2],
[3, 4]])

B = [Link]([[5, 6],
[7, 8]])

[Link](A, B)
# [[19 22]
# [43 50]]

A @ B # syntaxe moderne recommandée

Transposer

[Link](A) #
[[-2. 1. ]

NUMPY FAIT MAISON 28

 # [ 1,5 -0,5]]

La transposition inverse les lignes en colonnes.

A = [Link]([[1, 2, 3],
[4, 5, 6]])

A.T
# [[1 4]
# [2 5]
# [3 6]]

Déterminant et inverse

Déterminant

Le déterminant est une valeur scalaire qui décrit les propriétés d'une matrice (par
exemple, l'inversibilité).

A = [Link]([[1, 2],
[3, 4]])

[Link](A) # -2,0

Inverse

L'inverse d'une matrice sert à résoudre des équations linéaires.

Valeurs propres et vecteurs propres

Les valeurs propres et les vecteurs propres décrivent la manière dont une matrice
transforme l'espace.

A = [Link]([[4, 2],
[1, 3]])

valeurs propres, vecteurs propres =

[Link](A)

print(valeurs propres) # [5, 2]

print(vecteurs # les colonnes sont des
propres) vecteurs propres

NUMPY FAIT MAISON 29

 Résolution d'un système linéaire

Résolvez l'équation : Ax = b

# Résolution d'un système d'équations

: # 2x + y = 8
# x + 3y = 13

A = [Link]([[2, 1],
[1, 3]])

b = [Link]([8, 13])

[Link](A, b) # [3. 2.]

Remarques importantes
La multiplication matricielle n'est pas élément par élément (utiliser pour la
multiplication élément par élément)

Utilise@z pour la multiplication matricielle

les fonctions nécessitent des formes compatibles

Toutes les matrices n'ont pas d'inverse (le déterminant ne doit pas être nul)

Préfé[Link]() à

13. Aide-mémoire rapide

Catégorie Tâche Code

Configuration Importer NumPy import numpy as np

Tableaux Créer un tableau 1D [Link]([1, 2, 3])

Créer un tableau 2D [Link]([[1, 2], [3, 4]])

Tableau de zéros [Link]((2, 3))

Tableau de 1 [Link]((2, 3))

Tableau de valeurs [Link](0, 10, 2)

comprises entre
Espacement régulier [Link](0, 1, 5)

NUMPY FAIT MAISON 30

 Catégorie Tâche Code

Informations sur le tableau Forme [Link]

Taille [Link]

Dimensions [Link]

Type de données [Link]

Remodelage Remodelage [Link](2, 3)

Aplatir (copier) [Link]()

Aplatir (vue) [Link]()

Transposer arr.T

[Link](arr), [Link](arr),
Opérations Somme / Moyenne / [Link](arr)
mathématiques Écart-type
Min / Max [Link](arr), [Link](arr)

Index des valeurs [Link](arr), [Link](arr)

minimales et maximales
Tri et filtrage Trier [Link](arr)

Argsort (indices) [Link](arr)

Condition [Link](arr > 5)

Filtrage booléen arr[arr > 5]

Empilement et jointure Empilement vertical [Link]([a, b])

Empilement horizontal [Link]([a, b])

Concaténation [Link]([a, b])

Gestion des types Conversion de type [Link](np.float32)

Algèbre linéaire Multiplication A @ B

matricielle
Inverse [Link](A)

Déterminant [Link](A)

Résoudre Ax = b [Link](A, b)

Aléatoire (API
Créer un générateur rng = [Link].default_rng(42)
moderne)

Nombres flottants [Link](3)

aléatoires [0,1)
Nombres entiers [Link](0, 10, 5)
aléatoires
Choix aléatoire [Link]([1,2,3], size=2)

Mélange (sur place) [Link](arr)

NUMPY FAIT MAISON 31

 Permutation (copie) [Link](arr)

Catégorie Tâche Code

Distributions Distribution normale [Link](0, 1, size=5)

Distribution uniforme [Link](0, 10, size=5)

Distribution [Link](n=10, p=0,5, size=5)

binomiale

Remarques finales
Utilise les pratiques NumPy modernedse(fault_rng )

Couvre les concepts de base, intermédiaires et avancés importants

Structuré pour une révision rapide et une utilisation concrète

Verdict final
NumPy est une bibliothèque fondamentale pour le calcul numérique en Python et sert de pilier
aux workflows de science des données, d'apprentissage automatique et de calcul
scientifique.

Grâce à ce guide, j'ai appris à :

Créer et manipuler efficacement des tableaux

Effectuer des opérations vectorisées rapides sans boucles

Remodeler et transformer les structures de données

Appliquez la diffusion pour des opérations sur des structures de formes différentes

Utilisez des outils puissants tels que le tri, la recherche, l'empilement et le fractionnement

Générer des données aléatoires et travailler avec des distributions de probabilité

Appliquer des concepts d'algèbre linéaire tels que la multiplication matricielle,

l'inversion et la résolution de systèmes d'équations

L'un des points clés à retenir est que NumPy ne se limite pas aux tableaux, mais permet d'écrire
du code efficace, évolutif et optimisé pour résoudre des problèmes concrets liés aux
données.

Je comprends également l'importance de :

Utiliser des opérations vectorisées plutôt que des boucles

Écrire du code économe en mémoire

NUMPY FAIT MAISON 32

 Tirer parti de NumPy comme base pour des bibliothèques telles que Pandas,
TensorFlow et PyTorch

À l'avenir, la prochaine étape consiste à :

Appliquer NumPy à des ensembles de données réels (Pandas)

L'utiliser dans des workflows d'apprentissage automatique

Construire de petits projets qui renforcent ces concepts

En résumé :

NumPy est un outil essentiel qui transforme Python en un environnement hautement

performant pour le calcul numérique, et sa maîtrise est une étape cruciale pour devenir un data
scientist ou un ingénieur en IA compétent.

NUMPY FAIT MAISON 33