S'inspirer de l'exemple de la somme calculée dans le cours : on initialise ici une variable produit à 1, et on multiplie la valeur de chaque élément successif dans le tableau par la valeur précédente de produit :
def produit(t: list)->int :
produit = 1
for nombre in t : # parcours par valeur des éléments du tableau
produit = produit * nombre
return produit
nombres = [2, 3, 2]
print(produit(nombres))
S'inspirer de l'inversion d'une chaîne de caractères faite dans le chapitre sur les chaînes.
L'idée : on parcourt le tableau élément par élément, et on concatène chacun de ses éléments au début du nouveau tableau ( préalablement initialisé, bien sûr ! ) :
def inverse_tableau(t : list)->list :
t_inverse = [] # tableau initialement vide
for elt in t :
t_inverse = [elt] + deuxieme # attention au type de 'elt' : ce doit être un élément de tableau, pas une valeur "seule"
return t_inverse
t1 = [12, 56, 6, 1, 78, 96]
print(inverse_tableau(t1))
Comme ici on concatène un tableau après un élément, on ne peut donc pas utiliser la fonction append(), qui concatène un élément à la fin d'un tableau...
Version 1 :
def analyse_ADN(tab: list)->int :
a = 0
for gene in tab:
if gene == 'A':
a = a + 1
return a
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
print(analyse_ADN(ADN))
Version 2 :
def analyse_ADN(tab: list)->tuple :
a = 0 # une variable compteur pour chacun des 4 types de gène
t = 0
c = 0
g = 0
for gene in tab :
if gene == 'A':
a += 1
elif gene == 'T':
t += 1
elif gene == 'C':
c += 1
else : # ça ne peut être qu'un des 4 gènes !
g += 1
return a, t, c, g # renvoi des 4 résultats sous forme d'un tuple ( les parenthèses ne sont pas obligatoires )
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
analyse = analyse_ADN(ADN) # on récupère les résultats dans un tuple 'analyse'
print("Nombre de gènes 'A' :", analyse[0]) # le résultat pour le gène 'A' correspond au premier élément du tuple
print("Nombre de gènes 'T' :", analyse[1]) # celui pour 'T' au deuxième
print("Nombre de gènes 'C' :", analyse[2]) # celui pour 'C' au troisième
print("Nombre de gènes 'G' :", analyse[3]) # et celui pour 'G' au quatrième
Version 3 :
def analyse_ADN(tab: list)->tuple :
a = 0 # une variable compteur pour chacun des 4 types de gène
t = 0
c = 0
g = 0
for gene in tab :
if gene == 'A':
a += 1
elif gene == 'T':
t += 1
elif gene == 'C':
c += 1
else : # ça ne peut être qu'un des 4 gènes !
g += 1
n = len(tab) # nombre total de gènes dans le tableau
a = (a / n)*100 # calcul des pourcentages
t = (t / n)*100
c = (c / n)*100
g = (g / n)*100
return a, t, c, g # renvoi des 4 résultats sous forme d'un tuple ( les parenthèses ne sont pas obligatoires )
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
analyse = analyse_ADN(ADN)
# on récupère les résultats dans un tuple 'analyse'
print("Pourcentage de gènes 'A' :", analyse[0]) # le résultat pour le gène 'A' correspond au premier élément du tuple
print("Pourcentage de gènes 'T' :", analyse[1]) # celui pour 'T' au deuxième
print("Pourcentage de gènes 'C' :", analyse[2]) # celui pour 'C' au troisième
print("Pourcentage de gènes 'G' :", analyse[3]) # et celui pour 'G' au quatrième
Ici, pour compter les différences, il faut parcourir les deux tableaux "parallèlement", c'est à dire en adressant chacun de leurs éléments de même indice en même temps : on ne peut donc pas faire ici de parcours par valeur, puisque celui ci ne permettrait le parcours que d'un seul tableau à la fois.
C'est donc un parcours par indice qu'il faut faire ici :
def compter_differences(t1: list, t2: list)-> int :
differences = 0 # variable compteur du nombre de différence
for i in range(len(t1)): # ou len(t2), les deux tableaux ont le même nombre d'éléments
if t1[i] != t2[i]: # attention, on compare les valeurs des éléments, pas leur indice ( c'est le même ici ! ) !
differences = differences + 1
return differences
tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']
tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']
print(compter_differences(tab_1, tab_2))
Même problème que précédemment : un parcours par indice est indispensable.
def moyenne_coefficient(notes: list, coeffs: list)->float :
somme_notes = 0
somme_coeff = 0
for i in range(len(notes)):
somme_notes = somme_notes + notes[i]*coeffs[i] # somme des notes pondérées par leur coefficient
somme_coeff = somme_coeff + coeffs[i] # somme total des coefficients
return somme_notes / somme_coeff # calcul de la moyenne
notes = [10, 10, 20]
coeffs = [1, 3, 1]
print(moyenne_coefficient(notes, coeffs))
Attention, problème pas évident !
imax + 1 = n - 1, ce qui conduit à : imax = n - 2 : il faut donc parcourir le tableau de son éliment d'indice 0,
jusqu'à son élément d'indice n - 2.for ... i n range(), on devra donc écrire pour le parcours : for i in range(len(t)-1)t[i+1] - t[i]; si celle-ci est positive, alors on l'ajoute à un compteur de dénivelées positives,
si elle est négative, on l'ajoute à un compteur de dénivelée négatives, si elle est nulle, on ne fait rien !
def compter_deniveles(t : list)->tuple :
d_plus = 0 # compteurs pour les dénivelées cumulées positive
d_moins = 0 # et négative
for i in range(len(t)-1): # pour i variant de 0 à n - 2
d = t[i+1] - t[i] # calcul de la dénivelée entre deux altitudes successives
if d > 0: # si elle est positive,
d_plus = d_plus + d # on l'ajoute à la dénivelée cumulée positive,
elif d < 0: # si elle est négative,
d_moins = d_moins + d # à la dénivelée cumulée négative.
return d_plus, d_moins # renvoi des deux résultats sous forme d'un tuple de deux éléments
altitudes = [3, 7, 8, 9, 1, 0, 7, 8, 9, 3, 7, 8, 9, 4, 6, 1, 0, 0, 9, 5, 7, 34, 4, 5, 6, 7, 8, 9]
print(compter_deniveles(altitudes))