[1 / (n + 1) for n in range(4)] ?]]>[expression for n in range(p)] fournit la liste des termesn prend les valeurs $0$ à $3$, soit $1$,range(4) commence à $0$, donc le premier terme estrange(4) produit quatre valeurs, de $0$ à $3$. Lesum.]]>[(a, b) for a in range(1, 4) for b in range(1, 3)] ?]]>range(1, 3) ne produit que $1$ et $2$, soit deuxf([3, -1, 4, -5, 2]) ?
def f(L):
R = []
for x in L:
if x > 0:
R.append(x)
return R[x for x in L if x > 0].]]>[3, 4, 2]]]>L et recopie dans R les[-1, -5]]]>x > 0 retient les éléments positifs, pas3]]>[2, 3, 4]]]>R n'est pas triée ; l'ordre de L estU contient les premiers termes d'une suite. Que teste ladef test(U):
for i in range(len(U) - 1):
if U[i + 1] < U[i]:
return False
return Truei s'arrête à len(U) - 2 pour que U[i + 1] existe. UnFalse dès qu'un terme estTrue sinon.]]>False. La fonction reconnaît l'ordre croissant.]]>L après ces instructions ?
L = [2, 4, 6, 8]
L.insert(1, 3)
del L[3]L.insert(i, x) place x à l'indice i en décalant la suite ;del L[i] supprime l'élément d'indice i.]]>[2, 3, 4, 8]]]>[2, 3, 4, 6, 8] ; l'élément d'indice $3$ est $6$,[2, 3, 4, 6]]]>del L[3] supprime l'élément d'indice $3$, pas le[2, 3, 6, 8]]]>[3, 2, 4, 6]]]>L.insert(1, 3) place la valeur $3$ à l'indice $1$,def dicho(a, b, e):
while b - a > e:
m = (a + b) / 2
if f(a) * f(m) <= 0:
b = m
else:
...
return a, ba = m]]>b = a]]>m = a]]>m ne change pas l'intervalle, et la bouclea = b]]>euler(n) renvoie une valeurdef euler(n):
h = 1 / n
y = 1
for k in range(n):
...
return yy = y + h * y]]>y = y + h]]>y = h * y]]>y = y * (1 + k)]]>rect(0, 1, 100) pour une fonction f continue surdef rect(a, b, n):
h = (b - a) / n
s = 0
for k in range(n):
s = s + h * f(a + k * h)
return sh : onrandom est importé. La fonction $f$ est continue surmc(100000), environ ?
def mc(n):
c = 0
for i in range(n):
x = random.random()
y = random.random()
if y <= f(x):
c = c + 1
return c / ny > f(x).]]>def rang():
u = 0
n = 0
while 6 - u > 0.01:
u = 0.5 * u + 3
n = n + 1
return nn, un rang, et non une valeur den, pas le terme u.]]>comb(n, k) qui renvoiecomb(n, k) p k (1 - p) ** (n - k)]]>comb(n, k) p k (1 - p) ** k]]>p * k (1 - p) ** (n - k)]]>comb(n, k) p k (1 - p) (n - k)]]>*.]]>pbin(n, p, k) renvoie $P(X = k)$ pourdef f(n, p, k):
s = 0
for i in range(k + 1):
s = s + pbin(n, p, i)
return srange(k + 1) va jusqu'à $k$ inclus, donc $P(X = k)$F(j) renvoie $P(X \leq j)$. Que renvoie la fonctiondef seuil(alpha):
k = 0
while 1 - F(k) > alpha:
k = k + 1
return krandom est importé. Que renvoie ech(50, 0.3) ?
def ech(n, p):
L = []
for i in range(n):
if random.random() < p:
L.append(1)
else:
L.append(0)
return Lsum(ech(n, p)) simule une variable de loi $\mathcal{B}(n, p)$ etsum(ech(n, p)) / n une fréquence observée.]]>sum.]]>random.random() avec $p$.]]>random est importé. Un pion part de $0$ et fait $n$ pasmarche(10) ?
def marche(n):
x = 0
for i in range(n):
if random.random() < 0.5:
x = x + 1
else:
x = x - 1
return xx part de $0$ et change de $\pm 1$ à chaque pas.x, qui n'est doncs(4) ?
def s(n):
t = 0
for k in range(1, n + 1):
t = t + (-1) ** (k + 1) / k
return trange(1, n + 1) va jusqu'à $k = 4$ ; le termeiter(n) se rapprochent-ils quand $n$ grandit ?
def iter(n):
u = 0
for k in range(n):
u = (u + 2) ** 0.5
return uR contient $10\,000$ résultats simulés d'une variablesum(R) / len(R) ?]]>print([k**2 for k in range(1, 5)]) ?]]>[expression for k in range(a, b)] construit la liste des valeursk de a à b - 1.]]>[1, 4, 9, 16]]]>range(1, 5) donne $1$, $2$, $3$, $4$, dont on[0, 1, 4, 9, 16]]]>range(1, 5) commence à $1$, pas à $0$.]]>[1, 4, 9, 16, 25]]]>[2, 4, 6, 8]]]>k**2 est le carré, pas le double.]]>sum([1/k for k in range(1, 4)]) ?]]>sum additionne les éléments d'une liste ; combinée à une1.83, soit $1 + \dfrac{1}{2} + \dfrac{1}{3}$]]>2.08, soit $1 + \dfrac{1}{2} + \dfrac{1}{3} + \dfrac{1}{4}$]]>range(1, 4) s'arrête à $3$.]]>0.83, soit $\dfrac{1}{2} + \dfrac{1}{3}$]]>6, la somme des entiers de $1$ à $3$]]>L = [3, -1, 4, -2, 5], que vaut len([x for x in L if x > 0]) ?]]>len : une façon3, le nombre d'éléments positifs]]>len compte ces trois éléments.]]>12, la somme des éléments positifs]]>len compte, il n'additionne pas ; sum donnerait5, la longueur de L sans filtre]]>if x > 0 écarte les deux négatifs.]]>[3, 4, 5], la liste filtrée]]>len en renvoie la longueur.]]>u = 1
L = [u]
for k in range(3):
u = 2 * u + 1
L.append(u)
print(L)append.]]>[1, 3, 7, 15]]]>[3, 7, 15, 31]]]>[1, 3, 7]]]>range(3) ajoute trois termes après $u_0$, soit[1, 2, 4, 8]]]>L = [4, 9, 2, 9], que vaut L.index(max(L)) ?]]>max donne la valeur, index sa première position : combinés, ils1, l'indice de la première occurrence de $9$]]>max(L) vaut $9$ et index renvoie la9, la valeur du maximum]]>index renvoie une position, pas une valeur.]]>3, l'indice de la dernière occurrence]]>index s'arrête à la première occurrence trouvée.]]>index accepte les répétitions ; il renvoie laL = [5, 2, 8]
M = sorted(L)
print(L, M)sorted(L) renvoie une copie triée ; L.sort() trie la listeNone.]]>[5, 2, 8] [2, 5, 8], sorted renvoyant une copie triée]]>sorted(L) construit une nouvelle liste triéeL intacte.]]>[2, 5, 8] [2, 5, 8], les deux listes triées]]>L.sort() qui trie L sur place.]]>[5, 2, 8] None, le tri ne renvoyant rien]]>L.sort() renvoie None, mais sorted(L) renvoiesorted s'appliquant seulement aux nombres triés]]>sorted accepte toute liste de nombres.]]>L = [3, 1, 4, 1, 5], que vaut sum(L[i] for i in range(0, len(L), 2)) ?]]>range fixe le pas du parcours.]]>12, la somme des éléments d'indices $0$, $2$ et $4$]]>range(0, 5, 2) parcourt $0$, $2$ et $4$, et2, la somme des éléments d'indices $1$ et $3$]]>14, la somme de tous les éléments]]>6, la somme des indices pairs]]>L[i], pas i.]]>len([(i, j) for i in range(4) for j in range(4) if i < j]) ?]]>i < j énumère les paires, sans6, le nombre de couples $(i, j)$ avec $i < j$]]>16, le nombre total de couples]]>if i < j n'en garde qu'une partie.]]>12, les couples d'éléments distincts]]>i < j élimine aussi les couples avec $i > j$, pas4, une valeur par i]]>i se combine avec plusieurs j.]]>L = [-3, -1, 2, 5, -2]
c = 0
for i in range(len(L) - 1):
if L[i] * L[i + 1] < 0:
c = c + 1
print(c)2, le nombre de changements de signe entre voisins]]>4, le nombre de paires de voisins]]>3, le nombre de valeurs négatives]]>1, un seul passage du négatif au positif]]>y = 1
h = 0.5
for i in range(2):
y = y + h * y
print(y)2.25, soit $1{,}5^2$]]>y par $1 + h = 1{,}5$ ;2.0, soit $1 + 2 \times 0{,}5$]]>1.5, un seul pas]]>range(2) fait deux tours.]]>2.718…, la valeur exacte $\mathrm{e}$]]>s = 0
n = 0
while 2 - s > 0.01:
s = s + 0.5 ** n
n = n + 1
print(n)8, nombre de termes pour approcher $2$ à $0{,}01$ près]]>7, le dernier rang où l'écart dépasse $0{,}01$]]>2, la limite de la somme]]>100, l'inverse de la précision]]>binom(10, 0.5) ?from random import random
def binom(n, p):
s = 0
for i in range(n):
if random() < p:
s = s + 1
return s0 et 10, le nombre de succès simulés]]>s compte les succès et suit la loi binomiale de5, l'espérance de la loi]]>0 et 1, la fréquence des succès]]>s, pas s / n.]]>10, le nombre d'épreuves]]>s ne compte que les tours où random() < p.]]>math.comb(n, k) le calcule.]]>15, donné par comb(6, 2)]]>comb du module math.]]>30, donné par 6 * 5]]>12, donné par 6 * 2]]>720, donné par factorial(6)]]>from math import comb
def p(n, k, q):
return comb(n, k) * q ** k * (1 - q) ** (n - k)
s = 0
for k in range(3):
s = s + p(10, k, 0.2)
print(1 - s)s, pas de 1 - s.]]>range(3) s'arrête à $k = 2$, donc $k = 3$ faitfrom random import random
def frequence(n, p):
c = 0
for i in range(n):
if random() < p:
c = c + 1
return c / n
nb = 0
for j in range(1000):
if abs(frequence(100, 0.5) - 0.5) > 0.1:
nb = nb + 1
print(nb / 1000)0.1, une petite minorité d'échantillons]]>0.5, la moitié des échantillons]]>0.0, la fréquence restant toujours dans l'intervalle]]>0.95, la plupart des échantillons]]>