Listes et tableaux

Les listes

C’est un nouveau type de variable qui peut contenir des entiers, des flottants, des chaînes de caractères voire des listes. Il est naturellement intégré dans python.

Définition d’une liste – Affichage

Une liste est une collection ordonnée d’objets python. De même que pour les chaînes de caractères, la fonction print() permet d’afficher la liste. Voici un exemple de liste :

>>> liste1 = [1.56, u"tabouret", 3j]
>>> liste1
[1.56, u'tabouret', 3j]
>>> print(liste1)
[1.56, u'tabouret', 3j]
>>> type(liste1)
<type 'list'>

Le type d’objets est quelconque et peut même être une autre liste

>>> liste2 = [2, 4.1, u"chaise", liste1]
>>> print(liste2)
[2, 4.1, u'chaise', [1.56, u'tabouret', 3j]]
>>> liste2
[2, 4.1, u'chaise', [1.56, u'tabouret', 3j]]

Accès à ses éléments, indexation et longueur

On appelle un élément de cette liste d’après son numéro (ou indice) pris dans l’ordre en commençant par 0 pour le premier élément.

>>> liste1[1]
u'tabouret'

ou encore dans le cas d’une liste de liste

>>> liste2[0]
2
>>> liste2[3]
[1.56, u'tabouret', 3j]
>>> liste2[3][1]
u'tabouret'

Pour connaître le nombre éléments d’une liste, on dispose de la fonction len()

>>> N1 = len(liste1)
>>> print(N1)
3
>>> N2 = len(liste2)
>>> print(N2)
4

On appelera le dernier élément de la liste de la façon suivante :

>>> liste2[N2-1]
[1.56, u'tabouret', 3j]

ou encore en remontant avec des indices négatifs

>>> liste2[-1]
[1.56, u'tabouret', 3j]
>>> liste2[-3]
4.1

Comme pour les chaines de caractères et avec la même syntaxe, il est possible de ne sélectionner qu’une partie de liste. Ne pas oublier que le premier indice vaut 0

>>> liste2[1:4]         # Tous les éléments de 1 à 3
[4.1, u'chaise', [1.56, u'tabouret', 3j]]
>>> liste2[0:2]         # Tous les éléments de 0 à 1
[2, 4.1]
>>> liste2[:3]          # les 3 premiers caractères
[2, 4.1, u'chaise']
>>> liste2[3:]          # Tout sauf les 3 premiers caractères
[[1.56, u'tabouret', 3j]]

Création de listes

Pour créer une liste de nombre on utilise la fonction range()

>>> range(0,4)
[0, 1, 2, 3]
>>> range(4)    # Plus simple
[0, 1, 2, 3]

Si on veut une liste qui ne commence pas à zéro et dont les élements ne sont pas successifs on peut écrire :

>>> range(3,40,7)
[3, 10, 17, 24, 31, 38]

Opérations sur les listes

Comme pour les chaînes de caractères, il est possible de concaténer des listes, c’est à dire de les juxtaposer avec la fonction "+".

>>> a = [1, 2, 3]
>>> b = [2, 3, 4]
>>> listeconcat = a + b
>>> print(listeconcat)
[1, 2, 3, 2, 3, 4]

Il est possible d’ajouter des éléments à la fin d’une liste avec la fonction append().

>>> listeconcat.append(3j)
>>> listeconcat
[1, 2, 3, 2, 3, 4, 3j]
>>> listeconcat.append(u"Toto")
>>> listeconcat
[1, 2, 3, 2, 3, 4, 3j, u'Toto']

Note

  • Il est possible d’insérer des élements à n’importe quel indice (insert()), d’en retirer (remove()), de les trier, de les compter, de renverser la liste... Nous renvoyons le lecteur intéressé à la documentation python correspondante .

L’opération multiplication permet de créer un certain nombre d’éléments identiques

>>> dix_zeros = [0]*10
>>> dix_zeros
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> a = [1, 2, 3, 4, 5]
>>> b = [0]*len(a)      # Liste b conntenant autant de 0 que a possède d'éléments
>>> b
[0, 0, 0, 0, 0]

Les tableaux

Un tableau est une liste ordonnée de nombres uniquement (flottants, entiers, complexes voire booléens codés en binaire). Les tableaux sont accessibles à partir de la librairie Numpy qui doit être préalablement chargée. Pour des raisons de simplicité évidentes, nous chargerons la libraire Scipy qui contient Numpy. Pour plus de détails, on pourra se reporter à la documentation de Numpy p.7-11.

Construction et affichage

Il est possible de construire un tableau (=``array``) de manière explicite. Comme les listes, il s’agit d’un nouveau type de variable.

>>> from scipy import *
>>> a = array([1, 2, 3, 4, 5, 1j, 1+3j])
>>> type(a)
<type 'numpy.ndarray'>

Accès à ses éléments, indexation et longueur

L’indexation, l’accès à ses éléments et la longueur d’un tableau (fonction len()) sont les commandes identiques aux listes

>>> from scipy import *
>>> tab1 = array([10.2, 3.4, 3, 4, 5])
>>> type(tab1 )
<type 'numpy.ndarray'>

>>> len(tab1)   # Longueur du tableau
5
>>> tab1[2]     # Indexation des éléments
3.0

Comme pour les listes et avec la même syntaxe, il est possible de ne sélectionner qu’une partie d’un tableau. Ne pas oublier que le premier indice vaut 0

>>> from scipy import *
>>> tab1[1:3]           # Tous les éléments de 1 à 2
array([ 3.4,  3. ])
>>> tab1[0:2]           # Tous les éléments de 0 à 1
array([ 10.2,   3.4])
>>> tab1[:3]            # les 3 premiers caractères
array([ 10.2,   3.4,   3. ])
>>> tab1[3:]            # Tout sauf les 3 premiers caractères
array([ 4.,  5.])
>>> tab1[-1]            # Décompte inverse des indices
5.0
>>> tab1[-2]            # Décompte inverse des indices
4.0

Création de tableaux particuliers

Avec la bibliothèque numpy, il est possible de créer des tableaux particuliers, utiles pour certains calculs.

Tableaux régulièrement espacé (Structure : Début, Fin-incrément, incrément)

>>> from scipy import *
>>> arange(15)                          # Correspond à la méthode range pour les listes
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])

>>> arange(2, 3, 0.1)
array([ 2. ,  2.1,  2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9])

Tableaux avec un nombre de points spécifié régulièrement espacés linéairement ou logarithmiquement (Structure : Début, Fin, Nombre de points)

>>> from scipy import *
>>> linspace(-1., 4., 11)
array([-1. , -0.5,  0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ])

>>> logspace(-1, 4, 11)
array([  1.00000000e-01,   3.16227766e-01,   1.00000000e+00,
 3.16227766e+00,   1.00000000e+01,   3.16227766e+01,
 1.00000000e+02,   3.16227766e+02,   1.00000000e+03,
 3.16227766e+03,   1.00000000e+04])

Tableaux avec des nombres particuliers

>>> from scipy import *
>>> zeros(8)                    # Tableau avec un nombre de 0 spécifié
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])

>>> ones(8)                     # Tableau avec un nombre de 1 spécifié
array([ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.])

Opérations sur les tableaux

Avertissement

Attention les opérations sont différentes de celles des listes !!

Les symboles "+", "-", "*" et "/" permettent (contrairement aux listes) d’additioner, de soustraire, de multiplier ou de diviser un à un les éléments des tableaux (Il est donc nécessaire qu’ils soient de même dimensions). Il est même possible de mettre des tableaux en exposant avec la commande "**".

>>> from scipy import *
>>> a,b = arange(1.,4.), arange(2.,5.)
>>> a
array([ 1.,  2.,  3.])
>>> b
array([ 2.,  3.,  4.])

>>> a + b               # Addition éléments par éléments
array([ 3.,  5.,  7.])

>>> a - b               # Soustraction éléments par éléments
array([-1., -1., -1.])

>>> a * b               # Multiplication éléments par éléments
array([  2.,   6.,  12.])

>>> a / b               # Division éléments par éléments
array([ 0.5       ,  0.66666667,  0.75      ])

>>> a ** b              # Exposant éléments par éléments
array([  1.,   8.,  81.])

Il est aussi possible de réaliser ces opérations ("+",``”-“,“*”, ``"/" ou "**") avec un nombre constant.

>>> a - 3
array([-2., -1.,  0.])
>>> a * 3
array([ 2.,  3.,  4.])
>>> a ** 3
array([  1.,   8.,  27.])       # Mise au cube de chaque élément

Comme pour les listes, la fonction append() permet d’ajouter un élément (ici un nombre) à la fin d’un tableau ;

Avertissement

Toutefois, on prendra garde à la syntaxe qui n’est pas la même : append(liste,nombre à ajouter)

Sur un exemple :

>>> from scipy import *
>>> maliste = arange(1.,4.)
>>> maliste
array([ 1.,  2.,  3.])
>>> append(maliste,10)
array([ 1.,  2.,  3., 10.])

Les tableaux2D

Un tableau 2D est en fait un tableau de tableau. Ils ne sont uniquement accessibles qu’à partir de la librairie Numpy chargée par Scipy.

On définit un tableau 2D de manière explicite. L’accès à ses éléments est identique à celui d’un tableau 1D excepté qu’il faut 2 indices (ligne et colonne) pour repérer un élément :

>>> from scipy import *
>>> tab2D1 = array([[1, 2, 3],[4, 5, 6]])
>>> tab2D1
array([[1, 2, 3],
       [4, 5, 6]])
>>> type(tab2D1)
<type 'numpy.ndarray'>
>>> shape(tab2D1)
2,3                     # Dimensions du tableau

>>> tab2D1[1][2]        # Attention les indices commencent à 0
6
>>> tab2D1[0,:]         # Première ligne
array([1, 2, 3])
>>> tab2D1[:,0]         # Première colonne
array([1, 4])

Les opérations "+",``”-“,“*”, ``"/" ou "**" ont le même effet et la même syntaxe que pour un tableau 1D.

>>> tab2D1 ** 3                 # Mise au cube de chaque élément
array([[  1,   8,  27],
       [ 64, 125, 216]])
>>> tab2D1 * tab2D1             # Multiplication éléments par éléments
      [16, 25, 36]])

Avertissement

Reste à faire * Création de tableaux particuliers (arange, linspace, logspace, ones) * fonction append()

Une transposition peut être réalisée à l’aide de la fonction ndarray.T. Par exemple ,

::
>>> from scipy import *
>>> x = array([[1.,2.],[3.,4.]])
>>> x
array([[ 1.,  2.],
       [ 3.,  4.]])
>>> x.T
array([[ 1.,  3.],
       [ 2.,  4.]])

Un tableau vide peut être créé par la comande zeros comme pour les tableaux 1d mais le nombre de ligne et de colonne doivent être spécifiés. Un résultat similaire est obtenu avec la commande ones.

::
>>> from scipy import *
>>> zeros((6, 2))
array([[ 0.,  0.],
          [ 0.,  0.],
          [ 0.,  0.],
          [ 0.,  0.],
          [ 0.,  0.],
          [ 0.,  0.]])
>>> ones((2, 3))
array([[ 1.,  1.,  1.],
          [ 1.,  1.,  1.]])

On ajoute un ligne ou une colonne avec la fonction append

::
>>> from scipy import *
>>> a = array([10,20,30])
>>> append(a,[[1,2,3]],axis=0) # Ajout d'une ligne (axis=0)
array([[10, 20, 30],
       [1, 2, 3]])

>>>append(a,[[15],[15]],axis=1) # Ajout d’une colonne (axis=1) >>>array([[10, 20, 30, 15], [1, 2, 3, 15]])