Création de listes en Python

Une liste est une suite d’objets, rangés dans un certain ordre. Chaque objet est séparé par une virgule et la suite est encadrée par des crochets.

Une liste n’est pas forcement homogène : elle peut contenir des objets de types différents les uns des autres.

liste : ['girafe ', 'tigre ', 'singe ', 'souris ']
indice : 0 1 2 3

>>> animaux = ['girafe ','tigre ','singe ','souris ']
>>> animaux [0]
'girafe'
>>> animaux [1]
'tigre'
>>> animaux [3]
'souris'

• Pour créer une liste en Python, on a plusieurs possibilités :

• Les crochets [] représentent l’opérateur d’indice en Python. Il ne nécessite pas de recherche de symbole ni d’appel de fonction. Par conséquent, il s’avère le moyen le plus rapide de créer une liste en Python.
• Vous pouvez spécifier les éléments à l’intérieur de [] , séparés par des virgules.

#Créer une liste Python à l'aide de l'opérateur indice
# Syntaxe
liste1 = [] # Création d'une liste vide
liste2= [a1, a2, a3, ...] # Création d'une liste avec des éléments

• Python inclut une méthode list () intégrée.
• Il accepte une séquence ou un tuple comme argument et se convertit en une liste Python.
• Exemple 1: Créer des listes à partir d’une chaîne, d’un tuple et d’une liste

# Création d'une liste vide
print(list())
# Création d'une chaîne de voyelle
chaine_voyelle = 'aeiou'
print(list(chaine_voyelle))

# voyelle tuple
voyelle_tuple = ('a', 'e', 'i', 'o', 'u')
print(list(voyelle_tuple))

# voyelle liste
voyelle_liste = ['a', 'e', 'i', 'o', 'u']
print(list(voyelle_liste))

###Production###
[]
['a', 'e', 'i', 'o', 'u']
['a', 'e', 'i', 'o', 'u']
['a', 'e', 'i', 'o', 'u']

• Exemple 2: Créer des listes à partir d’un ensemble et d’un dictionnaire

# voyelle set
voyelle_set = {'a', 'e', 'i', 'o', 'u'}
print(list(voyelle_set))

# vowel dictionary
vowel_dictionary = {'a': 1, 'e': 2, 'i': 3, 'o':4, 'u':5}
print(list(vowel_dictionary))
 ###Production###
['a', 'u', 'o', 'i', 'e']
['a', 'e', 'i', 'o', 'u']

• On peut créer une liste de façon exhaustive :
Jour=["lundi", "mardi", "mercredi", "jeudi", "vendredi"]
• On peut créer une liste vide puis lui ajouter des éléments :
Tab=[] : initialisation d’une liste vide.

Tab=[0]*10 : permet d’initialiser une liste ou un tableau de 10 cases avec la valeur 0.
M=[[0, 3, 4],[1, 5, 7]] : des listes de listes sont possibles.

• On peut utiliser les compréhensions de listes :
• Utiliser la fonction range ()
• La fonction range () permet de créer une liste. Elle permet d’utiliser trois paramètres. Le premier contient le numéro de départ de la liste, le second le dernier nombre de la liste et finalement l’incrément entre chaque nombre généré.

Exemple:1

>>>print(list(range(0,10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
>>>range(5)
[0, 1, 2, 3, 4 ]
>>>range(10,40,5)
[10, 15, 20, 25, 30, 35 ]

Exemple:2

# Créer une liste dans une rangé de 10-20
Ma_liste = [range(10, 20, 1)]
# Imprimer la liste
print(Ma_liste)
Sortie :[range(10,20)]
Constat:1
• Comme nous pouvons le voir dans la sortie, le résultat n’est pas exactement ce à quoi nous nous attendions car Python ne décompresse pas le résultat de la fonction range().
• Nous pouvons utiliser l’opérateur de décompression d’arguments, c’est-à-dire * .

# Créer une liste dans une rangé de 10-20
Ma_liste = [*range(10, 21, 1)]
# Imprimer la liste
print(Ma_liste)
Sortie :[10,11,12,13,14,15,16,17,18,19,20]

Constat:2

• Nous pouvons utiliser la fonction extend() pour décompresser le résultat de la fonction

# Créer une liste dans une rangé de 10-20
Ma_liste = []
Ma_liste.extend(range(10, 20, 1))
Ma_liste.append(20)
# Imprimer la liste
print(Ma_liste)
Sortie :[10,11,12,13,14,15,16,17,18,19,20]

• Liste en compréhension et boucle for
• Une liste en compréhension est souvent construite sur la base d’une liste mais on peut construire une liste en compréhension sur la base de n’importe quel itérable.
• Une liste en compréhension admet un équivalent créé avec une boucle for mais nécessitant un code plus long.
• Soit la liste en compréhension L suivante :

t = [5, 2, 0, 3, 7, 10]
L = [10 * x for x in t]
print(L)
###Production###
[50, 20, 0, 30, 70, 100]

• La même liste pourrait être obtenue avec une boucle for :

t = [5, 2, 0, 3, 7, 10]
L = []
for x in t:
    L.append(10*x)
print(L)

• Listes en compréhension imbriquées
• Les listes en compréhension peuvent être imbriquées. Néanmoins la liste n’est pas forcément créée dans l’ordre où on s’y attendrait.
• Soit à créer une liste formée de tous "mots" commençant par une lettre A ou B et suivie d’un chiffre parmi 1, 2 ou 3. On peut utiliser une liste en compréhension :

L = [x+y for x in "AB" for y in "123"]
print(L)
###Production###
['A1', 'A2', 'A3', 'B1', 'B2', 'B3']

• Création d’une liste (tableau) par copie de tableau:

>>> tab=[1,2,3]
>>> T=tab
>>> Tableau=tab.copy()
>>> tab.remove(2)
>>> print(tab)
[1, 3]
>>> print(T)
[1, 3]
>>> print(Tableau)
[1, 2, 3]

• On peut la créer de façon exhaustive :

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

• On peut aussi utiliser les boucles :

>>> B=[[0 for j in range(10)] for i in range(3)]
>>> print(B)
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

>>> animaux = ['girafe ','tigre ','singe ','souris ']
>>> animaux [0]
'girafe '
>>> animaux [2]
'singe '
>>> animaux [4]
Erreur

Sources:
Livre Cours de Python,version du 9 mai 2019
Livre Apprenez à programmer en python VINCENT LE GOFF

• print(a[4::-2])
• La syntaxe de tranche [4::-2] commence par l’élément à index 4( ‘quux’) et continue jusqu’au début de la liste, en ignorant tous les autres éléments. Cela donne les éléments à indices 4, 2 et 0.
• print(a[-5:-3])
• [-5:-3] commence à l’index -5 et remonte à l’index mais non compris -3, qui désigne les éléments ‘bar’et ‘baz’.