Discussion :

[nevergiveup]

Bonjour, je dois créer une fonction qui vérifie si une matrice carrée est diagonale (En supposant que la matrice est un tableau à deux dimensions). Cela signifie que toutes les cases sont égales à 0 , sauf éventuellement pour les cases sur la diagonale. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> D =[[1,0,0],
       [0,2,0],
       [0,0,1]]
>>> True

Dans le cas contraire False.

[marco056]

Et ?

[lg_53]

Parcours l'ensemble des éléments de ta matrice avec des indices i et j (un pour chaque dimension) :
- Si i est différent de j, tu vérifies que l'élément sur la i-eme ligne, j-ieme est bien nul. Si c'est le cas tu continues à faire la vérification pour les indices suivants. Sinon tu peux directement renvoyer False car tu as trouvé un élément non nul qui n'est pas sur la diagonale.
- Si i est égale à j, tu n'as rien à faire. On est sur la diagonale, donc les valeurs peuvent être ce qu'elles veulent.

Il faut traduire tout ca en Python maintenant.

[fred1599]

L'explication sur la matrice diagonale me semble mal exprimée, il faut préciser que seule la diagonale principale doit être avec des valeurs nulles ou non nulles, et que les autres valeurs restantes doivent être à la valeur 0.

Tu peux déjà récupérer toutes les valeurs en dehors de la diagonale principale dans une liste,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
numbers = []
for i, line in enumerate(D):
    for j, column in enumerate(line):
        if i != j:
            numbers.append(line[j])
 
print(numbers)

Ensuite pour tester si toutes les valeurs sont à 0, on peut utiliser l'objet set, qui permettra de vérifier que toutes la valeurs sont identiques et après un test d'égalité, vérifier si cette valeur vaut 0.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
values = set(numbers)
if len(values) == 1 and values[0] == 0:
    print("matrice diagonale")

Il y a sans doute d'autres solutions, mais celle-ci me semble assez intuitive...

[lg_53]

Inutile de récupérer les éléments non diagonaux dans une liste pour faire le test que tous les éléments sont nul. Au lieu d'ajouter l'élément à numbers, il suffit de tester directement s'il vaut 0 ou non.

Ca consomme moins de mémoire et c'est plus rapide en plus, car si vous avez une matrice pleine, là avec votre méthode vous parcourrez tout. Avec la mienne je m'arrete dès que j'ai trouvé un élément qui ne vas pas (donc dès le début sur une matrice pleine).

Je n'ai volontairement pas donné le code qui va avec l'algorithme que j'ai proposé, le but étant de ne pas faire l'exercice de cet étudiant à sa place ...

[fred1599]

Je n'ai volontairement pas donné le code qui va avec l'algorithme que j'ai proposé, le but étant de ne pas faire l'exercice de cet étudiant à sa place ...

Désolé, tu remarqueras que j'ai répondu 2 minutes après toi. Si j'avais vu ton post avant, je n'aurai sans doute pas écrit le mien...

Inutile de récupérer les éléments non diagonaux dans une liste pour faire le test que tous les éléments sont nul. Au lieu d'ajouter l'élément à numbers, il suffit de tester directement s'il vaut 0 ou non.

Ca consomme moins de mémoire et c'est plus rapide en plus, car si vous avez une matrice pleine, là avec votre méthode vous parcourrez tout. Avec la mienne je m'arrete dès que j'ai trouvé un élément qui ne vas pas (donc dès le début sur une matrice pleine).

Certes, j'ai présenté un code assez intuitif sans montrer d'optimisation. Ça pourrait faire l'objet d'un code de base à optimiser.

[Supernul]

Je pense qu'une bonne habitude quand on travaille sur des matrices avec python est d'utiliser numpy.
Dès que l'on parle de la diagonale d'une matrice, il est souvent intéressant de travailler avec une matrice identité.

Le principe : faire une multiplication terme à terme entre ta matrice et la matrice identité de même dimension puis tester si cette nouvelle matrice correspond à ta matrice.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
import numpy as np
 
init_mat = np.array([[2,0,0], [0,2,0], [1,0,2]])
 
iden_mat = np.identity(3)
 
mult_mat = init_mat * iden_mat != init_mat
 
# si le résultat diffère de 0, la matrice testée possède x éléments non nuls hors diagonale.
print(np.sum(mult_mat))

C'est une autre solution possible.

[fred1599]

Oui, numpy ! En vue de son 1er topic, je pense que c'est un travail algorithmique avec les matrices... Je pense même que ma solution avec enumerate est overkill et qu'il va falloir qu'il bosse avec range et len (Pfff...).

[lg_53]

Désolé, tu remarqueras que j'ai répondu 2 minutes après toi. Si j'avais vu ton post avant, je n'aurai sans doute pas écrit le mien...

Oui, je m'en suis douté après coup.


Avec numpy on peut faire des choses très puissantes. On peut imaginer utiliser np.where pour obtenir directement la position des éléments non nul puis regarder si les positions sont bien toutes sur la diagonale. On peut aussi utiliser np.diag pour extraire et construire une matrice diagonale ayant la meme diagonal que la matrice d'origine et comparer cette nouvelle matrice à la matrice d'origine (ce qui tient en une ligne de code).
Ici la matrice étant présentée comme une liste de liste, je pense qu'on en est sur de l'apprentissage. Numpy c'est probablement trop avancé pour nevergiveup.

[Sve@r]

Il y a sans doute d'autres solutions, mais celle-ci me semble assez intuitive...

Bonjour

Autre possibilité: mettre simplement la diagonale à 0 et ensuite regarder (via effectivementset) si le contenu de la matrice vaut 0. En plus, pour ça, inutile de regarder l'élément [0] du tableau. Puisque la matrice aura au-moins un zéro, si ce qui sort de set a une longueur de 1, c'est que la matrice est diagonale.
Plus rapide car on ne traite que la diagonale (et non tous les autres nombres) mais a l'inconvénient de modifier la matrice d'origine.

Sinon effectivement la solution de lg_53 (qui sort dès qu'on trouve un cas d'impossibilité) semble être ce qu'il y a de mieux...

[nevergiveup]

Oui, numpy ! En vue de son 1er topic, je pense que c'est un travail algorithmique avec les matrices... Je pense même que ma solution avec enumerate est overkill et qu'il va falloir qu'il bosse avec range et len (Pfff...).

Effectivement on nous impose d'utiliser (for in range....) , parce que nous sommes débutants. En ce qui concerne mon topic je suis parti avec l'algo que m'a fourni lg_53 et je suis arrivé à ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def est_diagonale(M):
 
    for i in range (len(M)):
 
        for j in range (len(M)):
            if i!=j and M[i][j]== 0:
                res = True
            else:
                res = False
    return res

Mais ce n'est pas encore ce que je veux car j'aimerai que la boucle s'arrête dès qu'on aura trouvé une valeur fausse dans la matrice . Bon ensuite mon programme ne marche pas car j'obtiens tout le temps False quelque soit les valeurs de ma matrice.

[marco056]

Plutôt comme cela, non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
D =[[1,0,0],[0,2,0],[0,0,1]]
E =[[0,3,0],[0,0,2], [0,1,0]]
 
def diago1(M):
    for i in range (len(M)):
        for j in range (len(M)):
            if i != j and M[i][j] != 0:
                return False
            else:
                res = True
    return res
 
print(diago1(D))
print(diago1(E))
 
def diago2(M):
    res = True
    for i in range (len(M)):
        for j in range (len(M)):
            if i != j and M[i][j] != 0:
                return False
    return res
 
print(diago2(D))
print(diago2(E))

L'idée, c'est que dès qu'un return est rencontré, les instructions suivantes ne sont pas évaluées.

[Sve@r]

Plutôt comme cela, non ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def diago2(M):
    res = True
    for i in range (len(M)):
        for j in range (len(M)):
            if i != j and M[i][j] != 0:
                return False
    return res

T'es sûr d'avoir vraiment besoin de la variable "res" ???