Python Creation d'objet pour lecture ecriture d'un fichier csv

Version imprimable

l'objet Base_Trx est utiliser pour ecrire un fichier csv. entete et donnees
Ce qui fonctionne parfaitement
Ceci étant je veux créer méthode pour lire le fichier csv.
Un objet pour stoker les données globales du fichier une liste d'objet avec une incrémentation d’identification.

J'ai bien des lacune dans l'univers de la programmation objet.
Je cherche aussi un doc en français pour utiliser des outils de modélisation et de reverse engenering.
j'ai un outil BOUML mais il ne fait pas de reverse sur code python

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
import datetime
 
 
def convertie_date(src):
    if src =='':
        valid_date = None
    else:
        #0123456890
        #2017-02-01
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[5:7]) 
        alpha_jj =  int(src[9:11]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
        return None
    pass  
 
class Base_Trx(object):
    def __init__(self,PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT):
        self.PRT = PRT
        self.GT = GT
        self.ORDRE = ORDRE
        self.MODULE = MODULE
        self.DATE_DEBUT_PRT = DT_DB_PRT
        self.DT_FN_PRT = DT_FN_PRT
        self.DT_DB_GT = DT_DB_GT
        self.DT_FN_GT = DT_FN_GT
        pass
 
    def __str__(self):
        resulta = "PRT :" + str(self.PRT ) +"\n"
        resulta += "GT :" + str(self.GT ) +"\n"
        resulta += "ORDRE :" + str(self.ORDRE ) +"\n"
        resulta += "MODULE :" + str(self.MODULE ) +"\n"
        resulta += "DT_DB_PRT :" + str(self.DT_DB_PRT ) +"\n"
        resulta += "DT_FN_PRT :" + str(self.DT_FN_PRT ) +"\n"
        resulta += "DT_DB_GT :" + str(self.DT_DB_GT ) +"\n"
        resulta += "DT_FN_GT :" + str(self.DT_FN_GT ) +"\n"
 
        return resulta
    pass
 
    def csv_donnee(self):
        return [self.PRT,self.GT,self.ORDRE,self.MODULE,self.DT_DB_PRT,
                self.DT_FN_PRT,self.DT_DB_GT, self.DT_FN_GT]
        pass
 
    def csv_entete(self):
        return ["PRT","GT","ORDRE","MODULE","DT_DB_PRT","DT_FN_PRT","DT_DB_GT","DT_FN_GT"]
        pass
 
pass
 
 
class Base_Obj(object):
    rang = 0 
    def __init__(self):
        Base_Trx.rang += 1 
        self.ident = Base_Trx.rang 
        self.Trixel_Fic = list()
        pass
    def ajouter(self, Base_Trx): 
        self.Base_Obj.append(Base_Trx) 
 
 
pass

Salut,

Difficile de comprendre ce que tu veux faire exactement.
Code:

1 2 3 4 5 6 7 8 9 10 class Base_Obj(object): rang = 0 def __init__(self): Base_Trx.rang += 1 self.ident = Base_Trx.rang self.Trixel_Fic = list() def ajouter(self, Base_Trx): self.Base_Obj.append(Base_Trx)
Tu devrais avoir une AttributeError ici: Base_Trx.rang += 1 cette classe n'a pas d'attribut rang

Ensuite dans la méthode ajouter(self, Base_Trx) tu utilises le nom d'une classe, Base_Trx. Simple désir de s'emmêler les pinceaux ou bien c'est réellement cette classe qui est demandée en argument ?

Tu peux aussi supprimer toutes les instructions pass qui encombrent inutilement.

Qu'appelle-tu reverse engineering en Python ?

04/11/2017, 10h48
wiztricks

Salut,

Citation:

Envoyé par dedalios

Ceci étant je veux créer méthode pour lire le fichier csv.

Certes mais quel est le problème qui vous en empêche? Pourquoi ne pas utiliser le module csv?

Citation:

J'ai bien des lacune dans l'univers de la programmation objet.
Je cherche aussi un doc en français pour utiliser des outils de modélisation et de reverse engenering.
j'ai un outil BOUML mais il ne fait pas de reverse sur code python

Il vous faut regarder dans les documents de la rubrique ALM ou poser des questions dans le forum correspondant.

- W

Programmme lireficp.py

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# coding: utf-8  
import string
import sys
import datetime
import csv
import os
 
from  Explorateur import *
from  Trixel import *
 
'''
Created on 1 nov. 2017 
 
 
'''
nom_fichier_prt =None 
fichier_csv_prt =None
ecrire_csv= None
if __name__ == '__main__':
    nom_fichier_path_in = explorateur_window (".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
        # ouverture du fichier excel
        # wb = xlrd.open_workbook(nom_fichier_path_in)
        # Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire complet
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
        creer_csv  = False
        nb_ligne =0
        with open(nom_fichier_path_in, 'r',newline='\n')   as fichier:  
            for ligne in fichier:
                PRT=ligne[0:15]
                GT=ligne[15:30]
                ORDRE=ligne[30:33]
                MODULE=ligne[33:48]
                DT_DB_PRT=ligne[48:58]
                DT_FN_PRT=ligne[58:68]
                DT_DB_GT=ligne[68:78]
                DT_FN_GT=ligne[78:88]                                
                monfic = Base_Trx(PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT)
                if(creer_csv ==False):
                    nom_fichier_prt = nom_fichier_path + "/resultat.csv"  
                    fichier_csv_prt = open(nom_fichier_prt, 'w', newline='') # Codage du fichier csv délimiter ligne /n estpar efaut  
                    ecrire_csv = csv.writer(fichier_csv_prt, delimiter = ';') # Codage du fichier csv délimiter de champ
                    ecrire_csv.writerow(monfic.csv_entete())  # entete                
                    creer_csv = True 
                if(creer_csv ==True):
                    ecrire_csv.writerow(monfic.csv_donnee())  # entete  
#                print(monfic)
        if(creer_csv== True):
            fichier_csv_prt.close()    
    try: 
        print("")
    finally:  
        print("")

Le code de Trixel.py

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# coding: utf-8 
import datetime
 
 
def convertie_date(src):
    if src =='':
        valid_date = None
    else:
        #0123456890
        #2017-02-01
        #2017/02/01
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[5:7]) 
        alpha_jj =  int(src[8:11]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
        return None
 
 
class Base_Trx(object):
    def __init__(self,PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT):
        self.PRT = PRT
        self.GT = GT
        self.ORDRE = ORDRE
        self.MODULE = MODULE
        self.DT_DB_PRT = convertie_date(DT_DB_PRT)
        self.DT_FN_PRT = convertie_date(DT_FN_PRT)
        self.DT_DB_GT = convertie_date(DT_DB_GT)
        self.DT_FN_GT = convertie_date(DT_FN_GT)
 
 
    def __str__(self):
        resulta = "PRT :" + str(self.PRT ) +"\n"
        resulta += "GT :" + str(self.GT ) +"\n"
        resulta += "ORDRE :" + str(self.ORDRE ) +"\n"
        resulta += "MODULE :" + str(self.MODULE ) +"\n"
        resulta += "DT_DB_PRT :" + str(self.DT_DB_PRT ) +"\n"
        resulta += "DT_FN_PRT :" + str(self.DT_FN_PRT ) +"\n"
        resulta += "DT_DB_GT :" + str(self.DT_DB_GT ) +"\n"
        resulta += "DT_FN_GT :" + str(self.DT_FN_GT ) +"\n"
 
        return resulta
 
 
    def csv_donnee(self):
        return [self.PRT,self.GT,self.ORDRE,self.MODULE,self.DT_DB_PRT,
                self.DT_FN_PRT,self.DT_DB_GT, self.DT_FN_GT]
 
 
    def csv_entete(self):
        return ["PRT","GT","ORDRE","MODULE","DT_DB_PRT","DT_FN_PRT","DT_DB_GT","DT_FN_GT"]
 
 
 
 
 
#class Base_meta(object):
#        def __init__(self)
#        self= Base_Trx[]

Le code de explorateur.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# coding: utf-8  
 
import tkinter 
from tkinter.filedialog import askopenfilename
 
'''Created on 21 aout 2017 
'''
def explorateur_window(repertoireinit):
    """ Explorateur Windows    """
    #root = tkinter.Tk()
 
    filename = tkinter.filedialog.askopenfilename(
        initialdir=repertoireinit,
        title="Choisir votre fichier",
        filetypes=(
            ("Fichier .txt", "*.txt"),
            ("Tous type de fichier","*.*")
        )
    )
    return filename
pass

Le fichier lu par le traitement

Code:

1
2
3
4
5
6
7
Citroen        AssuranceX     001Base           2017/01/012017/12/312017/01/012017/12/31
Citroen        AssuranceX     002Enfant         2017/01/012025/12/312017/01/012017/12/31
Citroen        AssuranceX     001Base           2017/01/012017/06/302017/01/012017/06/30
Citroen        AssuranceX     002Enfant         2017/01/012017/06/302017/01/012017/06/30
Peugeot        AssuranceY     001Base           2017/01/072017/06/302017/07/012017/12/31
Peugeot        AssuranceY     002Enfant1        2017/01/072017/06/302017/07/012017/12/31
Peugeot        AssuranceY     003Enfant1        2017/01/072017/06/302017/07/012017/12/31

Le fichier résultat.csv

Code:

1
2
3
4
5
6
7
8
PRT;GT;ORDRE;MODULE;DT_DB_PRT;DT_FN_PRT;DT_DB_GT;DT_FN_GT
Citroen        ;AssuranceX     ;001;Base           ;2017-01-01;2017-12-31;2017-01-01;2017-12-31
Citroen        ;AssuranceX     ;002;Enfant         ;2017-01-01;2025-12-31;2017-01-01;2017-12-31
Citroen        ;AssuranceX     ;001;Base           ;2017-01-01;2017-06-30;2017-01-01;2017-06-30
Citroen        ;AssuranceX     ;002;Enfant         ;2017-01-01;2017-06-30;2017-01-01;2017-06-30
Peugeot        ;AssuranceY     ;001;Base           ;2017-01-07;2017-06-30;2017-07-01;2017-12-31
Peugeot        ;AssuranceY     ;002;Enfant1        ;2017-01-07;2017-06-30;2017-07-01;2017-12-31
Peugeot        ;AssuranceY     ;003;Enfant1        ;2017-01-07;2017-06-30;2017-07-01;2017-12-31

Cette solution marche maintenant

Je veux partir de 2 fichiers csv pour faire des analyses de comparative.

Je veux pouvoir charge le fichier csv résultat1.csv avec résultat2.csv

Code:

1
2
3
4
5
6
PRT;GT;ORDRE;MODULE;DT_DB_PRT;DT_FN_PRT;DT_DB_GT;DT_FN_GT
Peugeot        ;AssuranceX     ;001;Base           ;2017-04-01;2017-12-31;2017-04-01;2017-12-31
Peugeot        ;AssuranceX     ;002;Enfant         ;2017-04-01;2025-12-31;2017-04-01;2017-12-31
Citroen        ;AssuranceX     ;001;Base           ;2017-01-01;2017-06-30;2017-01-01;2017-06-30
Peugeot        ;AssuranceY     ;001;Base           ;2017-01-07;2017-06-30;2017-07-01;2017-12-31
Peugeot        ;AssuranceY     ;003;Enfant1        ;2017-01-07;2017-06-30;2017-07-01;2017-12-31

Je cherche donc a créer un moyen de lire le fichier csv dont la structure est défini dans la class Base_Trx

Pour faire des comparaisons entre mes deux fichiers.

je cherche donc à créer un objet x qui contient une liste d'objet Base_Trx avec un index d'identification

Je débute dans la codification d'objet donc je cherche un peu .

Le programme de lecture du fichier csv

lirecsv.py

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
38
39
40
41
# coding: utf-8  
import string
import sys
import datetime
import csv
import os
 
from  Explorateur import *
from  Trixel import *
 
'''
Created on 1 nov. 2017 
 
@author: EricSVlo
'''
obj= None
 
if __name__ == '__main__':
    nom_fichier_path_in = explorateur_window (".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
        # ouverture du fichier excel
        # wb = xlrd.open_workbook(nom_fichier_path_in)
        # Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire complet
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
        nb_ligne =0
        with open(nom_fichier_path_in, 'r', newline='')   as fichier:  
            lire_fichier = csv.reader(fichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            for ligne in lire_fichier:
                print(ligne)
                if(nb_ligne!=0):
                    obj=Base_Trx(ligne[0],ligne[1],ligne[2],ligne[3],ligne[4],ligne[5],ligne[6],ligne[6])
                    print(obj)
                nb_ligne+=1
 
    try: 
        print("")
    finally:  
        print("")    
    pass

Je ne souhaitais pas dans la class Base_Trx créer une notion d'index car cette indexe n'existe pas dans le fichier csv .

quand je parle de reverse ingenering , je voudrais sur la base du code Trixel.py créer l'objet UML correspondant j'ai une 20 d'objets définie en python en je voudrais les mettre en format UML.

05/11/2017, 19h13
wiztricks

Salut,

Citation:

Envoyé par dedalios

Je cherche donc a créer un moyen de lire le fichier csv dont la structure est défini dans la class Base_Trx

Pour faire des comparaisons entre mes deux fichiers.

je cherche donc à créer un objet x qui contient une liste d'objet Base_Trx avec un index d'identification

Les class n'ajoutent que du non fonctionnel (lisibilité, maintenabilité,...) en vous permettant d'organiser votre code un peu différemment et éviter certaines répétitions. Vous pouvez essayer d'écrire le code sans "class" puis le restructurer pour les utiliser. Vous pouvez aussi tout coder avec des "class" (même si elles ne servent à rien, repeindre le monde avec des "class" aide à trouver les limites du concept).
Essayez de résoudre votre problème sans "class" dans un premier temps.

- W
05/11/2017, 23h30
dedalios

Citation:

Envoyé par wiztricks

Salut,

Les class n'ajoutent que du non fonctionnel (lisibilité, maintenabilité,...) en vous permettant d'organiser votre code un peu différemment et éviter certaines répétitions. Vous pouvez essayer d'écrire le code sans "class" puis le restructurer pour les utiliser. Vous pouvez aussi tout coder avec des "class" (même si elles ne servent à rien, repeindre le monde avec des "class" aide à trouver les limites du concept).
Essayez de résoudre votre problème sans "class" dans un premier temps.

- W

Cela va me faire revenir 20 ans en arrière mais c'est sans nul doute la solution la plus pertinente

Trixel.py

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# coding: utf-8 
import datetime
import csv
 
def convertie_date(src):
    if src =='':
        valid_date = None
    else:
        #0123456890
        #2017-02-01
        #2017/02/01
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[5:7]) 
        alpha_jj =  int(src[8:11]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
        return None
 
 
class Base_Trx(object):
    rang = 0 
    def __init__(self,PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT):
        self.rang += 1 
        self.PRT = PRT
        self.GT = GT
        self.ORDRE = ORDRE
        self.MODULE = MODULE
        self.DT_DB_PRT = convertie_date(DT_DB_PRT)
        self.DT_FN_PRT = convertie_date(DT_FN_PRT)
        self.DT_DB_GT = convertie_date(DT_DB_GT)
        self.DT_FN_GT = convertie_date(DT_FN_GT)
 
 
    def __str__(self):
        resulta = "Indexe:" + str(self.rang ) + "\n"
        resulta += "PRT :" + str(self.PRT ) +"\n"
        resulta += "GT :" + str(self.GT ) +"\n"
        resulta += "ORDRE :" + str(self.ORDRE ) +"\n"
        resulta += "MODULE :" + str(self.MODULE ) +"\n"
        resulta += "DT_DB_PRT :" + str(self.DT_DB_PRT ) +"\n"
        resulta += "DT_FN_PRT :" + str(self.DT_FN_PRT ) +"\n"
        resulta += "DT_DB_GT :" + str(self.DT_DB_GT ) +"\n"
        resulta += "DT_FN_GT :" + str(self.DT_FN_GT ) +"\n"
        return resulta
 
 
    def __csv_donnee__(self):
        return [self.PRT,self.GT,self.ORDRE,self.MODULE,self.DT_DB_PRT,
                self.DT_FN_PRT,self.DT_DB_GT, self.DT_FN_GT]
 
    def __csv_entete__(self):
        return ["PRT","GT","ORDRE","MODULE","DT_DB_PRT","DT_FN_PRT","DT_DB_GT","DT_FN_GT"]
 
 
    def csv_donnee(self, nomfichier):
        ecrire_csv = csv.writer(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
        ecrire_csv.writerow(self.__csv_donnee__())  # donnée  
 
    def csv_entete(self,nomfichier):
        ecrire_csv = csv.writer(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
        ecrire_csv.writerow(self.__csv_entete__())  # donnée 
 
    def lire_csv(self,nomfichier):
            lire_csv = csv.reader(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            self.rang += 1 
            self.PRT = lire_csv[0]
            self.GT = lire_csv[1]
            self.ORDRE = lire_csv[2]
            self.MODULE = lire_csv[3]
            self.DT_DB_PRT = convertie_date(lire_csv[4])
            self.DT_FN_PRT = convertie_date(lire_csv[5])
            self.DT_DB_GT = convertie_date(lire_csv[6])
            self.DT_FN_GT = convertie_date(lire_csv[7])
 
 
class Les_Base_Trx(object):
    def __init__(self):
        self.Des_Base_Trx= list()
 
    def __str__(self):
        listeBase_Trx =""
        for un_Base_Trx in self.Liste_de_Base_Trx:
            if(listeBase_Trx=="" ):
                listeBase_Trx= str(un_Base_Trx)
            else:
               listeBase_Trx+= "/n/n" + str(un_Base_Trx)  
 
    def ajouter(self, Base_Trx): 
        """ Ajouter de l'objet issus du csv"""
        self.Des_Base_Trx.append(Base_Trx) 
 
 
    def charger(self,nomfichier):
        nb_ligne =0
        with open(nomfichier, 'r', newline='')   as fichier: 
            lire_fichier = csv.reader(fichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            for ligne in lire_fichier:
                print(ligne)
                if(nb_ligne!=0):
                    self.ajouter(Des_Base_Trx.lire_csv(nomfichier))
                nb_ligne+=1

Problème je ne suis pas certaine que ceci soit réellement utilisable

Code:

1
2
3
4
5
6
7
8
9
10
11
    def lire_csv(self,nomfichier):
            lire_csv = csv.reader(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            self.rang += 1 
            self.PRT = lire_csv[0]
            self.GT = lire_csv[1]
            self.ORDRE = lire_csv[2]
            self.MODULE = lire_csv[3]
            self.DT_DB_PRT = convertie_date(lire_csv[4])
            self.DT_FN_PRT = convertie_date(lire_csv[5])
            self.DT_DB_GT = convertie_date(lire_csv[6])
            self.DT_FN_GT = convertie_date(lire_csv[7])

lirecsv.py ce code lui non prob

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
38
39
40
41
42
43
44
45
46
 
 
'''
Created on 1 nov. 2017 
 
@author: 
'''
nom_fichier_prt =None 
fichier_csv_prt =None
ecrire_csv= None
if __name__ == '__main__':
    nom_fichier_path_in = explorateur_window (".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
        # ouverture du fichier excel
        # wb = xlrd.open_workbook(nom_fichier_path_in)
        # Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire complet
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
        creer_csv  = False
        nb_ligne =0
        with open(nom_fichier_path_in, 'r',newline='\n')   as fichier:  
            for ligne in fichier:
                PRT=ligne[0:15]
                GT=ligne[15:30]
                ORDRE=ligne[30:33]
                MODULE=ligne[33:48]
                DT_DB_PRT=ligne[48:58]
                DT_FN_PRT=ligne[58:68]
                DT_DB_GT=ligne[68:78]
                DT_FN_GT=ligne[78:88]                                
                monfic = Base_Trx(PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT)
                if(creer_csv ==False):
                    nom_fichier_prt = nom_fichier_path + "/resultat.csv"  
                    fichier_csv_prt = open(nom_fichier_prt, 'w', newline='') # Codage du fichier csv délimiter ligne /n estpar efaut  
                    monfic.csv_entete(fichier_csv_prt) # entete                
                    creer_csv = True 
                if(creer_csv ==True):
                    monfic.csv_donnee(fichier_csv_prt)
                print(monfic)
        if(creer_csv== True):
            fichier_csv_prt.close()    
    try: 
        print("")
    finally:  
        print("")

Au travers de cette class , je recherche a construire une méthode de chargement depuis la lecture de fichier csv.
Chaque enregistrement du fichier hormis l'entête ce base sur le class Base_Trx.
Mais je ne réuissit pas a formalisé le code qui permettrait d'avoir une class constituer de l'intégralité des données lu depuis le fichier csv.

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
class Les_Base_Trx(object):
    def __init__(self):
        self.Des_Base_Trx= list()
 
    def __str__(self):
        listeBase_Trx =""
        for un_Base_Trx in self.Liste_de_Base_Trx:
            if(listeBase_Trx=="" ):
                listeBase_Trx= str(un_Base_Trx)
            else:
               listeBase_Trx+= "/n/n" + str(un_Base_Trx)  
 
    def ajouter(self, Base_Trx): 
        """ Ajouter de l'objet issus du csv"""
        self.Des_Base_Trx.append(Base_Trx) 
 
 
    def charger(self,nomfichier):
        nb_ligne =0
        with open(nomfichier, 'r', newline='')   as fichier: 
            lire_fichier = csv.reader(fichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            for ligne in lire_fichier:
                print(ligne)
                if(nb_ligne!=0):
                    self.ajouter(Des_Base_Trx.lire_csv(nomfichier))
                nb_ligne+=1

Autre point

Quand à cette partie du code il n'est pas viable.:aie:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
Cette méthode de la class Base_Trx ,ce veut une méthode de chargement d'un enregistrement du fichier csv dans un objet de type  Base_Trx
une sorte de méthode  def __init__() utlisant  les donnée lues  sur la ligne courant du fichier (a mexeception de l'entête)  mais voila cela ne marche pas  ?
 
 def lire_csv(self,nomfichier):
            lire_csv = csv.reader(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            self.rang += 1 
            self.PRT = lire_csv[0]
            self.GT = lire_csv[1]
            self.ORDRE = lire_csv[2]
            self.MODULE = lire_csv[3]
            self.DT_DB_PRT = convertie_date(lire_csv[4])
            self.DT_FN_PRT = convertie_date(lire_csv[5])
            self.DT_DB_GT = convertie_date(lire_csv[6])
            self.DT_FN_GT = convertie_date(lire_csv[7])

06/11/2017, 07h57
wiztricks

Salut,

Pourquoi poster vos brouillons de code sans formuler de question ?

- W

Je pense avoir trouver la solution

Voici la solution mise en place qui fonctionne.

le code des class trixel.py

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
# coding: utf-8 
import datetime
import csv
 
def convertie_date(src):
    if src =='':
        valid_date = None
    else:
        #0123456890
        #2017-02-01
        #2017/02/01
        alpha_aaaa = int(src[0:4]) 
        alpha_mm =   int(src[5:7]) 
        alpha_jj =  int(src[8:11]) 
        try :
            valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
            return valid_date
        except ValueError:
            print('%s Date invalide !' % src)
        return None
 
 
class Base_Trx(object):
    rang = 0 
    def __init__(self,PRT,GT,ORDRE,MODULE,DT_DB_PRT,DT_FN_PRT,DT_DB_GT,DT_FN_GT):
        self.rang += 1 
        self.PRT = PRT
        self.GT = GT
        self.ORDRE = ORDRE
        self.MODULE = MODULE
        self.DT_DB_PRT = convertie_date(DT_DB_PRT)
        self.DT_FN_PRT = convertie_date(DT_FN_PRT)
        self.DT_DB_GT = convertie_date(DT_DB_GT)
        self.DT_FN_GT = convertie_date(DT_FN_GT)
 
 
    def __str__(self):
        resulta = "Indexe:" + str(self.rang ) + "\n"
        resulta += "PRT :" + str(self.PRT ) +"\n"
        resulta += "GT :" + str(self.GT ) +"\n"
        resulta += "ORDRE :" + str(self.ORDRE ) +"\n"
        resulta += "MODULE :" + str(self.MODULE ) +"\n"
        resulta += "DT_DB_PRT :" + str(self.DT_DB_PRT ) +"\n"
        resulta += "DT_FN_PRT :" + str(self.DT_FN_PRT ) +"\n"
        resulta += "DT_DB_GT :" + str(self.DT_DB_GT ) +"\n"
        resulta += "DT_FN_GT :" + str(self.DT_FN_GT ) +"\n"
        return resulta
 
 
    def __csv_donnee__(self):
        return [self.PRT,self.GT,self.ORDRE,self.MODULE,self.DT_DB_PRT,
                self.DT_FN_PRT,self.DT_DB_GT, self.DT_FN_GT]
 
    def __csv_entete__(self):
        return ["PRT","GT","ORDRE","MODULE","DT_DB_PRT","DT_FN_PRT","DT_DB_GT","DT_FN_GT"]
 
 
    def csv_donnee(self, nomfichier):
        ecrire_csv = csv.writer(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
        ecrire_csv.writerow(self.__csv_donnee__())  # donnée  
 
    def csv_entete(self,nomfichier):
        ecrire_csv = csv.writer(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
        ecrire_csv.writerow(self.__csv_entete__())  # donnée 
 
    def lire_csv(self,nomfichier):
            lire_csv = csv.reader(nomfichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            self.rang += 1 
            self.PRT = lire_csv[0]
            self.GT = lire_csv[1]
            self.ORDRE = lire_csv[2]
            self.MODULE = lire_csv[3]
            self.DT_DB_PRT = convertie_date(lire_csv[4])
            self.DT_FN_PRT = convertie_date(lire_csv[5])
            self.DT_DB_GT = convertie_date(lire_csv[6])
            self.DT_FN_GT = convertie_date(lire_csv[7])
 
 
class Les_Base_Trx(object):
    def __init__(self):
        self.Des_Base_Trx= list()
 
    def __str__(self):
        listeBase_Trx =""
        for un_Base_Trx in self.Des_Base_Trx:
            if(listeBase_Trx=="" ):
                listeBase_Trx= str(un_Base_Trx)
            else:
                listeBase_Trx+= "\n\n" + str(un_Base_Trx)  
        return    listeBase_Trx     
 
    def ajouter(self, Base_Trx): 
        """ Ajouter de l'objet issus du csv"""
        self.Des_Base_Trx.append(Base_Trx) 
 
 
    def charger(self,nomfichier):
        nb_ligne =0
        with open(nomfichier, 'r', newline='')   as fichier: 
            lire_fichier = csv.reader(fichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            for ligne in lire_fichier:
                if(nb_ligne!=0):
                    ligne_csv=Base_Trx(ligne[0],ligne[1],ligne[2],ligne[3],ligne[4],ligne[5],ligne[6],ligne[7])
                    ligne_csv.rang = nb_ligne
                    self.ajouter(ligne_csv)
                nb_ligne+=1

le code du lecteur du fichir csv avec les 2 méthodes

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
38
39
40
41
42
43
44
# coding: utf-8  
import string
import sys
import datetime
import csv
import os
 
from  Explorateur import *
from  Trixel import *
 
'''
Created on 1 nov. 2017 
 
@author: EricSVlo
'''
obj= None
un_Les_Base_Trx = Les_Base_Trx()
 
if __name__ == '__main__':
    nom_fichier_path_in = explorateur_window (".//") # Recherche via explorateur
    if os.path.isfile(nom_fichier_path_in):
        # ouverture du fichier excel
        # wb = xlrd.open_workbook(nom_fichier_path_in)
        # Ouverture du fichier destination
        nom_fichier_in = os.path.basename(nom_fichier_path_in) # Retourne le nom du fichier
        nom_fichier_path = os.path.dirname(nom_fichier_path_in) # Retourne le répertoire complet
        list_nf = os.path.split(nom_fichier_path_in) # Fractionne le chemin d'acc�s. Retourne un tuple
        nb_ligne =0
        # Méthode N°1 ligne par ligne
        with open(nom_fichier_path_in, 'r', newline='')   as fichier:  
            lire_fichier = csv.reader(fichier, delimiter = ';') # Codage du fichier csv délimiter de champ
            for ligne in lire_fichier:
                if(nb_ligne!=0):
                    obj=Base_Trx(ligne[0],ligne[1],ligne[2],ligne[3],ligne[4],ligne[5],ligne[6],ligne[7])
                nb_ligne+=1
        # Méthode N°1 tous le fichier
        with open(nom_fichier_path_in, 'r', newline='')   as fichier:  
            un_Les_Base_Trx.charger(nom_fichier_path_in)
        print(un_Les_Base_Trx)   
    try: 
        print("")
    finally:  
        print("")    
    pass

La seule petite chose qui me géne est ceci

Code:

obj=Base_Trx(ligne[0],ligne[1],ligne[2],ligne[3],ligne[4],ligne[5],ligne[6],ligne[7])

Code:

ligne_csv=Base_Trx(ligne[0],ligne[1],ligne[2],ligne[3],ligne[4],ligne[5],ligne[6],ligne[7])

j'aimerai trouve une solution plus élégante pour creer les donnees de ces 2 classes avez-vous une idée?

et dernier point je cherche toujours a mettre des class dans un affichage d'outil UML a partir du code python , je trouve des outils payant mais qui d'outil gratuit , existe t'il quelque chose sur eclipse?

06/11/2017, 16h24
wiztricks

Salut,

Citation:

Envoyé par dedalios

j'aimerai trouve une solution plus élégante pour creer les donnees de ces 2 classes avez-vous une idée?

C'est sûr que pour créer une liste de tuple çà fait "compliqué".
Vous devriez peut-être (re)voir ce qu'on appelle (un)packing des listes d'arguments. Cela permettrait d'écrire obj=Base_Trx(*ligne).
Çà serait bien aussi de regarder les namedtuple.

- W
06/11/2017, 23h23
dedalios

Citation:

Envoyé par wiztricks

Salut,

C'est sûr que pour créer une liste de tuple çà fait "compliqué".
Vous devriez peut-être (re)voir ce qu'on appelle (un)packing des listes d'arguments. Cela permettrait d'écrire obj=Base_Trx(*ligne).
Çà serait bien aussi de regarder les namedtuple.

- W

Merci effectivement plus simple.