La fonction np.dot() nous permet de réaliser un produit matriciel entre deux tableaux NumPy. Cette méthode est particulièrement utile lorsque nous travaillons avec des vecteurs ou des matrices et que nous avons besoin de calculer leur produit scalaire ou leur produit matriciel.

Prenons un exemple simple pour illustrer cela. Supposons que nous ayons deux matrices A et B, et que nous voulions effectuer leur produit :

import numpy as np

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

resultat = np.dot(A, B)
print(resultat)

# Résultat :
# [[19 22]
#  [43 50]]

Dans cet exemple, la méthode np.dot effectue le produit matriciel classique : chaque élément de la matrice résultante est obtenu en multipliant les lignes de A par les colonnes de B puis en additionnant les produits.

Il est important de noter que pour que le produit matriciel soit défini, le nombre de colonnes de la première matrice doit être égal au nombre de lignes de la seconde.

La forme (ou shape) de la première matrice doit être de type (m, n) et celle de la seconde matrice doit être de type (n, p). Le résultat du produit matriciel aura alors une forme (m, p).

Si ce n'est pas le cas, NumPy lèvera une erreur.

En utilisant np.dot, nous avons donc une méthode directe et performante pour effectuer des calculs algébriques fondamentaux en programmation scientifique avec Python.

La fonction np.ones()

Elle est très pratique lorsque nous voulons créer rapidement un tableau rempli de 1.

Cette fonction prend en paramètre la forme souhaitée du tableau, et elle renvoie un objet ndarray où tous les éléments valent 1. Par défaut, ces éléments ne sont pas des entiers, mais des nombres à virgule flottante de type float64.

Observons un exemple simple :

import numpy as np

tableau = np.ones((2, 3))
print(tableau)
# [[1. 1. 1.]
#  [1. 1. 1.]]

Nous voyons que chaque valeur s'affiche sous la forme 1.. Cela indique que ce ne sont pas de simples entiers (int) mais des nombres flottants, c'est-à-dire des valeurs décimales. Même si nous ne voyons pas la partie décimale ici, Python considère que ces valeurs peuvent avoir des chiffres après la virgule, comme 1.0, 1.5, 3.1415, etc.

Par défaut, le type utilisé par np.ones() est float64. Cela signifie deux choses importantes :

D'abord, float indique qu'il s'agit d'un nombre à virgule flottante. Contrairement aux entiers, ce type peut représenter des nombres fractionnaires.

Ensuite, 64 signifie que ce type utilise 64 bits en mémoire pour représenter chaque valeur. Cela lui permet d'avoir une grande précision, en stockant des nombres très grands, très petits, ou très précis après la virgule.

Vérifions le type réel des éléments :

print(tableau.dtype)
# float64

Si nous préférons que le tableau contienne des entiers (int), il est possible de le préciser avec l'argument dtype :

tableau_entier = np.ones((2, 3), dtype=int)
print(tableau_entier)
print(tableau_entier.dtype)
# [[1 1 1]
#  [1 1 1]]
# int64

Dans ce cas, les valeurs sont stockées comme des entiers sur 64 bits, ce qui peut être utile si nous n'avons pas besoin de décimales et que nous voulons économiser de la mémoire ou accélérer certaines opérations.

En résumé, np.ones() est une fonction efficace pour générer des tableaux remplis de 1. Elle utilise par défaut le type float64, ce qui offre une bonne précision numérique. Mais selon le contexte, nous pouvons choisir un autre type grâce au paramètre dtype.

La fonction np.zeros()

np.zeros() fonctionne exactement comme np.ones(), sauf qu'elle remplit le tableau avec des 0. Voici un exemple où nous créons un tableau de forme (3, 4) :

tableau_zero = np.zeros((3, 4))
print(tableau_zero)
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

Là encore, les valeurs sont par défaut en float64, ce qui est utile pour la précision des calculs. Si nous voulons des entiers, nous pouvons également spécifier dtype=int.

La fonction np.eye()

La fonction np.eye() nous permet de générer une matrice identité, c'est-à-dire une matrice carrée dont les éléments de la diagonale principale sont égaux à 1, et les autres à 0. C'est très pratique en algèbre linéaire :

identite = np.eye(6)
print(identite)
# [[1. 0. 0. 0. 0. 0.]
#  [0. 1. 0. 0. 0. 0.]
#  [0. 0. 1. 0. 0. 0.]
#  [0. 0. 0. 1. 0. 0.]
#  [0. 0. 0. 0. 1. 0.]
#  [0. 0. 0. 0. 0. 1.]]

La fonction np.random.randint()

Pour générer un tableau avec des entiers aléatoires, nous utilisons np.random.randint(). Cette fonction prend trois arguments : la borne minimale, la borne maximale (exclue), et la forme du tableau.

Par exemple, pour créer un tableau de forme (4, 3) rempli de nombres entiers aléatoires entre 0 et 9, nous écrivons :

aleatoires = np.random.randint(0, 10, size=(4, 3))
print(aleatoires)
# Exemple de sortie :
# [[5 2 8]
#  [0 3 1]
#  [9 7 4]
#  [6 6 2]]

Chaque fois que nous exécutons ce code, nous obtenons des valeurs différentes, car les nombres sont générés aléatoirement. C'est très utile pour faire des simulations, générer des données de test ou construire des matrices avec une structure variable.

La fonction np.arange()

La fonction np.arange() de NumPy permet de créer facilement un tableau contenant une séquence de nombres régulièrement espacés, un peu comme la fonction range() de Python, mais en version NumPy, donc avec beaucoup plus de puissance.

Sa syntaxe générale est la suivante :

np.arange(start, stop, step)

start : la valeur de départ (incluse)

stop : la valeur de fin (exclue)

step : l'incrément entre chaque valeur

Tous les arguments sont facultatifs sauf stop. Si un seul argument est donné, il sera considéré comme la valeur de fin, et start sera 0 par défaut, avec un step de 1.

Prenons quelques exemples pour bien comprendre :

import numpy as np

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

Ici, on a généré un tableau allant de 0 à 4. La valeur 5 est exclue, exactement comme avec la fonction range() en Python.

On peut également spécifier un point de départ et un pas :

b = np.arange(2, 10, 2)
print(b)
# [2 4 6 8]

Ce tableau commence à 2 et augmente de 2 à chaque fois, jusqu'à être juste avant 10.

La grande force de np.arange() est qu'elle génère directement un np.ndarray, ce qui permet d'utiliser toutes les fonctions vectorielles de NumPy dessus :

c = np.arange(1, 6)
print(c ** 2)
# [ 1  4  9 16 25]

Chaque élément est élevé au carré sans boucle explicite.

Il est important de noter que np.arange() fonctionne aussi avec des pas décimaux, mais attention à la précision en virgule flottante :

d = np.arange(0, 1, 0.2)
print(d)
# [0.  0.2 0.4 0.6 0.8]

Ici, les valeurs sont bien espacées de 0.2, mais selon les cas, il peut y avoir de légères imprécisions dues à la représentation binaire des nombres flottants. Si l'on veut une précision parfaite sur les bornes, mieux vaut utiliser np.linspace().

En résumé, np.arange() est une fonction très pratique pour générer des séquences numériques, qu'on peut ensuite utiliser pour indexer, tracer des graphes, ou créer des structures de test pour nos algorithmes. Elle s'utilise de manière très similaire à range(), mais avec la puissance et la souplesse des tableaux NumPy.