Discussion :

[Shinyshine]

Bonjour tout le monde,

Mon but est de créer un tableau d'amortissement, mais malheureusement python n'est pas capable de faire un tableau! D'après ce que j'ai vu en python c'est les listes que se rapproche le plus du tableau!

Je peux utiliser les données de ma listes et les mettrent dans un tableau tkinter?

[ju_bicycle]

Hello
je ne comprend pas trop ta question
j'ai l'impression que tu mélange différente chose
1)

D'après ce que j'ai vu en python c'est les listes que se rapproche le plus du tableau!

en fait une liste est exactement comme le tableau en C avec 2 avantages:
-Pas besoin de déclarer sa taille à l'avance
-Il peut contenir toute sortes de données (entier, flottant, lettre, chaine de charactere, liste, tous ca mélangé

Ex:
Liste_1=[0,1,2,3,4] (que des entiers)
liste_2=[0.1,2.3,4.5] (que des flottants)
liste_3=['c','salut'] (charactere et chaine de characteres)
liste_4[1,2.3,'c','salut',[1,2,5,8]] (entier, flottant,charactere, chaine de charactere, liste)

Bref donc fait ta liste avec ce que tu veux dedans (des pourcentages non?)
tu peux utiliser la méthode append pour ajouter des éléments dans une liste

Ensuite tu parle de tkinter et de tableau... Que veux tu dire par la? tu souhaite afficher un tableau graphiquement?

Dans ce cas la pas sur que python sois l'outil idéal (meme si c'est faisable c'est sur)...

[Shinyshine]

En faîte je veux faire un tableau d'ammortissement (de la compta ^^) = http://geronim.free.fr/compta/compta..._lineaire3.htm

Je peux faire mes calculs dans une liste (vu que c'est le plus simple) et pour faire une jolie présentation, utilisé l'interface graphique tkinter pour faire un jolie truc dans ce style:

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
26
27
28
29
30
31
32
33
34
35
from tkinter import *
 
class Application:
    def __init__(self, ligne, colonne):
        self.root=Tk()
        self.root.title('Tableau - v.01')
 
        for k in range(colonne):
            b=Button(self.root, text=str(k+1))
            b.grid(row=0,column=k+1,sticky=NSEW)
        self.root.grid_rowconfigure(0, weight=1)
        for m in range(ligne):
            b=Button(self.root, text=str(m+1), width=10)
            b.grid(row=m+1,column=0,sticky=NSEW)
        self.root.grid_rowconfigure(0, weight=1)
        self.root.grid_columnconfigure(0, weight=1)
 
        rows = []
        for i in range(ligne):
            cols = []
            for j in range(colonne):
                e = Entry(self.root, justify=CENTER)
                e.grid(row=i+1, column=j+1, sticky=NSEW)
                e.insert(END, '(%d , %d)' % (i, j))
                cols.append(e)
                self.root.grid_columnconfigure(j, weight=1)
            self.root.grid_rowconfigure(i+1, weight=1)
            rows.append(cols)
 
        self.root.mainloop()
 
 
# départ du programme principal :
if __name__ == "__main__":
    f = Application(8,6)

[Antoine_935]

Si j'ai bien compris, le souci est de faire un tableau avec TkInter.

Il existe des widgets supplémentaires pour Tk:ç
Tix http://tix.sourceforge.net/
PMW http://pmw.sourceforge.net/
et sans doute plein d'autres.

Et il y a d'autres librairies graphiques, sans oublier l'option du HTML.

[eyquem]

Code :

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

1
2
for x in xrange(24):
    print divmod(x,6)

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(1, 0)
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(2, 5)
(3, 0)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
(3, 5)

Ceci montre que grâce à divmod(), on peut faire correspondre un tableau de 24/6 lignes x 6 colonnes
à une liste de 24 éléments.

Inversement à partir d’un couple d’indices ligne,colonne = 2,5 on peut déduire l’élément d’index 2*6 + 5 dans la liste, si besoin est.

NB:
divmod(a,b) donne le couple (a//b,a%b)




Donc, bien qu’il n’y ait pas de structure de données qu’on puisse appeler tableau en Python, car aucune structure de données ne peut être indicée de cette façon: structure(3,4) ,
on peut tout de même repérer des données par deux indices comme si on disposait d’un tel tableau, à partir de l’utilisation d’une liste.

On n’est ainsi pas contraint à recourir à une liste de listes pour simuler un tableau.
Une injection d’un peu de mathématique pallie l’absence d’une telle structure en Python.




Ce qui donne, appliqué à l’obtention d’un tableau d’amortissement sans prorata temporis:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from Tkinter import *
 
class Application:
    def __init__(self, ligne,col_textes):
        self.root=Tk()
        self.root.title('Tableau - v.01')
 
        colonnes = len(col_textes)
 
        for k in range(colonnes):
            b=Button(self.root, text=col_textes[k])
            b.grid(row=0,column=k,sticky=NSEW)
 
        for k,u in enumerate(L[colonnes:]):
            e = Entry(self.root, justify=CENTER)
            e.grid(row=k//colonnes + 5, column=k%colonnes, sticky=NSEW)
            e.insert(END, u)
 
        self.root.mainloop()
 
 
# départ du programme principal :
if __name__ == "__main__":
 
    valacqu = float(input("Entrer la valeur comptable d'acquisition : ' "))
    durut   = input("Entrer la duree d'utilisation : ")
    annuite = valacqu/durut
 
    col_textes = ('Annee',"Valeur comptable\nde début\nd'exercice",
                  "Annuité\nd'amortissement",'Amortissements\ncumulés',
                  "Valeur comptable\nnette en \nfin d'exercice")
 
    L = [ 0, None, None, 0, valacqu] # valeurs de depart pour l'iteration qui suit
 
    for i in xrange(0,len(col_textes)*durut,5):
        L.extend([L[i] + 1, L[i+4], annuite, L[i+3] + annuite, L[i+4] - annuite])
        # colonne 0: Annee
        # colonne 1: Valeur comptable de début d'exercice
        # colonne 2: Annuité d'amortissement
        # colonne 3: Amortissement cumulé
        # colonne 4: Valeur comptable nette en fin d'exercice

Je suppose que l’itération unique for k,u in enumerate(L[colonnes:]) est ce que tu souhaitais obtenir, au lieu d’une itération à deux boucles imbriquées.





J’ai enlevé les instructions
self.root.grid_rowconfigure(0, weight=1)
(celle-ci était en double)
self.root.grid_columnconfigure(0, weight=1)
je ne comprends pas bien comment elles fonctionnent, ça a l’air de marcher encore sans elles.




Il y a encore de bricoles à régler au niveau des calculs:

- arrêter les chiffres significatifs à deux décimales, faire en sorte qu’on tombe toujours à zéro de valeur comptable finale sur la dernière ligne ...

- coder le cas avec prorata temporis