oujood.com

LES arrays en python

Python n'a pas de support intégré pour les Arrays (arrayx), mais les listes de Python peuvent être utilisées à la place.
Cette page vous montre comment utiliser les LISTES comme des ARRAYS. Cependant, pour travailler avec des arrayx en Python, vous devez importer une bibliothèque, comme la bibliothèque NumPy.

chercher |

Array

Les arrayx sont utilisés pour stocker plusieurs valeurs dans une seule variable :
Exemple Créez un array contenant les noms des voitures :

voitures = ["Renault", "Peugeot", "Ford", "Volvo", "BMW"]

Qu'est-ce qu'un array (tableau) ?

Un array est une variable spéciale, qui peut contenir plus d'une valeur à la fois.
Si vous avez une liste d'éléments (une liste de noms de voitures, par exemple), le stockage des voitures dans des variables individuelles pourrait ressembler à ceci :

voiture1 = "Renault"
voiture2 = "Mercedes
voiture3 = "BMW"

Cependant, que se passe-t-il si vous voulez parcourir les voitures en boucle et trouver une voiture spécifique ? Et que se passe-t-il si vous n'avez pas 3 voitures, mais 300 ?
La solution est un array !
Un array peut contenir plusieurs valeurs sous un seul nom, et vous pouvez accéder aux valeurs en vous référant à un numéro d'index.

Accéder aux éléments d'un array

Pour accéder à un élément d'un array, il faut se référer à son numéro d'index.
Exemple Obtenez la valeur du premier élément de l'array : x = voitures[0]
Ou modifiez la valeur du premier élément de l'array : voitures[0] = "Toyota"

La longueur d'un array

Pour obtenir la longueur d'un array (le nombre d'éléments dans un array), utilisez la méthode len().
Exemple Retournez le nombre d'éléments dans le array :
x = len(voitures)

Remarque : la longueur d'un array est toujours supérieure d'une unité à l'indice le plus élevé de l'array.

Boucle sur les éléments d'un array

Vous pouvez utiliser la boucle for in pour parcourir en boucle tous les éléments d'un array.
Exemple Imprimez chaque élément de l'array voitures

  Copier le code

for x in voitures :
  print(x)

Ajout d'éléments à un array

Vous pouvez utiliser la méthode append() pour ajouter un élément à un array.
Exemple : Ajoutez un élément supplémentaire au array de voitures :
voitures.append("Honda")

Suppression d'éléments d'un array

Vous pouvez utiliser la méthode pop() pour supprimer un élément de l'array.
Exemple : Supprimez le deuxième élément de l'array voitures :
voitures.pop(1)
Vous pouvez également utiliser la méthode remove() pour supprimer un élément de l'array.
Exemple : Supprimez l'élément dont la valeur est "Volvo" :
voitures.remove("Volvo")

Remarque : la méthode remove() de la liste ne supprime que la première occurrence de la valeur spécifiée.

Méthodes pour les arrayx

Python dispose d'un ensemble de méthodes intégrées que vous pouvez utiliser sur les listes et les arrayx.
Méthode Description
append()Ajoute un élément à la fin de la liste.
clear()Supprime tous les éléments de la liste
copy()Renvoie une copie de la liste
count()Renvoie le nombre d'éléments ayant la valeur spécifiée.
extend()Ajoute les éléments d'une liste (ou de n'importe quel itérable), à la fin de la liste courante.
index()Renvoie l'indice du premier élément ayant la valeur spécifiée.
insert()Ajoute un élément à la position spécifiée
pop()Supprime l'élément à la position spécifiée
remove()Supprime le premier élément avec la valeur spécifiée
reverse()Inverse l'ordre de la liste
sort()Trie la liste

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


Cependant, pour travailler avec des arrayx en Python, vous devez importer une bibliothèque, comme la bibliothèque NumPy. et c'est ce que montre la suite de ce cours

Création d'un array NumPy

Dans ce qui suit, vous apprendrez à créer des arrays NumPy, notamment des arrays unidimensionnels, bidimensionnels et tridimensionnels.
L'array est la structure de données centrale de la bibliothèque NumPy. Un array NumPy est une grille de valeurs de même type et indexées par un tuple d'entiers non négatifs.
Tous les array sont des instances de la classe ndarray. Pour créer un nouveau array NumPy, vous utilisez la fonction array() de la bibliothèque NumPy.
Avant de commencer, vérifier si la bibliotéque NumPy est installée en executant le code suivant:

import numpy as np

Si vous recevez l'erreur : ModuleNotFoundError: No module named 'numpy' alors vous devez instaler le module. Consulter GUIDE D'INSTALLATION DE PYTHON ET NUMPY

Création des arrays unidimensionnels

L'exemple suivant utilise la fonction array() pour créer un array

  Copier le code

import numpy as np

a = np.array([1, 2, 3])

print(type(a))
print(a)
Ce code affiche :

  Copier le code

<class 'numpy.ndarray'>
[1 2 3]
Comment ça fonctionne?
Tout d'abord, importez la bibliothèque numpy en tant que np :
import numpy as np
Ensuite, créez un array 1-D (une dimention) en passant une liste de trois entiers :
a = np.array([1, 2, 3])
La fonction array() renvoie une nouvelle instance du type ndarray. Par conséquent, le type(a) renvoie .
Un array 1-D est créé comme un vecteur.

Récupérer la dimension d'un array

Pour connaitre le nombre de dimensions d'un array, la propriété ndim est utilisée. En NumPy, les dimensions sont appelées axes.
Par exemple : le code qui suit renvoie la dimension de l'array:

  Copier le code

import numpy as np

a = np.array([1, 2, 3])
x= a.ndim
if x ==1:
    print("l'array a une dimension")
else:
    print("l'array a " + str(x) + " dimensions")
Dans cet exemple, la propriété ndim renvoie 1 .

Obtention du type de données des éléments d'un array

Pour obtenir le type de données des éléments d'un array, vous utilisez la propriété dtype.
Par exemple :

  Copier le code

import numpy as np

a = np.array([1, 2, 3])

print(a.dtype)
Dans cet exemple, le type des éléments est int32.
Si vous voulez définir le type des éléments de l'array, vous pouvez utiliser l'argument dtype de la fonction array().
Comme le montre l'exemple xuivant :

  Copier le code

import numpy as np

a = np.array([1, 2, 3], dtype=np.float64)

print(a)
print(a.dtype)
Dans cet exemple, les nombres de l'array ont le point décimal (.) et le type de données de ses éléments est float64.

Indexation de arrays 1-D NumPy

Le long d'un seul axe, vous pouvez sélectionner des éléments en utilisant des indices. Le premier élément est indexé 0, le deuxième élément est indexé 1, et ainsi de suite.
Outre les indices non négatifs, vous pouvez utiliser des indices négatifs pour localiser des éléments. Par exemple, le dernier élément a un indice -1, l'avant-dernier élément a un indice -2, et ainsi de suite.
L'exemple suivant montre comment accéder aux éléments d'un array

  Copier le code

import numpy as np

a = np.arange(10, 15)
print(a)

print(a[0])
print(a[1])
print(a[-1])

Création de arrayx bidimensionnels

L'exemple suivant utilise la fonction array() pour créer un array bidimensionnel (2-D) :

  Copier le code

import numpy as np

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

print(b)
x=b.ndim 
print(str(x) + " dimensions")
Dans cet exemple, nous passons une liste d'une liste d'entiers à la fonction array(). La propriété ndim renvoie 2 comme prévu.
Une bonne astuce pour obtenir le nombre de dimensions d'un array est de compter les crochets ([) jusqu'à ce que vous rencontriez le premier nombre. Le nombre de crochets correspond au nombre de dimensions ou d'axes.
Un array à deux dimensions est également appelé une matrice.

Indexation de l'array NumPy sur des arrays 2-D

Avec les arrays 2-D et multidimensionnels, vous pouvez sélectionner des éléments comme vous l'avez fait avec les arrays 1-D, mais pour chaque dimension (ou axe). Par exemple :

  Copier le code

import numpy as np

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

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

print(a[0, 0])  # 1
print(a[1, 0])  # 4
print(a[0, 2])  # 3
print(a[1, 2])  # 6
print(a[0, -1])  # 3
print(a[1, -1])  # 6

Création d'un array tridimensionnel

L'exemple suivant utilise la fonction array() pour créer un array tridimensionnel (3-D) :

  Copier le code

import numpy as np

c = np.array(
    [
        [
            [1, 2, 3],
            [4, 5, 6]
        ],
        [
            [7, 8, 9],
            [10, 11, 12]
        ],
    ]
)
print(c)
x=c.ndim 
print("Array à " + str(x) + " dimensions")
print("De type : " + str(c.dtype))

Indexation de l'array NumPy sur des arrays 3-D

L'exemple suivant crée un array NumPy 3-D :
axes tridimensions
Cette image montre que nous avons :
Deux index sur l'axe-0, donc on aura les indexs 0 et 1
Trois indexs sur l'axe-1, on aura alors les indexes 0, 1 et 2
ET en fin deux indexs sur l'axe-2, et on aura donc les indexs 0 et 1
pour avoir un élément on l'idexe comme suit :
[index axe-0, index axe-1, index axe-2]

  Copier le code

import numpy as np

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

print(a[0, 0, 1])  # retourne 2
print(a[0, 2, 1])  # retourne 6

Découpage d'un array Numpy sur des arrays uni-dimensionnels D-1

Les arrays NumPy utilisent les [] et : pour le découpage en tranches comme les listes. En utilisant les tranches, vous pouvez sélectionner une plage d'éléments dans un array avec la syntaxe suivante :
[m:n]
Cette tranche sélectionne les éléments commençant par m et se terminant par n-1. Notez que le nième élément n'est pas inclus. En fait, la tranche m:n peut être définie explicitement comme suit :
[m:n:1]
Le chiffre 1 indique que la tranche sélectionne tous les éléments entre m et n , n non inclus.
Pour sélectionner tous les deux éléments, vous pouvez utiliser la tranche suivante :
[m:n:2]
En général, l'expression suivante sélectionne tous les k éléments entre m et n :
[m:n:k]
Si k est négatif, la tranche renvoie les éléments dans l'ordre inverse, de m à n+1. Le tableau suivant illustre les expressions de découpage en tranches : > Voir l'exemple suivant:
[index axe-0, index axe-1, index axe-2]

  Copier le code

import numpy as np

a = np.arange(10, 101,10)

print('a=', a)
print('a[2:5]=', a[2:5])
print('a[:]=', a[:])
print('a[0:-1]=', a[0:-1])
print('a[0:6]=', a[0:6])
print('a[7:]=', a[7:])
print('a[5:-1]=', a[5:-1])
print('a[0:5:2]=', a[0:5:2])
print('a[::-1]=', a[::-1])
Tranche Expression Signification
a[m:n] Sélectionner les éléments dont l'indice commence à m et se termine à n-1.
a[:] or a[0:-1] Sélectionner tous les éléments dans un axe donné
a[:n] Sélectionner les éléments à partir de l'indice 0 jusqu'à l'élément d'indice n-1.
a[m:] Sélectionne les éléments à partir de l'indice m jusqu'au dernier élément.
a[m:-1] Sélectionner les éléments à partir de l'indice m jusqu'au dernier élément.
a[m:n:k] Sélectionner les éléments d'indice m à n (exclusif), avec un incrément k
a[::-1] Sélectionne tous les éléments dans l'ordre inverse

Découpage de tableaux Numpy sur des arrays multidimensionnels

Pour découper un array multidimensionnel, vous appliquez les crochets [] et la notation : à chaque dimension (ou axe). Le découpage renvoie un array réduit dont chaque élément correspond aux règles de sélection.
Par exemple :

  Copier le code

import numpy as np

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

print(a[0:2, :])
L'image qui suit montre les éléments que nous avons sélectionné par l'expression a[0:2, :] en vert
numpy array découpage
Dans cet exemple, le array a est un array 2-D.
Dans l'expression a[0:2, :]
D'abord, le 0:2 sélectionne les éléments à l'indice 0 et 1, c'est-à-dire les éléments du début jusqu'à l'élément avec l'index 2 non inclus ce qui renvoie :
[[1 2 3]
[4 5 6]]
Ensuite, le : sélectionne tous les éléments. Par conséquent, l'expression entière retourne :
[[1 2 3]
[4 5 6]]
Prenons un autre exemple :

  Copier le code

import numpy as np

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

print(a[1:, 1:])
Dans l'expression a[1 :, 1 :]:
D'abord, (1: ) sélectionne les éléments à partir de l'indice 1 jusqu'au dernier élément du premier axe (ou ligne), ce qui renvoie :
[[4 5 6]
[7 8 9]]
Second, 1 : sélectionne les éléments à partir de l'indice 1 jusqu'aux derniers éléments du second axe (ou colonne), ce qui donne :
[[5 6]
[8 9]]

Indexation fantaisiste

Dans le tutoriel précédent, vous avez appris à sélectionner les éléments d'un tableau NumPy en utilisant les techniques d'indexation et de découpage.
En plus de l'utilisation de l'indexation et du découpage, NumPy vous fournit un moyen pratique d'indexer un array appelé fancy indexing.
L'indexation fantaisiste vous permet d'indexer un array numpy en utilisant ce qui suit :
Un autre array NumPy
Une liste Python
Une séquence d'entiers
Voyons l'exemple suivant :

  Copier le code

import numpy as np

a = np.arange(1, 10)
print(a)

indices = np.array([2, 3, 4])
print(a[indices])
Sortie :
[1 2 3 4 5 6 7 8 9]
[3 4 5]
Comment cela fonctionne?
Tout d'abord, nous avons utilisé la fonction arange() pour créer un array numpy (a) avec les nombres de 1 à 9 :
a=[1 2 3 4 5 6 7 8 9]
Ensuite, créez un deuxième array numpy pour l'indexation :
indices = np.array([2, 3, 4])
Ce qui définie les indexes dont on veut obtenir éléments
Troisièmement, utilisez le tableau indices pour indexer le tableau a :
print(a[indices])

L'indexation fantaisiste vous permet d'indexer un tableau à l'aide d'un autre tableau, d'une liste ou d'une séquence d'entiers.

Indexation booléenne d'un array NumPy

Numpy vous permet d'utiliser un array de valeurs booléennes comme index d'un autre array. Chaque élément de l'array booléen indique s'il faut ou non sélectionner les éléments de l'array.
Si la valeur est True, l'élément de cet index est sélectionné. Dans le cas où la valeur est False, l'élément de cet index n'est pas sélectionné.
L'exemple suivant utilise l'indexation booléenne pour sélectionner les éléments d'un array numpy en utilisant un array de valeurs booléennes :

  Copier le code

import numpy as np

a = np.array([1, 2, 3])
b = np.array([True, True, False])
c = a[b]
print(c)
Généralement, vous utiliserez l'indexation booléenne pour filtrer un array. Par exemple :

  Copier le code

import numpy as np

a = np.arange(1, 10)
b = a > 6
print(b)

c = a[b]
print(c)
Sortie de ce code:
[False False False False False False True True True]
[7 8 9]
Comment cela fonctionne?
D'abord, créez un array qui contient 9 nombres de 1 à 9 en utilisant la fonction arange() :
a = np.arange(1, 10)
Ensuite, créez un array booléen à partir de l'expression suivante :
b = a > 6
Cette expression compare chaque élément du array a avec 6 et renvoie Vrai s'il est supérieur à 6 ou Faux sinon.
La variable b est un array de valeurs booléennes :
[False False False False False False True True True]
Troisièmement, utilisez le array b comme index du array a et assignez le résultat à la variable c :
c = a[b]
Le array c contient uniquement les nombres du array a, qui sont supérieurs à 6.




Voir aussi nos tutoriel :

Créez une Table dans une base de données

Créez une Table dans une base de données

traitement des espaces de noms

Traitement des espaces de noms

fonction strnatcmp, strnatcmp

Comparaison de chaînes avec l'algorithme d'"ordre naturel"