Informatique Terminale : Compléments de programmation Corrigé Sujet 1 : Matrices carrées 1.

Informatique Terminale : Compléments de programmation

Corrigé

Sujet 1 : Matrices carrées

1.

M2 = [[7, 6, 5], [4, 8, 2], [3, 0, 1]]

M1 + M2 = [[9, 9, 9], [9, 9, 9], [9, 9, 9]]

2. a) Le constructeur d’une classe est la méthode spéciale

def __init__(self, lignes):

self.lignes = lignes

b) La matrice associée à l’objet est son attribut

donc

def __call__(self, i, j):

return self.lignes[i][j]

c) La longueur d’une matrice est le nombre de listes qu’elle contient

def taille(self):

return len(self.lignes)

d) On parcourt la matrice associée à l’objet et on retient le plus grand entier. Le nombre de chiffres est la longueur de la chaîne de caractères associée.

def largeur(self):

mini = 0

for lig in self.lignes:

for x in lig:

if x > mini:

mini = x return len(str(mini))

e) On construit une chaîne de caractères en ajoutant devant chaque entier le nombre d’espaces nécessaires pour que le nombre de caractères entre deux virgules soit toujours le même.

def __str__(self):

larg = self.largeur() ligne = ''

for lig in self.lignes:

ligne += '['

for i in range(len(lig)-1):

ligne += ' '*(larg-len(str(lig[i]))) + str(lig[i]) + ', ' ligne += ' '*(larg-len(str(lig[-1]))) + str(lig[-1]) + ']\n' return ligne

3. a)

est le nombre de clés du dictionnaire

. La méthode

renvoie

si ce nombre est égal au nombre de coefficients de l’objet

c’est-à-dire si tous ces coefficients sont différents.

Sinon elle renvoie

.

b)

donc

et

On en déduit que les lignes de c (les trois sous-listes précédentes) ont la même référence donc, pour

, le code

transforme toutes les lignes en

puis, pour

en

et pour

en

. Finalement, l’affichage est

[1, 1, 1]

[1, 1, 1]

[1, 1, 1]

Remarque. On peut voir que toutes les lignes ont la même référence avec :

I = Carre.Id(3)

print(id(I.lignes[0]), id(I.lignes[1]))

c) Il faut définir chaque ligne indépendamment des autres :

def Nul(n):

lignes = []

for i in range(n):

lignes.append([0]*n) return Carre(lignes)

4. On construit la somme des deux matrices et on renvoie l’instance de la classe

associée

def __add__(self, carre):

n = self.taille() lignes = []

for i in range(n):

ligne = []

for j in range(n):

ligne.append(self.lignes[i][j] + carre.lignes[i][j]) lignes.append(ligne)

return Carre(lignes)

Remarque. Il existe une méthode spéciale pour chaque opérateur.

Celle de l’opérateur

est

5. Il suffit de parcourir toutes les sous-listes de la matrice associée à l’objet et de renvoyer

dès qu’on rencontre le paramètre ; si rien n’a été renvoyé pendant le parcours, on peut renvoyer

:

def __contains__(self, valeur):

n = self.taille() for i in range(n):

for j in range(n):

if valeur==self.lignes[i][j] : return True return False

Complément. La méthode

permet de rendre un objet itérable :

def __iter__(self):

return Iterateur(self)

Elle renvoie un itérateur (objet de la classe

à défnir) qui fonctionne avec la méthode

__next__

qui retourne la valeur suivante dans la boucle

:

class Iterateur:

def __init__(self, carre):

self.courant = 0 self.carre = carre

def __next__(self):

n = self.carre.taille() if self.courant>=n**2:

raise StopIteration

ret = self.carre(self.courant//n, self.courant%n) self.courant += 1

return ret

On peut alors parcourir l’objet avec

et utiliser les fonctions

,

,

,

.