Tutoriel Python : manipuler les tableaux

Table des matières :

1. Introduction :

NumPy est le package fondamental pour le calcul scientifique avec Python. Ça signifie « Python numérique. » Elle supporte :

Tableaux à N dimensions.
Fonctions de diffusion.
Outils d’intégration de code C / C ++ et Fortran.
Fonctions utiles d'algèbre linéaire, de transformée de Fourier et de nombres aléatoires.

L’objet principal de NumPy est les tableaux multidimensionnels homogène. Un array est un tableau d'éléments (généralement des nombres), tous du même type, indexés par un tuple d'entiers positifs et représentés par une seule variable. La classe des tableaux de NumPy est appelée ndarray. Elle est aussi connue par le tableau d'alias (the alias array).

Dans les tableaux NumPy, les éléments de données individuels sont appelés éléments. Tous les éléments d'un tableau doivent être du même type. Les tableaux peuvent être constitués de n'importe quel nombre de dimensions. Dans NumPy, les dimensions sont appelées axes. Chaque dimension d'un tableau a une longueur qui est le nombre total d'éléments dans cette direction.

Remarque : Python n'a pas de support intégré pour les tableaux, mais les listes Python peuvent être utilisées à la place.

2. Création des tableaux NumPy à l'aide de la fonction array () :

Vous pouvez créer un tableau NumPy à partir d'une liste ou d'un tuple Python normal en utilisant la fonction np.array(). Le type du tableau résultant est déduit du type des éléments.

Exemple 1 :

Syntaxe:

import numpy as np
int_numbre_array=np.array([1,2,3,4])
int_numbre_array
type(int_numbre_array)
int_numbre_array.dtype
float_numbre_array=np.array([9.1,3.4,5.7,4.4])
float_numbre_array.dtype
two_dimensional_array_list=np.array([[1,2,3],[4,5,6]])
two_dimensional_array_list
two_dimensional_array_tuple=np.array(((1,2,3),(4,5,6)))
two_dimensional_array_tuple

Résultat de l’execution :

Explication du code :

Importez la bibliothèque Numpy dans votre programme. Passez une liste d'éléments à la fonction np.array () et affectez le résultat à l'objet int_number_array . Dans la sortie, vous pouvez voir que tous les éléments sont placés dans un objet itérable de la classe de tableau et un tableau à une dimension.

L'objet int_number_array appartient à la classe numpy.ndarray .NumPy fournit un grand ensemble de types de données numériques que vous pouvez utiliser pour construire des tableaux. NumPy essaie de deviner un datatype lorsque vous créez un tableau, mais les fonctions qui construisent des tableaux incluent également un argument facultatif pour spécifier explicitement le type de données.

Remarque :

Le type de int_number_array est dtype ('int32').
Le type de float_number_array est dtype ('float64').

La fonction np.array () prend soit une seule liste, soit un tuple comme argument. Si vous souhaitez spécifier plusieurs listes ou tuples, transmettez-les sous forme de listes imbriquées ou de tuples imbriqués -. Ici, two_dimensional_ array_list et two_dimensional_array_tuple sont des exemples de tableaux à deux dimensions.

Syntaxe :

array_dtype=np.array([1,2,3,4],dtype=np.float64)
array_dtype
int_numbre_array.dtype

Résultat de l’exécution :

Vous pouvez également spécifier explicitement le type de données du tableau en affectant des valeurs de type telles que np.float64, np.int32 et autres à un attribut dtype et le passer comme second argument à la fonction np.array () .

3. les Attributs des tableaux :

Le contenu de ndarray peut être consulté et modifié en indexant ou en découpant le tableau et via les méthodes et attributs du ndarray. Les attributs les plus importants de l'objet ndarray sont :

ndarray.ndim :Elle donne le nombre d'axes ou de dimensions dans le tableau.
ndarray.shape :Elle donne les dimensions du tableau. Pour un tableau avec n lignes et m colonnes, la forme sera un tuple d'entiers (n, m).
ndarray.size: Donne le nombre total d'éléments du tableau
ndarray.dtype:Donne un objet décrivant le type des éléments du tableau. Elle peut créer ou spécifier des dtype à l'aide de types Python standard. De plus, NumPy fournit ses propres types tels que np.int32, np.int16, np.float64 et autres.
ndarray.itemsize :Donne la taille de chaque élément du tableau en octets.
ndarray.data:Donne le tampon(buffer) contenant les éléments réels du tableau. Normalement, nous n'utiliserons pas cet attribut car nous accèderons aux éléments dans un tableau à l'aide des fonctions d'indexation.

Exemple 2 :

Syntaxe:

import numpy as np
array_attributes=np.array([[10,20,30,40],[11,12,13,14]])
array_attributes.ndim
array_attributes.shape
array_attributes.size
array_attributes.dtype
array_attributes.itemsize
array_attributes.data

Résultat de l’exécution :

4. Création de tableaux NumPy avec un contenu d'espace réservé initial :

Souvent, les éléments d'un tableau sont initialement inconnus, mais sa taille est connue. Par conséquent, NumPy propose plusieurs fonctions pour créer des tableaux avec un contenu d'espace réservé initial (TABLEAU 2). Celles-ci minimisent la nécessité de développer des tableaux, chose qui est relativement coûteuse.

np.zeros() :Crée un tableau des zéros.
np.ones() :Crée un tableau des uns.(1)
np.empty() :Crée un tableau vide.
np.full() :Crée un tableau complet.
np.eye() :Crée une matrice d'identité.
np.random.random() :Crée un tableau avec des valeurs aléatoires.
np.arange() :La syntaxe de arange() est, np.arange ([start,]stop, [step,][dtype=None]). Renvoie des valeurs régulièrement espacées dans un intervalle donné où start (un nombre et facultatif) est le début de l'intervalle et sa valeur par défaut est zéro, stop (un nombre) est la fin de l'intervalle et step (un nombre et est facultatif) est l'espacement entre les valeurs et dtype est le type de tableau de sortie.
np.linspace() :La syntaxe de linspace est : numpy.linspace(start, stop, num=50, dtype=None) Renvoie des nombres régulièrement espacés sur un intervalle spécifié où start est la valeur de départ de la séquence, stop est la valeur de fin de la séquence et num (un entier et facultatif) est le nombre d'échantillons à générer. La valeur par défaut est 50. Doit être non négatif. Le dtype facultatif est le type du tableau de sortie.

Exemple 3 :

Syntaxe:

import numpy as np
np.zeros((2,3))
np.ones((3,4))
np.full((3,3),2)
np.eye(2,2)
np.random.random((2,2))
np.arange(10,30,5)
np.linespace(0,2,9)

Résultat de l’exécution :

Il existe diverses fonctions NumPy pour créer des tableaux . Lorsque la fonction arange() est utilisée avec des arguments en virgule flottante, il n'est généralement pas possible de prédire le nombre d'éléments obtenus, en raison de la précision en virgule flottante finie. Pour cette raison, il est généralement préférable d'utiliser la fonction linspace() à laquelle vous pouvez passer un argument spécifiant le nombre d'éléments que vous souhaitez générer au lieu de l'étape. Dans, la fonction linspace() produit neuf éléments de données entre zéro et deux.

5. indexation d'entiers, indexation de tableau, tableau booléen Indexation, découpage et itération dans les tableaux :

Les tableaux unidimensionnels peuvent être indexés, découpés et itérés, tout comme les listes et autres séquences Python.

Exemple 4 :

Syntaxe:

import numpy as np
a=np.arange(5)
a
a[2]
a[2:4]
a[:4:2]=-999
a
a[::-1]
for each_element in a:
print(each_element)

Résultat de l’exécution :

Opérations d'indexation, de découpage et d'itération sur des tableaux NumPy unidimensionnels Pour les tableaux multidimensionnels, vous pouvez spécifier un index ou une tranche par axe.

Exemple 5:

Syntaxe:

import numpy as np
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
a
a[1,3]
a[:2, 1:3]
lower_axes=a[1,:]
lower_axes
lower_axes.ndim
same_axes=a[1:2,:]
same_axes
same_axes.ndim
a[:, 1]
a[:, 1:2 ]
for row in a :
print(row)
for each_element in a.flat :
print(each_element)

Résultat de l’exécution :

Explication du code :

Utilisez l'indexation d'entiers pour extraire les éléments de données présents dans la ligne 1 et la colonne 3. Vous pouvez également mélanger l'indexation d'entiers avec l'indexation de tranches. Retirez alors le sous-tableau constitué de la ligne 0 et de la ligne 1 et de la colonne 1 et de la colonne 2 ayant la forme (2, 2). Affichez les éléments présents dans toutes les colonnes de la ligne. Le mélange de l'indexation d'entiers avec des tranches donne un tableau d'axes inférieurs. L'utilisation de tranches dans tous les axes d'un tableau donne un tableau des mêmes axes que le tableau d'origine. L'itération sur des tableaux multidimensionnels se fait par rapport au premier axe . Cependant, si l'on veut effectuer une opération sur chaque élément du tableau, on peut utiliser l'attribut flat, qui est un littérateur sur tous les éléments du tableau -.

6. Les opérations arithmétiques de base sur les tableaux NumPy :

Les fonctions mathématiques de base exécutent des opérations élémentaires sur les tableaux et sont disponibles à la fois en tant que surcharges d'opérateur et en tant que fonctions dans le module NumPy.

Exemple 7:

Syntaxe:

import numpy as np
a=np.array([20,30,40,50])
b=np.arange(4)
b
a+b #np.add(a,b)
a-b #np.substract(a,b)
A=np.array([[1,1],[6,1])
B=np.array([[2,8],[ 3,4])
A*B #np.multiply(A,B)
A/B #np.divide(A,B)
np.dot(A,B)
B**2

Résultat de l’exécution :

Les opérations de somme, de soustraction, de multiplication et de division par élément sont effectuées, ce qui donne un tableau . Le produit Matrix est réalisé en Chaque élément est carré dans le tableau B comme indiqué dans la figure ci-dessus.

7. Les Fonctions mathématiques sur les tableaux dans NumPy :

Diverses fonctions mathématiques sont prises en charge dans NumPy. Quelques fonctions mathématiques fréquemment utilisées sont présentées ci-dessous :

Exemple 8:

Syntaxe:

import numpy as np
a=np.array([20,30,40,50])
np.sin(a)
np.cos(a)
np.tan(a)
a=np.array([-1.7,-1.5,-0.2,0.2,1.5,1.7,2.0])
np.floor(a)
np.ceil(a)
np.sqrt([1,4,9])
np.maximum([2,3,4],[1,5,2])
np.minimum([2,3,4],[1,5,2])
np.sum([0.5,1.5])
np.sum([0,1],[0,5],axis=0)
np.sum([0,1],[0,5],axis=1)

Résultat de l’exécution :

Les opérations trigonométriques comme sin(), cos() et tan() sont prises en charge . La fonction floor () ayant la syntaxe floor (x), renvoie la plus grande valeur entière inférieure ou égale à x, élément par élément . La fonction ceil() ayant une syntaxe comme ceil(x), retourne la plus petite valeur entière supérieure ou égale à x, élément par élément .

La fonction sqrt() renvoie la racine carrée positive d'un tableau, élément par élément . La fonction maximum() compare deux tableaux et renvoie un nouveau tableau contenant un maximum d'éléments de tableau par élément. La fonction mum() compare deux tableaux et renvoie un nouveau tableau contenant un minimum d'éléments de tableau par élément.

La fonction sum() renvoie la somme des éléments du tableau sur un axe donné. Toutes les fonctions ci-dessus renvoient un nouveau tableau.

8. Modification de la forme d'un tableau :

Vous pouvez modifier la forme d'un tableau.

Exemple 9:

Syntaxe:

import numpy as np
a=np.floor(10*np.random.random((3,4)))
a
a.shape
a.ravel()
a.reshape(6,2)

Résultat de l’exécution :

Un tableau a une forme donnée par le nombre d'éléments le long de chaque axe . La forme d'un tableau peut être modifiée avec les fonctions ravel() et reshape() . Ravel() et reshape() renvoient un tableau modifié mais ne modifient pas le tableau d'origine. La fonction ravel() renvoie un tableau aplati, tel qu'un tableau à une dimension, contenant les éléments de l'entrée. La fonction reshape() donne une nouvelle forme à un tableau sans changer ses données.

9. Exercices :

Exercice 1 :

Écrire un programme qui permet de saisir n nombre au clavier, et les stocker dans un tableau, calculez leur somme.

Exercice 2 :

Écrire un programme qui permet de chercher toutes les occurrences d’un élément dans un tableau.

Exercice 3 :

Écrire un programme qui permet d’insérer un élément dans un tableau .

Exercice 4 :

Écrire un programme qui permet de trier par ordre croissant les éléments d’un tableau.

Exercice 5:

Écrire un programme pour déclarer un tableau, puis saisir ses éléments à partir de l'utilisateur et rechercher les éléments maximum et minimum dans le tableau.

Exercice 6 :

Écrire un programme qui permet de saisir les données de 2 matrices A, B de taille (N, M), de faire leur somme, l’afficher à l’écran.

10. Correction des Exercices :

Exercice 1:

Syntaxe :

N= int(input("Entrer le nombre d’elements du tableau : "))
tab=[0]*N
sum=0
for I in range(N):
tab[i]=int(input(“entrer element {0} :” .format(i+1)))
sum+=tab[i]
for I in range(N):
print(tab[i] ,end=’, ‘)
print(“\n la somme= ”,sum)

Résultat de l’exécution :

Exercice 2 :

Syntaxe :

N= int(input("Entrez le nombre d’éléments du tableau : "))
tab=[0]*N
sum=0
for I in range(N):
tab[i]=int (input ("entrer l’élément {0}: ". format(i+1)))
X=int(input(“ entre le nombre chercher : ”))
Cpt=0
for I in range(N):
if(tab[i]==X):
Cpt+=1
for I in range(N):
print(tab[i] ,end=’, ‘)
print("\n le nombre d’occurrence du",X, " est " ,Cpt)

Résultat de l’exécution :

Exercice 3 :

Syntaxe :

N= int(input("Entrez le nombre d’éléments du tableau : "))
tab=[0]*N
for I in range(N):
tab[i]=int(input(“entrer l’élément {0} :” .format(i+1)))
X=int(input(“ entre un a insérer dans le tableau : ”))
tab.append(X)
for I in range(N):
print(tab[i] ,end=’, ‘)

Résultat de l’exécution :

Exercice 4:

Syntaxe :

N= int(input("Entrez le nombre d’elements du tableau : "))
tab=[0]*N
for I in range(N):
tab[i]=int(input(“entrer l’élément {0} :” .format(i+1)))
tab.sort();
for I in range(N):
print(tab[i] ,end=’, ‘)

Résultat de l’exécution :

Exercice 5:

Syntaxe :

N= int(input("Entrez le nombre d’éléments du tableau : "))
tab=[0]*N
sum=0
for I in range(N):
tab[i]=int(input(“entrer l’élément {0} :” .format(i+1)))
max=tab[0]
min=tab[0]
for I in range(N):
if(tab[i]>max):
max=tab[i]
if(tab[i] min=tab[i]
print(“le maximum est = “,max)
print(“le minimum est =“,min)

Résultat de l’exécution :

Exercice 6:

Syntaxe :

N= int(input("Entrez le nombre des lignes de la matrice : "))
M= int(input("Entrez le nombre des colonnes de la matrice : "))
A=[[0 for i in range(N)]for j in range(M)]
B=[[0 for i in range(N)]for j in range(M)]
C=[[0 for i in range(N)]for j in range(M)]
for I in range(M):
for j in range(N):
A[i][j]=int(input(“ saisir l’élément A[{0}][{1}] : ”.format(i,j)))
for I in range(M):
for j in range(N):
B[i][j]=int(input(“ saisir l’élément A[{0}][{1}] : ”.format(i,j)))
for I in range(M):
for j in range(N):
C[i][j]=A[i][j]+B[i][j]
for I in range(M):
for j in range(N):
print( C[i][j] ,end =’ , ‘)
print(“ “)

Résultat de l’exécution:

Conclusion

Un tableau est une structure de données linéaire qui a le même type d'éléments. Les éléments d'un tableau sont stockés dans des emplacements mémoire consécutifs. En python la principale différence entre les tableaux et les listes :

Les listes python peuvent contenir des valeurs correspondant à différents types de donnée.
Les tableaux peuvent contenir des valeurs de même types de donnée.

NumPy est le package principale qui support toutes les fonctionnalités des tableaux.

Article publié le 18 Octobre 2020par Kaoutar OUAZZINE