append, longueur avec len,in, compréhensions, conversions[]), les tuples (avec()) et les dictionnaires (avec{}). Ils diffèrent par leurliste = []]]>liste = list().]]>liste = ()]]>liste = {}]]>liste = null]]>null n'existe pasNone, qui ne(1) est(1,) est un tuple àt = tuple[1, 2, 3], crochets après le mot tuple]]>tuple[...] avec des crochetstuple([1, 2, 3]).]]>t = (1, 2, 3), ou même t = 1, 2, 3]]>() et, pour unt = (1,).]]>t = {1, 2, 3}, les accolades regroupant les éléments]]>t = [1, 2, 3], puis t.freeze() pour le figer]]>freeze n'existe. Latuple(liste).]]>liste.append(x)tuple.append(x) provoque uneAttributeError.]]>("a", 1, [2])["a", "b", "c"][1] ?]]>len(liste) - 1. Un indiceIndexError.]]>"c"]]>"c" se trouve à"b"]]>"a"]]>"a","b".]]>len s'exécute enlen([]) vaut $0$, ce quiliste.size()]]>size n'existeliste.length]]>length n'existelen(liste)]]>lensize(liste)]]>sizeliste ?]]>append modifie la+ crée uneliste = liste + [4, 5, 6].]]>liste += 42]]>+= attend unliste += [42]append.]]>liste = liste + 42]]>+ ne sait pasTypeError.]]>liste.append(42)]]>liste = [1, 2]; liste.append(3),[1, 2, 3].]]>liste.add(42)]]>add est définiefor i in range(len(liste)):.i et de la valeurliste[i] à chaque tour de boucle.]]>for i in liste.length:
print(liste[i])]]>length n'existefor i in nombre: n'est pasprint liste]]>print est une fonction etfor x in liste:
print(x)]]>xwhile liste:
print(liste)]]>liste ?]]>for parcourtliste.has(42)]]>42 in liste]]>in renvoie un booléen indiquant la présence ouliste.find(42)]]>find est définieliste.contains(42)]]>contains(x, y),return a, b, ou("Alice", 17, "Lyon").]]>l = [1, 2, 3]
l.append(4)
print(len(l))append modifie lal = l.append(4) :append ne renvoie rien (laNone),l se retrouverait àNone.]]>5]]>3]]>append.]]>4]]>[1, 2, 3]. Aprèsl.append(4), elle vaut[1, 2, 3, 4], donc sat = [10, 20, 30, 40, 50]. Que vaut[t[i] for i in range(1, 4)] ?]]>range(a, b), la borne ab[t[i] for i in range(a, b)]a à b - 1.]]>[10, 20, 30]]]>t[1] désigne le deuxième[20, 30, 40]]]>range(1, 4) produit les indices[1, 2, 3]]]>range(1, 4). Lait[i], l'élément situé à[20, 30, 40, 50]]]>range esta,b et c après l'instruction(a, b, c) = (1, 2, 3) ?]]>f() renvoie (4, 7),x, y = f() affecte $x = 4$ et $y = 7$.]]>((1, 2, 3),)]]>a, b, c = 1, 2, 3. Cettea, b = b, a.]]>l = [10, 20, 30]. Quelle expressionl sauf le dernier, quelle que soit lal ?]]>[l[i] for i in range(n)],n - 1. En prenantlen(l) - 1 comme borne, on s'arrête juste avant[l[i] for i in range(1, len(l))]]]>len(l) - 1, ce qui retire le premier[20, 30].]]>[l[i] for i in range(len(l) - 1)]]]>range(len(l) - 1) produitlen(l) - 2, soit tous[10, 20] dans une nouvelle liste ; l n'est[l[i] for i in range(len(l) - 2)]]]>len(l) - 2 étant exclue,len(l) - 3 et les[10].]]>l[len(l) - 1]]]>l[len(l) - 1] est ledef bornes(notes):
mini = notes[0]
maxi = notes[0]
for n in notes:
if n < mini:
mini = n
if n > maxi:
maxi = n
return (mini, maxi)
resultat = bornes([12, 8, 15, 10])resultat après l'exécution de ce code ?]]>resultat[0] et resultat[1],bas, haut = bornes([12, 8, 15, 10]).]]>(8, 15)]]>return (mini, maxi) renvoie unresultat.]]>[8, 15]]]>return (mini, maxi) construisent un8]]>return ne s'arrête pas à la première valeur. Il renvoie(mini, maxi), qui contient les deux notes.]]>(15, 8)]]>return (mini, maxi) : d'abord le minimum, puis le maximum.]]>liste.sort() et sorted(liste) ?]]>sortedsort (« trier »)None.]]>sort est nettement plus lente à l'exécution]]>sorted(liste) appelle liste.sort()]]>sorted construit unesort modifie la liste surNone.]]>sorted ne fonctionne que sur des nombres]]>sortedsort modifie la liste, sorted renvoie une copie triée]]>sort trie sur placeNone, sorted renvoie unesorted ; sinon, sortsortedsort.]]>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100][expression for i in range(a, b)] construitia à b - 1. Elle équivaut à uneappend. Les deux erreurs*, etrange.]]>[i ** 2 for i in range(1, 11)]]]>range(1, 11) parcourt lesi ** 2[i * 2 for i in range(1, 11)]]]>i 2 est le double de i, pas[2, 4, 6, 8, 10, 12, 14, 16, 18, 20].i 2 ou i i.]]>[i ** 2 for i in range(10)]]]>range(10) commence à $0$ et[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] :[i ** 2 for i in range(1, 10)]]]>range estrange(1, 10) s'arrête à[1, 4, 9, 16, 25, 36, 49, 64, 81], sansa = [1, 2, 3]
b = a
b.append(4)
print(a)b = a n'a pas[4]]]>append[1, 2, 3]]]>b = a ne[1, 2, 3, 4]]]>a et bb = [x for x in a].]]>l = [1, 2, 3]
for x in l:
x = x * 2
print(l)for i in range(len(l)): l[i] = l[i] * 2. Lax d'un for x in l n'est qu'un nom[2, 4, 6]]]>x = x 2 crée un nouvel entier et lex, sans rien écrire dans la liste.l[i] = l[i] 2 en parcourant les indices.]]>[1, 2, 3]]]>x[1, 2, 3, 2, 4, 6]]]>l. Seule la méthode append allongerait lax.]]>len((42)) ?]]>type((42)) renvoie int,type((42,))tuple.]]>(42) est considéré comme vide]]>(42) n'est pas un tuple dulen lève une exception sur unTypeError]]>(42) n'est pas un tuplelen n'agit pas sur un entier. Pour créer(42,).]]>len ne renvoie pas la valeur(42) n'est pas un(42) n'estl = [1, 2, 3]
m = l
l = l + [4]
print(m)l.append(4) et l += [4]m ;l = l + [4] réaffecte l à une nouvelle listem.]]>[1, 2, 3, 4]]]>m suivrait l si la listel.append(4) oul += [4]. Mais l + [4] construit unel reçoit ; m désigne[1, 2, 3, [4]]]]>+ concatène les éléments[4], et surtout ilm n'en voit rien.]]>[1, 2, 3]]]>m = l, les deux nomsl + [4] crée[1, 2, 3, 4], affectée àl seul. m garde l'ancienne liste, intacte.]]>+ entre deux listes est défini etl + 4,TypeError.]]>eleves = [("Ana", 12), ("Bilal", 9), ("Chloé", 15)],eleves[1] = ("Bilal", 11). Toute tentative deeleves[1][1] = 11]]>eleves[1] est le p-uplet("Bilal", 9), et un p-uplet est immuable.TypeError: 'tuple' object does not support item assignment.]]>eleves[1] = ("Bilal", 11)]]>[("Ana", 12), ("Bilal", 11), ("Chloé", 15)].]]>eleves["Bilal"] = 11]]>TypeError: list indices must be integers or slices, not str.]]>eleves[1].append(11)]]>eleves[1] est un p-uplet, qui n'aappend. Python lèveAttributeError: 'tuple' object has no attribute 'append'.JOURS = ("lun", "mar",
"mer", ...). Le lecteurlen]]>s[0] ou len(s)liste = [] crée une liste vide ; t = () crée un tuple vide]]>t = [10, 20, 30, 40, 50] etr contenant[50, 40, 30, 20, 10]. Quel code convient ?]]>len(t) - 1 - i.t n'est pas modifiée.]]>r = []
for x in t:
r.append(x)]]>r dans l'ordre de parcours. On obtient une[10, 20, 30, 40, 50].]]>r = []
for x in t:
r = [x] + r]]>[x] + r placer vaut successivement [10], [20, 10],[30, 20, 10], jusqu'à [50, 40, 30, 20, 10].]]>r = []
for i in range(len(t) - 1):
r.append(t[len(t) - 1 - i])]]>len(t) - 1 - i lit bien larange(len(t) - 1) ne[50, 40, 30, 20] oublie le premier élément, $10$.]]>r = []
for i in range(len(t)):
r.append(t[len(t) - i])]]>t[len(t) - 0] vautt[5], hors de la liste, d'où une IndexError.t[len(t) - 1 - i].]]>t = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
compteur = 0
premier = -1
for i in range(len(t)):
if t[i] == 5:
compteur = compteur + 1
if premier == -1:
premier = i
print(compteur, premier)range, signale que la valeur n'a pas encore3 10]]>premier == -1 n'est vrai qu'au premier $5$ rencontré ; ensuitepremier vaut $4$ et n'est plus modifié.]]>3 4]]>premier ne reçoit un indice que tant3 5]]>4 3]]>compteur vaut le nombrepremier l'indice de la première, $4$ ;print les affiche dans cet ordre.]]>a = [1, 2, 3]
b = [4, 5]
a.append(b)Que vaut la liste a après cette exécution ?
a.append(x)x à la fin de a comme un seul élément,a sur place ; a + b produit uneab, sans modifier ni a ni b.[1, 2, 3, 4, 5] dans a, on écrita = a + b. Confondre les deux est l'une desappend accepte n'importe[1, 2, 3, [4, 5]]]]>append ajoute son paramètreb est lui-même une liste, on obtient[1, 2, 3, 4, 5]]]>a = a + b, qui enchaîne les éléments de ba. La méthodeappend, elle, ajoute son paramètre comme un[[1, 2, 3], 4, 5]]]>append ajoute en fin de liste,b qui est ajouté, pasa.]]>eleve = ("Ana", 15, True)("Ana", 15, True) sel = [1, 2, 3] ?]]>tuple(l) dans un sens, list(t) danst = tuple(l)]]>tuple(l) construit unlist(t).]]>t = l.tuple()]]>tuple. La conversion se faittuple.]]>t = (l)]]>t reste lat = l.freeze()]]>a = 1
b = 2
a, b = b, a
print(a, b)b, a, ce qui donne (2, 1),a, b. D'où2 1]]>(2, 1),a et b. L'échange se fait1 2]]>2 2, car a est écrasé avant d'être lu]]>a = b puis b = a). Ici la partiet = (3, 1, 4, 1, 5).count et index.append, sort, remove)t.count(1), qui renvoie $2$]]>count compte lesindext.append(9), qui ajoute $9$ à la fin]]>append modifierait leAttributeError.]]>t.sort(), qui range les valeurs dans l'ordre]]>sort trie sur place, doncsorted(t), qui renvoie une nouvellet[0] = 7, qui remplace le premier élément]]>TypeError.]]>t = (10, 20, 30)
for i in range(len(t)):
print(t[i])for v in t, ou avec len. La seule10, 20 puis 30, une valeur par ligne]]>0, 1 puis 2, c'est-à-dire les indices]]>t[i] désigne la valeuri, pas l'indice(10, 20, 30) en une seule ligne]]>print est à l'intérieurt = (1, 2)
u = t + (3,)
print(t, u)t += (3,) ne fait pas exception, cettet.]]>(1, 2) (1, 2, 3)]]>u,t. C'est la seule(1, 2, 3) (1, 2, 3)]]>t n'est pas modifié, unu(1, 2) (1, 2, (3,))]]>+ entre deux tuples meteleves = [("Ana", 12), ("Bilal", 9)]
for prenom, note in eleves:
print(prenom, note)prenom et noteeleve[0] et eleve[1]prenom et le secondnote.]]>for eleve in eleves puis eleve[0]]]>point = (3, 7) et l'onpoint = (5, point[1])]]>point[0] = 5]]>TypeError, un tuplepoint.modifier(0, 5)]]>point.append(5) puis on retire l'ancienne valeur]]>append n'existe pas sur unt = ([1, 2], 3)
t[0].append(9)
print(t)([1, 2, 9], 3)]]>([1, 2], 3), la modification étant perdue]]>append modifie bien la([1, 2], 3, 9)]]>sorted([(2, "b"), (1, "z"), (2, "a")]) ?]]>[(1, 'z'), (2, 'a'), (2, 'b')]]]>[(1, 'z'), (2, 'b'), (2, 'a')]]]>'a' passe avant'b'.]]>[(2, 'a'), (2, 'b'), (1, 'z')]]]>append.]]>t = (10, 20, 30, 40, 50).t[1:3] ?]]>t[1:3] se lit « de(20, 30)]]>[20, 30], car une tranche renvoie toujours une liste]]>(20, 30, 40), les deux indices étant inclus]]>l = [3, 1, 4, 1, 5]
l.remove(1)
print(l)remove travaille sur[3, 4, 1, 5]]]>remove retire la[3, 4, 5], les deux $1$ ayant disparu]]>remove autant de fois qu'il y a de[1, 4, 1, 5], le premier élément étant retiré]]>remove prend une valeur,[3, 1, 4, 1, 5], remove renvoyant une nouvelle liste]]>remove modifie la liste surnotes contient $12$ valeurs.notes[len(notes) - 1]]]>notes[len(notes)], la longueur servant d'indice]]>IndexError.]]>notes[12], puisque la liste compte douze valeurs]]>notes.dernier()]]>carres = []
for i in range(1, 5):
carres.append(i * i)
print(carres)append par tour. Le résultat se lit[1, 4, 9, 16]]]>i[1, 4, 9, 16, 25]]]>range(1, 5) s'arrête à $4$,[0, 1, 4, 9, 16]]]>16, seule la dernière valeur étant gardée]]>append ajoute sans écraser,list(range(2, 9, 2)) ?]]>range ne crée pas une liste mais unelist la[2, 4, 6, 8]]]>[2, 4, 6, 8, 10]]]>[2, 3, 4, 5, 6, 7, 8]]]>[0, 2, 4, 6, 8]]]>l = [4, 7, 2]
for v in l:
print(v)
for i in range(len(l)):
print(l[i])l[i], c'est-à-dire la valeur rangée ài.]]>range(len(l)) produitl[i] désigne un élément, pasnotes = [12, 15, 9]
total = 0
for n in notes:
total = total + n
print(total)36]]>12]]>total était réaffecté à chaque tour[12, 15, 9]]]>total est un nombre, pas une9]]>valeurs = [3, 9, 4]
m = valeurs[0]
for v in valeurs:
if v > m:
m = v
print(m)m avecvaleurs[0] ?]]>notes = [8, 14, 11, 5].append en une ligne.]]>[n for n in notes if n >= 10]]]>[14, 11].]]>[n if n >= 10 for n in notes]]]>[notes if n >= 10], sans boucle explicite]]>for, qui[n >= 10 for n in notes], qui teste chaque note]]>[False, True, True,
False], et non les notes elles-mêmes.]]>grille = [[1, 2, 3], [4, 5, 6]]
print(grille[1][2])6]]>grille[1] désigne la[4, 5, 6], et [2] en3]]>grille[0][2], sur[4, 5, 6]]]>2, l'élément d'indice $1$ dans la liste aplatie]]>original = [1, 2, 3]
copie = original[:]
copie.append(4)
print(original, copie)copie = originalcopie = original[:][1, 2, 3] [1, 2, 3, 4]]]>[1, 2, 3, 4] [1, 2, 3, 4]]]>copie = original, qui donne deux noms[1, 2, 3] [4]]]>original[:] est une écrituret = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
Combien de lignes et de colonnes possède le tableau
t ?
len(t) donnelen(t[0]) le nombre delen(t) vaut $4$ (quatre listes intérieures) etlen(t[0]) vaut $3$.]]>t[0] est[0, 1, 2].]]>grille = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
grille[2][0] = 0
print(grille)
Qu'affiche ce programme ?
]]>grille[i][j] se lit de gauche à droite :grille[i] sélectionne la ligne d'indice i, puis[j] la colonne. Les indices commencent à $0$ :[[1, 2, 3], [4, 5, 6], [0, 8, 9]]]]>grille[2] est la troisième ligne, [7, 8, 9],[0] en désigne le premier élément.]]>[[0, 2, 3], [4, 5, 6], [7, 8, 9]]]]>grille[0][0] = 0 ; le premier indice[[1, 2, 0], [4, 5, 6], [7, 8, 9]]]]>[[1, 2, 3], [4, 5, 6], [7, 8, 0]]]]>[0] désigne le premier élément de la ligne, past = [[1, 2], [3, 4], [5, 6]]
total = 0
for i in range(len(t)):
total = total + t[i][1]
print(total)
Qu'affiche ce programme ?
]]>12]]>t[i][1] est le deuxième élément de chaque9]]>21]]>6]]>total.]]>m = [[0 for j in range(3)] for i in range(2)]
Quelle valeur reçoit m ?
[0 for j in range(3)] construit unei. C'est la façon sûre de[[0, 0, 0], [0, 0, 0]]]]>[[0, 0], [0, 0], [0, 0]]]]>range(2) est à l'extérieur : il fixe le nombrerange(3) le nombre de[0, 0, 0, 0, 0, 0]]]>[[0, 1, 2], [0, 1, 2]]]]>0, pas j ; laj ne sert qu'à répéter trois fois.]]>ligne = [0, 0, 0]
m = [ligne, ligne]
m[0][0] = 5
print(m)
Qu'affiche ce programme ?
]]>[ligne, ligne] ne copie pas ligne : il range[[0 for j in range(3)] for i in range(2)].]]>[[5, 0, 0], [0, 0, 0]]]]>[[5, 0, 0], [5, 0, 0]]]]>m[0] et m[1] désignent la même listeligne ; la modifier par l'une se voit par[[0, 0, 0], [0, 0, 0]]]]>m[0][0] = 5 modifie bien ladivision(a, b) doit renvoyer à la fois le quotienta par b. Quellereturn q, r construit le tuple etq, r = division(a, b) le décompose.]]>(q, r), décomposé par q, r = division(a, b)]]>return successives, une par valeur]]>return termine la fonction."q,r" que l'appelant découpe et reconvertit]]>reglages[0] = 50 provoquerait une erreur, ce quireglages[0] = 50 dans la fonctionL = [10, 20, 30, 40, 50, 60].L[1:4] ?]]>L[a:b] contient les éléments d'indicerange(a, b).]]>[20, 30, 40]]]>[20, 30, 40, 50], les deux bornes étant incluses]]>range(1, 4).]]>[30, 40, 50], les indices commençant à $1$]]>20.]]>[20, 50], formée des deux éléments aux bornes]]>L = [3, 1, 4, 1, 5, 9].L[:2] ?]]>L[:k] donne les[3, 1]]]>[4, 1, 5, 9]]]>L[2:]. Ici, le nombre[3, 1, 4], l'indice $2$ étant inclus]]>[5, 9], les $2$ derniers éléments]]>L[-2:]. Sans signe moins, on partL = [10, 20, 30, 40, 50].L[2:] ?]]>len(L) : L[k:]L[:k], les deux tranches[30, 40, 50]]]>len(L). On prend tout à partir de[10, 20]]]>L[:2], les éléments[40, 50], l'indice $2$ étant exclu]]>[30], réduite à l'élément d'indice $2$]]>L = [2, 4, 6, 8, 10].L[-2:] ?]]>L[-k:] donne les $k$ derniers éléments,L[:-k] tout sauf ces $k$ derniers.]]>[8, 10], les $2$ derniers éléments]]>[2, 4], les $2$ premiers éléments]]>[2, 4, 6], tout sauf les $2$ derniers]]>L[:-2], où $-2$ est[10, 8], les $2$ derniers dans l'ordre inverse]]>s = "bonjour".s[1:-1] ?]]>s[1:-1] retire le premier et le dernier'onjou']]>'o') et on s'arrête avant le'bonjou']]>'b' a l'indice'onjour']]>L = [10, 11, 12, 13, 14, 15, 16].L[1::2] ?]]>L[début:fin:pas] : le pas est l'écartL[::2] prendL[1::2] les indices[11, 13, 15]]]>[10, 12, 14, 16]]]>[11], le $2$ étant la fin]]>[13, 14, 15, 16], le $2$ s'ajoutant au début]]>mot = "python".mot[::-1] ?]]>mot[::-1] renvoie la séquence à'nohtyp']]>'pytho', sans le dernier caractère]]>mot[:-1]. Ici, $-1$'n', le dernier caractère]]>mot[-1], un accès à un'ython', sans le premier caractère]]>mot[1:]. Un pasdef est_palindrome(mot):
return mot == mot[::-1]
print(est_palindrome("kayak"))
print(est_palindrome("radis"))mot == mot[::-1] le testeTrue puis False]]>"kayak" se lit de la"radis", qui donne "sidar".]]>True puis True]]>"radis"[::-1] vaut "sidar","radis".]]>False puis False, mot[::-1] ne changeant rien]]>L = ['a', 'b', 'c', 'd']
x = L[1]
y = L[1:2]x et y ?]]>L[1:2] + 1 siL contient des nombres.]]>x vaut 'b' et y vaut ['b']]]>L[1] est un élément,L[1:2] est une liste qui contient cetx et y valent tous deux 'b']]>x et y valent tous deux ['b']]]>x vaut 'b' et y vaut ['b', 'c']]]>L = [1, 2, 3, 4].L[2:10] ?]]>L[i], une tranche ne[3, 4]]]>IndexError, l'indice $10$ n'existant pas]]>L[10], provoque IndexError.[3, 4, None, None, None, None, None, None]]]>[]]]>L = [5, 6, 7, 8, 9].L[3:1] ?]]>[]]]>[8, 7], parcourue à l'envers]]>L[3:1:-1], pour aller vers la gauche.]]>[6, 7], les bornes étant remises dans l'ordre]]>[6, 7] est L[1:3].]]>L = [1, 2, 3, 4]
T = L[1:3]
T[0] = 99
print(L)L[:] sert à[1, 2, 3, 4]]]>T est une nouvelle[2, 3]. La modifier ne changeL.]]>[1, 99, 3, 4]]]>T était[99, 2, 3, 4]]]>T[0] est le premier élémentT, et T est de toute façonL.]]>T est une liste ordinaire, onL = ['a', 'b', 'c', 'd', 'e']
L[1:3] = ['X', 'Y', 'Z']
print(L)['a', 'X', 'Y', 'Z', 'd', 'e']]]>'b' et 'c') sont remplacés['a', 'X', 'Y', 'd', 'e'], la liste gardant sa taille]]>['a', 'X', 'Y', 'Z', 'e']]]>'d's = "python"
s[0:2] = "PY"+.]]>TypeError : une chaîne ne se modifie pas]]>s = "PY" + s[2:].]]>s devient 'PYthon']]>s devient 'PYpython', "PY" étant inséré au début]]>s reste 'python', sans message d'erreur]]>L = [1, 2, 3, 4, 5].L[2:] + L[:2] ?]]>L[k:] + L[:k] fait tourner la liste de[3, 4, 5, 1, 2]]]>[4, 5, 1, 2, 3]]]>L[-2:] + L[:-2].]]>[1, 2, 3, 4, 5], inchangée]]>[3, 4, 5]]]>+ met bout à bout les deuxT = ('a', 'b', 'c', 'd', 'e').T[::2] ?]]>('a', 'c', 'e')]]>T.]]>['a', 'c', 'e']]]>('b', 'd')]]>T[1::2]. Sans début, on part de('a', 'b'), les deux premiers éléments]]>T[:2].]]>