Contents
Licence CC BY-NC-ND Thierry Parmentelat

les containers (1/2)

les listes

  • permet de créer une liste de n’importe quels objets

    • techniquement, c’est un tableau de pointeurs vers les objets

    • les listes sont dynamiques, de taille variable

    • comme une liste est un objet, on peut avoir une liste de listes

les listes

L = []
L = [4, 'bob', 10 + 1j, True]

L

[4, 'bob', (10+1j), True]

# les indices en python
# commencent à 0
L[2]

(10+1j)

L[0] = 10

L

[10, 'bob', (10+1j), True]

modification des listes

L

[10, 'bob', (10+1j), True]

L[2:]

[(10+1j), True]

L[2:] = [6, 7, 8, 'alice']
L

[10, 'bob', 6, 7, 8, 'alice']

L[1:4] = []
L

[10, 8, 'alice']

attention

  • L[i] = L2

    • remplace le i-ème élément de L par la liste L2

  • L[i:j] = L2

    • insère tous les éléments de la liste L2 à la position i

    • après avoir supprimé les éléments i jusqu’à j-1 dans L

modification des listes…

L = [1, 2, 3, 4, 5]
L

[1, 2, 3, 4, 5]

L[2:4] = [10, 11, 12]
L

[1, 2, 10, 11, 12, 5]

L[3] = [3, 4]
L

[1, 2, 10, [3, 4], 12, 5]

%load_ext ipythontutor

%%ipythontutor curInstr=1 width=800
L = [1, 2, 3, 4, 5]
L[2:4] = [10, 11, 12]
L[3] = [3, 4]

méthodes sur les listes

  • toutes les méthodes sur les séquences

  • optimisé pour les ajouts à la fin de la liste

L = []
for i in range(4):
    L.append(i)

while L:
    print(L.pop())

3
2
1
0

si nécessaire, envisager la liste doublement chainée

from collections import deque
deque?

méthodes sur les listes…

  • des méthodes spécifiques aux types mutables
    (modifications in-place)

    • L.append(x) ajoute x à la fin de L

    • L.extend(L2) ajoute chaque élément de L2 à la fin de L

    • L.insert(i, x) ajoute x à la position i

    • L.sort() trie L

    • L.reverse() renverse les éléments de L

méthodes sur les listes…

  • L.pop(i) supprime l’élément à la position i, si i n’est pas fourni, supprime le dernier élément. La fonction retourne l’élément supprimé

    • utilisé pour faire une pile d’éléments

  • L.remove(x) supprime la première occurrence de x dans L. S’il n’y a pas de x, une exception est retournée

  • del L[i:j:k] supprime tous les éléments entre i et j-1 par pas de k éléments

    • si i == j supprime l’élément i

digression: range()

  • range() est une fonction builtin ou native

  • qui retourne un objet itérateur

  • c’est-à-dire sur lequel on peut faire un for

  • on y reviendra longuement

for i in range(4):
    print(i, end=" ")

0 1 2 3

digression: range() …

  • essentiellement, même logique que le slicing

  • range(j) balaie de 0 à j-1

  • range(i, j) balaie de i à j-1

  • range(i, j, k) balaie de i à j-1 par pas de k

  • pour obtenir une liste on transforme (cast)
    en liste en appelant list()

for i in range(1, 21, 5):
    print(i, end=" ")

1 6 11 16 

list(range(1, 21, 5))

[1, 6, 11, 16]

méthodes sur les listes…

L = list(range(5))
L.append(100)
L

[0, 1, 2, 3, 4, 100]

# comme si append(10)
#     puis append(20)
L.extend([10, 20])
L

[0, 1, 2, 3, 4, 100, 10, 20]

L.remove(10)
L

[0, 1, 2, 3, 4, 100, 20]

L.sort()
L

[0, 1, 2, 3, 4, 20, 100]

tri sur les listes

  • le tri des listes est très puissant en Python

    • tri en place méthode list.sort()

  • il a aussi la fonction built-in sorted()
    qui trie toutes les séquences

L = [10, -5, 3, 100]

# tri en place
L.sort()
L

[-5, 3, 10, 100]

L1 = [10, -5, 3, 100]

# crée une copie
L2 = sorted(L1)
print(L1)
print(L2)

[10, -5, 3, 100]
[-5, 3, 10, 100]

  • https://docs.python.org/3.5/howto/sorting.html

avertissement sur les listes

  • outil très très pratique

  • mais parfois (souvent) pas nécessaire

  • car nécessite de la mémoire

  • alors qu’on veut juste itérer sur le contenu

  • dans ce cas, techniques + adaptées : itérateurs et autres générateurs

  • sujet avancé que l’on verra plus tard

les tuples

  • comme des listes, mais immutables

  • syntaxe: () au lieu de []

  • mais attention si un seul élément

# syntaxe pour un tuple vide
T = ()
T

()

# syntaxe pour un singleton
T1 = (4,)
# ou encore
T2 = 4,

T1 == T2

True

  • attention (4) est un entier et (4,) est un tuple

  • c’est la virgule qui est importante

  • on peut omettre les () - la plupart du temps
    (mais pas toujours malheureusement)

les tuples

# syntaxe pour plusieurs éléments
T1 = (3, 5, 'alice', 10+1j)

# ou encore
T2 =  3, 5, 'alice', 10+1j

# ou encore
T3 =  3, 5, 'alice', 10+1j,

T1 == T2

True

T1 == T3

True

  • un tuple est non mutable

  • ce qui le rend hashable :
    on peut l’utiliser dans un ensemble
    ou comme clé dans un dictionnaire

  • par contre bien sûr les fonctions faisant des modifications
    in-place ne s’appliquent pas aux tuples

try: 
    T1[3] = 5   # python n'est pas content
except Exception as exc:
    print(f"OOPS {type(exc)} {exc}")

OOPS <class 'TypeError'> 'tuple' object does not support item assignment
les nombres chaines et binaire (str et bytes)