le programme ne "marche plus" à partir d'un certain rang

Bonjour,

Je rencontre un "os" avec une fonction qui itère des listes de listes (assimilables à des tableaux, ou à des matrices...)
A un moment le programme tourne sans rien retourner et je suis obligé d'appuyer sur contrôle+c

J'entre une liste de liste de nombre à valeur 0 ou 1, et la fonction "impr" m'imprime cette liste sous forme de "tableau"
exemple:
Code:

1 2 3 4 5 6 >>> B [[1, 0, 1], [0, 1, 1]] >>> impr(B) [1, 0, 1] [0, 1, 1] >>>
...j'effectue une opération que je décrit en détail en dessous, mais dont n'est pas nécessaire je pense de lire le détail ... la fonction s'appelle "AUG", , elle prends une liste de liste comme parametre et retourne une liste plus grande de listes (plus grandes aussi, en général), quand je réapplique "AUG" à cette nouvelle liste, ça marche, si la liste n'est pas trop grande, mais si je reproduis l'opération un certain nombre de fois, TRES VITE, ça tourne dans le vide ! et je dois appuyer sur CONTRÔL+C pour interrompre :

exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 >>> AUG(B) [[0, 0, 0], [1, 1, 0], [1, 0, 1], [0, 0, 1], [1, 0, 0], [0, 1, 1], [0, 1, 0]] >>> impr(AUG(B)) [0, 0, 0] [1, 1, 0] [1, 0, 1] [0, 0, 1] [1, 0, 0] [0, 1, 1] [0, 1, 0] >>> AUG(AUG(B)) [[0, 0, 0, 0], [1, 1, 0, 0], [1, 0, 1, 0], [0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]]
jusque là tout va bien mais si je réapplique AUG (ou n'importe quelle autre fonction!!!) je suis obligé d'appuyer sur CONTROL+C!
Code:

1 2 3 4 5 6 7 >>> impr(AUG(AUG(B)) KeyboardInterrupt >>> AUG(AUG(AUG(B)) KeyboardInterrupt >>> sorted(AUG(AUG(B))
Comment expliquer ceci?? il n'y a pas tant de calculs que ça, je ne comprends pas ce qui coince...

ENCORE PLUS ETRANGE : je n'ai rien changé au programme, mais en faisant exactement la même chose, j'obtiens une liste d'erreur qui pointe des définitions du tout début de la page IDLE (qui est peut être trop longue?)

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
description du problème (si ça interesse quelqu'un mais il est inutile de lire à mon avis)

: j'entre des liste de liste à valeur 0 ou 1 (ex [[1,0,1],[0,1,1]]) j
Après avoir définit "prod(a,b)" un "produit terme" à terme des listes à valeurs 0 ou 1 d'une longueur donnée (ex: prod([1,0,1],[0,1,1])=[0,0,1])
Et après avoir définit eng(A) qui quand on lui entre A une liste de liste à valeur entières, retourne la plus petite liste sans répétitions qui soit close par "prod" et qui contienne A (eng(A) close par "prod" signifie que pour deux liste d'entier a et b dans eng(A), prod(a,b) est encore dans eng(A)) (par exemple si A=[[1,0,1],[0,1,1]] , eng(A)=([1,0,1],[0,1,1],[0,0,1])), voici le code en détail qui aboutit à la définition de AUG
Code:

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 26 27 28 29 30 31 32 33 34 35 36 37 >>> def col(A,i):#donne la i-eme colonne du "tableau" A return [a[i] for a in A] >>> def tran(A): #transpose la "matrice" x=range (len(A[0])) return [C(A,i) for i in x] >>> def UN(paire):#calcul intermédiare pour calculer Fr(A,i) if paire[0]>paire[1]-paire[0]: return 0 else: return 1 >>> def Fr(A,i) :#retourne 1 si la i-eme colonne de A contient plus de 0 que de 1 (colonne 1-minoritaire )et 1 sinon x=0 y=0 while x<len(A) : y=y+A[x][i] x=x+1 return [y, len(A)] >>> def F(A): #retourne la liste des coefficients minoritaires l=len(A[0]) return [UN(Fr(eng(A),i)) for i in range (l)] >>> def aug(A): #rajoute la ligne des minoritaires à "l'engendré" puis augmente l'engendré e cette ligne des minoriataire et engendre à nouveau return eng(A+[F(A)]) >>> def AUG(A):#fais la même opération SAUF si la ligne des minoritaire est uniquement composée de 1, dans ce cas, on fait la même chose que précédemment sur le tableau obtenu en ajoutant une colonne de 0, à A a=A[0] l=len(a) L=len(eng(A)) u=[1 for j in a]#ligne avec que des 1 if F(A)==u: return tran(tran(eng(A))+[[0 for i in range (L)]])+[[1 for k in range(l+1)]]#la fonction "tran" (transposé) permet de faire des opérations sur les colonnes else : return aug(A)

Bonjour,

Je n'ai pas tout regardé, mais il est possible qu'il y ait le problème suivant: les listes sont transmises comme argument aux fonctions, comme adresse et non comme valeur.

Prenons un exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 def test(B): B.append("toto") return B A = [1, 2, 3] X = test(A) print(X) print(A) [1, 2, 3, 'toto'] [1, 2, 3, 'toto']
On voit bien les conséquences ici: la modification faite sur l'argument B a modifié aussi la liste A initiale (effet de bord)

Quand on ne veut pas ça, il faut travailler sur une copie de A et non sur A directement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def test(B): B = B[:] # ou B=B.copy() => le nouveau B est remplacé par une copie de l'ancien B B.append("toto") return B A = [1, 2, 3] X = test(A) print(X) print(A) [1, 2, 3, 'toto'] [1, 2, 3]

Je crois avoir fait attention à ça justement, mais peut-être qu'il y a quelque chose comme ça dans une des étapes intermédiaires qui aurait échappé à ma vigilance...je ne peux pas vérifier maintenant car il faut que je copie colle le "bon code" dans ce que j'ai sauvegardé (je n'arrive pas encore à créer des modules à "import"er...)

merci de m'avoir aiguillé sur la probable nature de l'erreur, en fait j'aurais du avoir la présence d'esprit de vérifier que c'est encore cette histoire de retournage... mais je me disais que peut-être j'avais "trop ecrit" et que la machine "ramait", mais c'est vraiment idiot d'avoir cru ça, je m'en rends compte, je ne devrais même pas avouer que j'ai eu une telle pensée lol

merci again^^