Les types suivants ordonnent les données en repérant la position de chaque donnée par
son rang, appelé indice
(ou index). On dit qu'ils sont indexables.
C'est une séquence de caractères (lettre) repérés par un index (ou indice),
c'est à dire leur position dans la chaine,
en commençant par 0. On l'écrit entre simples ' ' ou doubles " ".
>> mot = "Python"
>>> mot = 'Python'
>>> mot[0] #la première lettre de mot
'P'
>>> mot[4] #la cinquième lettre de mot
'o'
>>> mot[1] = 'i' #on veut remplacer la deuxième lettre par 'i'
Traceback (most recent call last):
File "interactive input", line 1, in module
TypeError: 'str' object does not support item assignment
Une fois créée, la chaine "Python", ou 'Python', n'est pas modifiable. On parle de type
immuable ou immutable.
Un tuple consiste en une séquence de valeurs (ou données), pas obligatoirement du
même type, séparées par des virgules. Etant une séquence, un tuple est également
indexable.
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
On peut imbriquer des tuples :
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
Un tuple vide s'écrit ().
>>> monTuple = (1,2,3,4,5)
>>> monTuple[3]=2
Traceback (most recent call last):
File "interactive input", line 1, in module
TypeError: 'tuple' object does not support item assignment
Comme les chaines de caractère, les tuples sont immutables, c'est à dire qu'une fois créé,
il n'est pas possible de modifier les données présentes dans le tuple.
Il s'agit d'une suite, placée entre crochets [ ], de valeurs (ou données, on parle parfois
d'éléments), séparés par des virgules. Les éléments d'une liste ne sont pas
obligatoirement tous du même type, bien qu'à l'usage ce soit souvent le cas. Une liste est
également indexable.
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
>>> squares[0]
1
>>> squares[2] = 36 #remplace le 3eme élément par 36
>>>squares
[1, 4, 36, 16, 25]
La particularité des listes est de pouvoir changer le nombre et les valeurs des éléments
qu'elles contiennent. On dit que les listes sont mutables/muables, à la différence des str et
des tuples.
Indices négatifs :
Un indice négatif signifie que l'on partira de la fin :
>>>"Python"[-1]
'n'
>>>[1, 4, 9, 16, 25][-2]
16
>>>(1, 5, -2, 3)[-3]
5
Fonction len() : renvoie la longeur (nombre d'éléments) de l'argument. Vient de length
(longueur en anglais)
>>> len([1, 4, 9, 16, 25])
5
>>> len("Python")
6
>>> len((1,5,-2,3))
4
Opération de concatenation "+" :
>>> [1,4,9]+[16,25]
[1, 4, 9, 16, 25]
>>> "Pyt"+"hon"
'Python'
>>> (1,5)+(-2,3)
(1, 5, -2, 3)
Attention, le + ne désigne pas une addition mathématique, mais prend ici un autre sens.
On parle de surcharge de l'opération addition.
Opération de duplication "*" :
>>> [1,2]*4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> "Pyhton"*3
'PyhtonPyhtonPyhton'
>>> (3,-1)*5
(3, -1, 3, -1, 3, -1, 3, -1, 3, -1)
Attention, le * ne désigne pas une multiplication mathématique, mais prend ici un autre
sens. On a surchargé l'opération multiplication.
str, tuple et list sont subscriptables. Un type subscriptable est un type dont on peut
récupérer une partie en utilisant [ ] :
Un slice doit respecter la syntaxe [start:stop:step].
Exemples :
>>> "Python"[1:4] #En l'absence de :step, la valeur 1 est prise par défaut
'yth'
Remarque : l'indice de fin n'est pas sélectionné. Ici on s'arrête à la lettre h, soit l'indice 3.
>>> [1, 4, 9, 16, 25, 36, 49, 64][ : 4]
[1, 4, 9, 16]
Remarque : En l'absence de start, le premier indice est choisi par défaut.
>>> [1, 4, 9, 16, 25, 36, 49, 64][3 :]
[16, 25, 36, 49, 64]
Remarque : En l'absence de stop, le dernier indice +1 est choisi par défaut. Le slice ira
jusqu'à la dernière valeur.
>>>"Python"[1:6:2] #Un pas de 2 a été choisi
'yhn'
>>> [1, 4, 9, 16, 25, 36, 49, 64][1: :2]
[4, 16, 36, 64]
>>> [1, 4, 9, 16, 25, 36, 49, 64][ : : -1]
[64, 49, 36, 25, 16, 9, 4, 1]
Un pas négatif permet de parcourir la liste dans le sens inverse.
Astuce : [ : : -1] permet donc de renvoyer le type construit dans l'ordre inverse.
Voici une liste non exhaustive de quelques opérations (on parle de méthodes) que Python
autorise sur les listes :
Méthode append (x) : ajoute élément l'élément à la fin de la liste
>>> squares = [1, 4, 9, 16, 25 ]
>>> squares.append(36) # rajoute 36 à la fin
>>> squares
[1, 4, 9, 16, 25, 36]
Méthode insert(i,x) : insère l'élément x au rang i dans la liste
>>> squares = [1, 4, 9, 25, 36 ]
>>> squares.insert(3,16)
>>> squares
[1, 4, 9, 16, 25, 36]
Méthode pop(i) : retire et renvoi l'élément situé au rang i de la liste. Si i n'est pas spécifié
( pop() ), c'est le dernier élément de la liste qui est choisi par défaut.
>>> squares = [1, 4, 9, 16, 25, 36]
>>> squares.pop(2)
9
>>> squares
[1, 4, 16, 25, 36]
>>> squares.pop()
36
>>> squares
[1, 4, 16, 25]
Compréhensions de listes :
Il est possible de fabriquer une liste en donnant la "recette de fabrication".
>>> [ i**2 for i in range(1,6)]
[1, 4, 9, 16, 25]
Un dictionnaire est une structure de données particulière. Plutôt que d'utiliser un indice
pour référencer les valeurs
qu'il contient, il utilisera une clé unique. Cette clé peut être un
nombre, une chaine de caractère ou
n'importe quel autre type immutable.
Un dictionnaire vide s'écrit { }.
Exemple :
>>> tel = {'jack': 4098, 'sape': 4139} #Création du dictionnaire avec deux clé 'jack' et 'sape'
>>> tel['guido'] = 4127 #Insertion d'une nouvelle clé 'guido' avec sa valeur 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack'] #Renvoyer la valeur associée à la clé 'jack'
4098
>>> del tel['sape'] #Supprimer le couple clé:valeur associé à la clé 'sape'
>>> tel
{'guido': 4127, 'jack': 4098}
>>> tel['irv'] = 4127 #Insertion d'une nouvelle clé 'irv' avec sa valeur 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
Méthodes items, keys et values :
Renvoient respectivement les couples (clés, valeurs), les clés et les valeurs.
>>> tel.items()
dict_items([('guido', 4127), ('jack', 4098), ('irv', 4127)])
>>> tel.keys()
dict_keys(['guido', 'jack', 'irv'])
>>> tel.values()
dict_values([4127, 4098, 4127])
Pour les utiliser en tant que liste, il faut utiliser list ( ) comme suit :
list (tel.items()) , list(tel.keys()) et list(tel.values()).