Informations sur les Langages Informatiques
En Python, les types construits sont des structures de données permettant de stocker et organiser des collections de valeurs. Parmi ces types, les tableaux occupent une place importante, offrant une manière efficace de gérer des ensembles de données.
Voici une introduction aux tableaux en Python et comment ils peuvent être utilisés pour représenter différentes formes de données structurées.
En Python, les tableaux sont des structures de données indexées, ce qui signifie que chaque élément a un index numérique commençant à 0. Les capacités attendues pour manipuler les tableaux incluent la lecture et la modification des éléments grâce à leurs index, la construction de tableaux par compréhension, l'utilisation de tableaux de tableaux pour représenter des matrices avec la notation a[i][j], et l'itération sur les éléments d'un tableau.
Seuls les tableaux dont les éléments sont du même type sont présentés ici, et aucune connaissance des tranches (slices) n'est exigible. L'aspect dynamique des tableaux de Python n'est pas évoqué, et il est important de noter que Python identifie les listes et les tableaux. Aucune référence n'est faite aux tableaux de la bibliothèque NumPy.
# Tableau indexé
mon_tableau = [10, 20, 30, 40]
print(mon_tableau)
print(mon_tableau[0])
print(mon_tableau[1])
print(mon_tableau[-1])
print(mon_tableau[-3])
print(type(mon_tableau))
# Modification d'un élément
mon_tableau[2] = 35
print(mon_tableau)
# Connaître le nombre d'éléments
print(len(mon_tableau))
# Sélectionner une partie du tableau
print(mon_tableau[1:3])
print(mon_tableau[1:])
print(mon_tableau[:3])
# Ajouter un élément à la fin
mon_tableau.append(50)
print(mon_tableau)
# Supprimer un élément par index
mon_tableau.pop(1)
print(mon_tableau)
# Supprimer le dernier élément
mon_tableau.pop()
print(mon_tableau)
Résultats :
[10, 20, 30, 40]
10
20
40
20
<class 'list'>
[10, 20, 35, 40]
4
[20, 30]
[20, 30, 40]
[10, 20, 30]
[10, 20, 30, 40, 50]
[10, 30, 40]
[10, 20, 30]
Vous pouvez construire des tableaux en utilisant la "compréhension de liste", une manière concise de créer des listes en Python :
# Exemple de compréhension de liste avec la fonction range()
tableau_range = list(range(0, 50, 4))
print(tableau_range)
# Exemple de compréhension de liste pour générer des puissances de 2
puissances = [2 ** n for n in range(32)]
print(puissances)
# Exemple de compréhension de liste pour créer une liste de 10 zéros
dix_zeros = [0] * 10
print(dix_zeros)
Résultats :
[0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48]
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Pour représenter une matrice, vous pouvez utiliser un tableau de tableaux :
# Définition d'une matrice
matrice = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
# Affichage de la matrice
print(matrice)
print(matrice[0][0])
print(matrice[1][2])
# Informations sur la matrice
print("Nombre de lignes dans la matrice :", len(matrice))
print("Taille de la matrice (lignes x colonnes) :",
len(matrice), "x", len(matrice[0]))
# Modification d'un élément de la matrice
matrice[1][1] = 100
print(matrice)
# Création d'une matrice de zéros
matrice_de_zeros = [[0 for _ in range(3)] for _ in range(3)]
print(matrice_de_zeros)
# Création d'une matrice de multiplication
matrice_multiplication = [[i * j for j in range(6)] for i in range(3)]
print(matrice_multiplication)
Résultats :
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1
6
Nombre de lignes dans la matrice : 3
Taille de la matrice (lignes x colonnes) : 3 x 3
[[1, 2, 3], [4, 100, 6], [7, 8, 9]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5], [0, 2, 4, 6, 8, 10]]
Utilisez une boucle for pour parcourir tous les éléments d'un tableau :
# Exemple d'itération sur un tableau
mon_tableau = [10, 20, 30, 40]
for élément in mon_tableau:
print(élément)
# Exemple d'itération sur un tableau avec index
mon_tableau = [10, 20, 30, 40]
for i in range(len(mon_tableau)):
print(mon_tableau[i])
# Exemple d'itération sur une matrice
matrice = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
for i in range(3):
for j in range(3):
print(matrice[i][j])
print()
# Exemple d'itération sur une matrice de multiplication
matrice_multiplication = [[i * j for j in range(6)] for i in range(3)]
# Afficher la matrice
for ligne in matrice_multiplication:
print(ligne)
Résultats :
10
20
30
40
10
20
30
40
1
2
3
4
5
6
7
8
9
[0, 0, 0, 0, 0, 0] [0, 1, 2, 3, 4, 5] [0, 2, 4, 6, 8, 10]
Certains des codes qui suivent permettent d'exploiter les tableaux sous différents formats. Ce sont des exemples et il ne faut donc pas s'arrêter à l'utilisation qui leur sont attitrées ci-dessous.
La fonction calcul_moyenne permet de calculer la moyenne pondérée d'un tableau où chaque élément est un couple (valeur, coefficient).
def calcul_moyenne(tableau):
somme = 0
coeff = 0
for element in tableau:
somme += element[0] * element[1]
coeff += element[1]
moyenne = somme / coeff
return moyenne
print(calcul_moyenne([(15, 0.5), (16, 1), (20, 2), (19, 2)]), "/ 20")
Résultat attendu :
Moyenne : 17.55 / 20
La fonction minimum_maximum retourne le minimum et le maximum d'un tableau.
def minimum_maximum(tableau):
minimum = tableau[0]
maximum = tableau[0]
for element in tableau:
if element < minimum:
minimum = element
if element > maximum:
maximum = element
return minimum, maximum
tableau = [x**4 - x**3 - 5 for x in range(-3, 3, 1)]
minimum, maximum = minimum_maximum(tableau)
print(tableau)
print("Le minimum est :", minimum)
print("Le maximum est :", maximum)
Résultat attendu :
Tableau : [-35, -20, -5, 6, 31, 84]
Le minimum est : -35
Le maximum est : 84
La fonction indices_maxi retourne la valeur maximale et les indices correspondants dans le tableau.
def indices_maxi(tableau):
list = []
maximum = tableau[0]
for elt in tableau:
if maximum < elt:
maximum = elt
list = []
for i in range(len(tableau)):
if tableau[i] == maximum:
list += [i]
return maximum, list
print(indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]))
Résultat attendu :
Valeur maximale : 9
Indices correspondants : [3, 8]
La fonction distance_point calcule la distance entre deux points dans un plan cartésien.
import math
def distance_point(A, B):
xA, yA = A
xB, yB = B
return math.sqrt((xB - xA)**2 + (yB - yA)**2)
A = (0, 0)
B = (math.pi, math.pi)
print(f"La distance entre les points A et B est de {distance_point(A, B)} cm")
Résultat attendu :
La distance entre les points A et B est de 4.442882938158366 cm
La fonction recherche_occurence trouve les indices d'occurrence d'une valeur dans un tableau.
def recherche_occurence(tableau, valeur):
list = []
for i in range(len(tableau)):
if tableau[i] == valeur:
list += [i]
if list == []:
list = "impossible à trouver"
return list
tableau = [5, 6, 4, 1, 2, 8, 7, 9, 5, 1, 2, 6, 4, 1, 7, 5, 6, 4, 6, 5, 4, 8, 7, 8, 5, 7, 2, 6, 1, 4, 8, 9]
for k in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
print("Votre recherche", k, " se trouve aux indices :", recherche_occurence(tableau, k))
Résultat attendu :
Votre recherche 1 se trouve aux indices : [3, 9, 13, 28]
Votre recherche 2 se trouve aux indices : [4, 10, 26]
Votre recherche 3 se trouve aux indices : impossible à trouver
Votre recherche 4 se trouve aux indices : [2, 12, 17, 20, 29]
Votre recherche 5 se trouve aux indices : [0, 8, 15, 19, 24]
Votre recherche 6 se trouve aux indices : [1, 11, 16, 18, 27]
Votre recherche 7 se trouve aux indices : [6, 14, 22, 25]
Votre recherche 8 se trouve aux indices : [5, 21, 23, 30]
Votre recherche 9 se trouve aux indices : [7, 31]
Cet exemple génère des triplets pythagoriciens où la somme des carrés des deux premiers éléments est égale au carré du troisième.
n = 50
print([(x, y, z) for x in range(1, n) for y in range(1, n)
for z in range(1, n) if x**2 + y**2 == z**2 and x <= y])
Résultat attendu :
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (7, 24, 25), (8, 15, 17), (9, 12, 15), (9, 40, 41), (10, 24, 26), (12, 16, 20), (12, 35, 37), (15, 20, 25), (15, 36, 39), (16, 30, 34), (18, 24, 30), (20, 21, 29), (21, 28, 35), (24, 32, 40), (27, 36, 45), (30, 40, 50)]