Une liste est un objet mutable (contrairement par exemple aux
tuples).
Une première façon de créer une liste (par extension : on liste
les éléments de la liste)
Une liste de 3 éléments1, 2 et 3 :
[1, 2, 3]
Une liste de listes :
[[1, 2, 3], [4, 6], [9, 2, 0]]
Une liste vide :
[]
Attention, à bien utiliser des crochets et non des parenthèses ou
des accolades :
(1, 2, 3) est un tuple (donc non
mutable) et non une liste (qui elle est mutable)
Une deuxième façon de créer une liste (par intension (en
anglais "comprehension") :
on donne une règle, un prédicat)
l1 = [i **2 for i in range (1,100)] #
les puissances de i pour i allant de 1 à 100, non inclus
l2 = [sqrt(x) for x in srange(0, 10,
.1)] # La racine carrée de x pour x allant de 0 à 10 non
inclus, par pas de 0.1, à savoir 0.0, 0.1, 0.2, 0.3, ....
[i for i in rang
(1,n) if predicat(i)] # on ne garde que les i qui satisfont au
prédicat
[x + y for x in l1
for y in l2] # on
somme tous les couples de x et de y, x appartenant à l1 et y à
l2
Quel est le nombre d'entiers inférieurs à
100 (donnez la liste de ces entiers) tel que la
différence entre
n'importe quel couple de ces entiers n'est jamais
un carré?
sage: carres=[i*2
for i in range(sqrt(n))]]
#liste des carrés des nombres entiers
inférieurs à racine carrée de 100
sage:
edges=[(i,j) for (i,j) in
CartesianProduct(range(n),range(n)) if
(i!=j and abs(i-j) in carres)]
# on construit une liste de tuples pour
définir les arêtes du graphe. Le
prédicat traduit bien l'énoncé. Une arête entre deux sommets
dont la différence est un
carré
# L'utilisation du produit cartésien était inutile on pouvait
écrire :
# sage:
edges=[(i,j) for i range(n) for j in range(n) if (i!=j
and abs(i-j) in carres)]
sage:
g.add_edges(edges) # on ajoute les arêtes au graphe
sage:
g.independent_set() # Cette
fonction nous
donne les sommets non reliés
Accès à un élément ou à une tranche (valable pour toutes les
séquences)
Attention, ce qui pour certains autres langages est hérétique, il
n'y a jamais d'erreur de déclenchée!!!!!
s[i]
ième élément de s
s[i:j]
sous-séquence de
s des éléments i à j (j non
inclus)
s[i:j:k]
sous-séquence de
s des éléments i à j avec un
incrément de
valeur k (j non inclus)
len(s)
longueur de s
Les méthodes applicables à une liste
l.insert(pos, elt) a pour effet d'insérer un élément elt
à la position pos
pos ==0, on insère en tête, en position 0,
pos == len(l) on insère après le dernier élément (le
dernier élément est en position len(l)-1). C'est donc
équivalent à l.append(elt)
Autres valeurs de pos? Valeurs de pos négatives?
l.extend(L) où L est une liste a pour effet de rallonger
la liste l en ajoutant à la fin tous les éléments de la liste
donnée ; cela a le même effet que l'opération suivante
utilisant la notation de tranche - slice (l[len(a):] = L.
l.remove(elt) a pour effet d'enlever le premier élément
de la liste dont la valeur est elt. Si l'opération enlève
effectivement un élément, la longueur de la liste diminue de 1.
L'exception
value_error est déclenchée si elt n'est pas présent.
l.pop([i]) a pour effet d'enlever l'élément présent à la
position donnée dans la liste, et le renvoie. Si aucun indice
n'est spécifié, a.pop() renvoie le dernier élément de la liste.
L'élément est aussi supprimé de la liste.
l.index(x) a pour effet de retourner l'indice dans la
liste du premier élément dont la valeur est x. Il y a erreur si
cet élément n'existe pas.
l.count(x) a pour effet de renvoyer le nombre de fois
que x apparaît dans la liste.
l.sort() a pour effet de trier les éléments à
l'intérieur de la liste.
l.reverse() a pour effet d'inverser l'ordre des éléments
à l'intérieur de la liste.
Une liste peut en fait être utilisée comme une pile
Une liste peut être utilisée comme une file, par exemple une
file PAPS (Premier Arrivé - Premier Servi - FIFO - First In First
Out)
Soit 6 fonctions sur x, à
savoir, f,g, h, i, j et k. On veut résoudre un système de 3
équations (le système est passé en paramètre à la
fonctionsolve sous forme
d'un liste de 3 éléments).
Le résultat est donné sous forme d'une liste de valeurs.
Liste vide : pas de solutions
....
liste des résultats = solve ([f == g, h
== i, j == k), x)
Participants
