IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Convertion csv vers python


Sujet :

Python

  1. #1
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut Convertion csv vers python
    Bonjour

    Dans ce code la lecture du fichier csv charge a chaque enregistrement la Base Python


    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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
     # coding: utf-8  
    '''
    Created on 23 mars 2018
     
    @author: 
    '''
    import csv
    import sqlite3
    import sys
    import datetime
    import csv
    import os
    import encodings
    from unidecode import unidecode
    from codecs import open
     
    def convertie_date(src):
        if src =='NULL':
            valid_date = None
        else:
            alpha_aaaa = int(src[0:4]) 
            alpha_mm =   int(src[4:6]) 
            alpha_jj =  int(src[6:8]) 
            try :
                valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
                return valid_date
            except ValueError:
                print('%s Date invalide !' % src)
                return None
    pass  
     
    def EstceNull(src):
        if src =='NULL':
            return  None
        else:
            return src
     
    def Estce_nombreNull(src):
        if src =='NULL':
            return  None
        else:
            return int(src)    
     
    class ExcelFr(csv.excel):
        # Séparateur de champ
        delimiter = ";"
        # Séparateur de ''chaîne''
        quotechar = None
        # Gestion du séparateur dans les ''chaînes''
        escapechar = None
        doublequote = True
        # Fin de ligne
        lineterminator = "\r\n"
        # Ajout automatique du séparateur de chaîne (pour ''writer'')
        quoting = csv.QUOTE_NONE
        # Ne pas ignorer les espaces entre le délimiteur de chaîne
        # et le texte
        skipinitialspace = False 
     
     
    class vls_actes(object):
     
        def __init__(self,liste):
     
            self.ACT_CODE = EstceNull(liste[0]);
            self.ACT_LIBELLE = EstceNull(liste[1]);
     
        def __str__(self):
            resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
            resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
            return  resultat
     
        def table_sqllite(self,Base):
            creer_table  = """CREATE TABLE vsl_actes(
                ACT_CODE TEXT(255) NOT NULL,
                ACT_LIBELLE TEXT(255),
                CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
            );
            """ 
     
            detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
     
            curseur =  Base.cursor() # appel au curseur
     
            # supprimer table existante
            if(detruire_table !=""):
                try:
                    curseur.execute(detruire_table)  
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                    Base.rollback()
                else:
                  Base.commit()    
     
            pass       
            if(creer_table !=""):
                print("creer base")
                try:
                    curseur.execute(creer_table)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"++ creer_table )  
                    Base.rollback()
                else:
                  Base.commit()    
            pass
     
        def insertion_sqllite(self,Base):
     
            curseur = Base.cursor() # appel au curseur
            data=[self.ACT_CODE,self.ACT_LIBELLE]
     
            if(self.ACT_CODE == '9BFC1'):
                print(data)     
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
     
            try:
                curseur.execute(rq,data)
     
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                Base.rollback()
            else: 
                Base.commit()  
     
    def actes(nomfichier,Base):
     
        file = open(nomfichier,  encoding='utf8')
        i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
        #
        # Ouverture du fichier source.
        #
        try:
            #
            # Cr�ation du ''lecteur'' CSV.
            #
            fichier_lu = csv.reader(file, 'excel-fr')
     
            max_long_ACT_CODE = 0
            max_long_ACT_LIBELLE = 0
            for row in fichier_lu:
                i+=1
     
                if(i>1):
                    nouvel_acte = vls_actes(row)  
     
                    if(i==2): # Suppprsseion de la table precedente  si besion 
                        # creation de la nouvelle table 
                        nouvel_acte.table_sqllite(Base)
                    # insertion de donnees
                    nouvel_acte.insertion_sqllite(Base)
     
                    if(max_long_ACT_CODE < len(nouvel_acte.ACT_CODE)):
                         max_long_ACT_CODE = len(nouvel_acte.ACT_CODE)
     
                    if(max_long_ACT_LIBELLE < len(nouvel_acte.ACT_LIBELLE)):
                         max_long_ACT_LIBELLE = len(nouvel_acte.ACT_LIBELLE)
     
            #print(max_long_ACT_CODE, end='\n' )
            #print(max_long_ACT_LIBELLE , end='\n')
        except OSError:
                print("Problème d'access au fichier :" + nomfichier)
        finally:
            #
            # Fermeture du fichier source
            #
            file.close()     
     
     
     
    if __name__ == '__main__':
        # Enregistre ce dialecte aupres du module csv
        encodage ="utf-8"
        LaBase ="nombase2.sq3" 
        Base = sqlite3.connect(LaBase)
        csv.register_dialect('excel-fr', ExcelFr())
     
        actes("actes.csv" , Base)
     
        Base.close()

    Problème j'ai 15 fichiers de ce type a convertir dans une seule base de données .
    Les structures de base sont pour chaque cas specifique.
    mais sur ce moèle j'ai creer 5 tables ( et les autres sont en ours de finalisation).

    Pour autant avec autant de donnée a charge la fait de réaliser l'insertion dans la base cela duree 1h30.
    le plus gros fichier fait 1250ko et les autres 5ko.

    Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert .

    je me demande quelle solution est la plus pertinante.

    modifier la classe: class vls_GTs(object):
    pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
    est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.

  2. #2
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Je cherche donc realiser les insertions en base par bloc de 50 voir 100 insert.
    Pour faire çà, il faut avoir des listes de tuples et utiliser executemany

    Citation Envoyé par dedalios Voir le message
    je me demande quelle solution est la plus pertinante.

    modifier la classe: class vls_GTs(object):
    pour avoir la classe de class vls_GTs(object): qui convertie les donnes csv.
    est une classe class DB_GTs(vls_GTs): charger de faire l'opération en base d'insertion.
    Tant que vous alimentez executemany en tuples, ranger votre code en class (ou pas), c'est pas çà qui fera le boulot...

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  3. #3
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut idee
    bonjour ,

    mon idee est de découper la class vsl_actes en 2parties.
    creer une class bd_actes
    qui charge un objet vls_actes


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class vls_actes(object):
     
        def __init__(self,liste):
     
            self.ACT_CODE = EstceNull(liste[0]);
            self.ACT_LIBELLE = EstceNull(liste[1]);
     
        def __str__(self):
            resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
            resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
            return  resultat
     
    ...
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    class bd_actes(object):
      les_actes = vls_actes[]
        def __init__(self,liste):


    Charger les donnees du fichier lu dans un objet bd_actes via des append(x)

    puis transferrer les donnees à la base pour bloc.

    Classe ou pas, en fait c'est plus pour améliorer ma compréhension du monde objet.

  4. #4
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    mon idee est de découper la class vsl_actes en 2parties.
    creer une class bd_actes qui charge un objet vls_actes
    Si vous voulez allez vite, difficile de passer à côté d'executemany...
    Et pour passer par là, il faut commencer par respecter/s'aligner avec l'interface proposée....
    Ce qui réduit les options qu'on peut (imaginer) avoir.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  5. #5
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut reflexion
    Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code
    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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    # coding: utf-8  
    '''
    Created on 23 mars 2018
     
    @author: 
    '''
    import csv
    import sqlite3
    import sys
    import datetime
    import csv
    import os
    import encodings
     
    from codecs import open
     
    def convertie_date(src):
        if src =='NULL':
            valid_date = None
        else:
            alpha_aaaa = int(src[0:4]) 
            alpha_mm =   int(src[4:6]) 
            alpha_jj =  int(src[6:8]) 
            try :
                valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
                return valid_date
            except ValueError:
                print('%s Date invalide !' % src)
                return None
    pass  
     
    def EstceNull(src):
        if src =='NULL':
            return  None
        else:
            return src
     
    def Estce_nombreNull(src):
        if src =='NULL':
            return  None
        else:
            return int(src)    
     
    class ExcelFr(csv.excel):
        # Séparateur de champ
        delimiter = ";"
        # Séparateur de ''chaîne''
        quotechar = None
        # Gestion du séparateur dans les ''chaînes''
        escapechar = None
        doublequote = True
        # Fin de ligne
        lineterminator = "\r\n"
        # Ajout automatique du séparateur de chaîne (pour ''writer'')
        quoting = csv.QUOTE_NONE
        # Ne pas ignorer les espaces entre le délimiteur de chaîne
        # et le texte
        skipinitialspace = False 
     
     
    class vls_actes(object):
     
        def __init__(self,liste):
     
            self.ACT_CODE = EstceNull(liste[0]);
            self.ACT_LIBELLE = EstceNull(liste[1]);
     
        def __str__(self):
            resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
            resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
            return  resultat
     
        def insertion_sqllite(self,Base):
     
            curseur = Base.cursor() # appel au curseur
            data=[self.ACT_CODE,self.ACT_LIBELLE]
     
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
     
            try:
                curseur.execute(rq,data)
     
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                Base.rollback()
            else: 
                Base.commit()  
     
    class Les_Actes(object):
        def __init__(self,Nomfichier,Base):
            self.Les_Actes=[]
            self.Nomfichier=Nomfichier
            self.Base=Base
            file = open(self.Nomfichier,  encoding='utf8')
            i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
            #
            # Ouverture du fichier source.
            #
            try:
                #
                # Cr�ation du ''lecteur'' CSV.
                #
                fichier_lu = csv.reader(file, 'excel-fr')
     
                max_long_ACT_CODE = 0
                max_long_ACT_LIBELLE = 0
                for row in fichier_lu:
                    i+=1
     
                    if(i>1):
                        nouvel_acte = vls_actes(row)  
                        self.Les_Actes.append(nouvel_acte) 
     
            except OSError:
                print("Problème d'access au fichier :" + self.Nomfichier)
            finally:
                #
                # Fermeture du fichier source
                #
                file.close()             
     
        def __str__(self):  
            resultat =""
            for actes in self.Les_Actes:
                if(actes ==""):
                    resultat = str(actes)
                else:
                    resultat += "/n" + str(actes)
            return resultat
     
        def table_sqllite(self,Base):
            creer_table  = """CREATE TABLE vsl_actes(
                ACT_CODE TEXT(255) NOT NULL,
                ACT_LIBELLE TEXT(255),
                CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
            );
            """ 
     
            detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
     
            curseur =  Base.cursor() # appel au curseur
     
            # supprimer table existante
            if(detruire_table !=""):
                try:
                    curseur.execute(detruire_table)  
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                    Base.rollback()
                else:
                    Base.commit()    
     
     
            if(creer_table !=""):
                print("creer base")
                try:
                    curseur.execute(creer_table)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ creer_table )  
                    Base.rollback()
                else:
                    Base.commit()    
     
            index_table =""" CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""       
            if(index_table !=""):
                try:
                    curseur.execute(index_table)
     
                except sqlite3.Error as e:
                    print("Problème de creation d'index : "  +   e.args[0]  + "/n" )  
                    print(index_table)
                    Base.rollback()
                else: 
                    Base.commit()      
     
     # self.GEL_CODE = self.GEL_CODE[7:12]
            pass
     
        def insertion_sqllite(self,Base):
            for actes in self.Les_Actes:
                # insrtion
     
                curseur = Base.cursor() # appel au curseur
     
                data=[actes.ACT_CODE,actes.ACT_LIBELLE]
     
                rq = """       INSERT INTO vsl_actes
                                (ACT_CODE, ACT_LIBELLE)
                                   VALUES(?, ?);"""
     
                try:
                    curseur.executemany(rq,data)
     
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                    print(rq)
                    print(data)
                    Base.rollback()
                else: 
                    Base.commit() 
     
     
     
    if __name__ == '__main__':
        # Enregistre ce dialecte aupr�s du module csv
        encodage ="utf-8"
        LaBase ="actes.sq3" 
        Base = sqlite3.connect(LaBase)
        csv.register_dialect('excel-fr', ExcelFr())
     
        traiter_actes =  Les_Actes("actes.csv" , Base)
        traiter_actes.table_sqllite(Base)
        traiter_actes.insertion_sqllite(Base)
     
        Base.close()

  6. #6
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Voici la base de mes réflexions , je n'ai pas test pour l'instant ce code
    Certes mais y-a-t-il une question en rapport avec le sujet?

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  7. #7
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut voila 2 version du code avec 2 erreurs
    voici les codes .
    sur le principe je lis un fichiercsv .
    je transfert les donnees pour appliquer divers correction à un objet de type vls_actes qui est le reflet de la base de donne a produire
    chaque lecture charge aussi une liste d'un objet de type Les_Actes(object) qui contient une liste d'objet self.Les_Actes de type vls_actes
    hormis la denommination qui pourrait etre différentié entre

    le nom de la class Les_Actes(object) et la vauer self.Les_Actes de ce meme objet . Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas


    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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    # coding: utf-8  
    '''
    Created on 23 mars 2018
     
    @author: 
    '''
    import csv
    import sqlite3
    import sys
    import datetime
    import csv
    import os
    import encodings
     
    from codecs import open
     
    def convertie_date(src):
        if src =='NULL':
            valid_date = None
        else:
            alpha_aaaa = int(src[0:4]) 
            alpha_mm =   int(src[4:6]) 
            alpha_jj =  int(src[6:8]) 
            try :
                valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
                return valid_date
            except ValueError:
                print('%s Date invalide !' % src)
                return None
    pass  
     
    def EstceNull(src):
        if src =='NULL':
            return  None
        else:
            return src
     
    def Estce_nombreNull(src):
        if src =='NULL':
            return  None
        else:
            return int(src)    
     
    class ExcelFr(csv.excel):
        # Séparateur de champ
        delimiter = ";"
        # Séparateur de ''chaîne''
        quotechar = None
        # Gestion du séparateur dans les ''chaînes''
        escapechar = None
        doublequote = True
        # Fin de ligne
        lineterminator = "\r\n"
        # Ajout automatique du séparateur de chaîne (pour ''writer'')
        quoting = csv.QUOTE_NONE
        # Ne pas ignorer les espaces entre le délimiteur de chaîne
        # et le texte
        skipinitialspace = False 
     
     
    class vls_actes(object):
     
        def __init__(self,liste):
     
            self.ACT_CODE = EstceNull(liste[0]);
            self.ACT_LIBELLE = EstceNull(liste[1]);
     
        def __str__(self):
            resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
            resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
            return  resultat
     
        def insertion_sqllite(self,Base):
     
            curseur = Base.cursor() # appel au curseur
            data=[self.ACT_CODE,self.ACT_LIBELLE]
     
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
     
            try:
                curseur.execute(rq,data)
     
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                print(rq)
                Base.rollback()
            else: 
                Base.commit()  
     
    class Les_Actes(object):
        def __init__(self,Nomfichier,Base):
            self.Les_Actes=[]
            self.Nomfichier=Nomfichier
            self.Base=Base
            file = open(self.Nomfichier,  encoding='utf8')
            i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
            #
            # Ouverture du fichier source.
            #
            try:
                #
                # Cr�ation du ''lecteur'' CSV.
                #
                fichier_lu = csv.reader(file, 'excel-fr')
     
                max_long_ACT_CODE = 0
                max_long_ACT_LIBELLE = 0
                for row in fichier_lu:
                    i+=1
     
                    if(i>1):
                        nouvel_acte = vls_actes(row)  
                        self.Les_Actes.append(nouvel_acte) 
     
            except OSError:
                print("Problème d'access au fichier :" + self.Nomfichier)
            finally:
                #
                # Fermeture du fichier source
                #
                file.close()             
     
        def __str__(self):  
            resultat =""
            for actes in self.Les_Actes:
                if(actes ==""):
                    resultat = str(actes)
                else:
                    resultat += "/n" + str(actes)
            return resultat
     
        def table_sqllite(self,Base):
            creer_table  = """CREATE TABLE vsl_actes(
                ACT_CODE TEXT(255) NOT NULL,
                ACT_LIBELLE TEXT(255),
                CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
            );
            """ 
     
            detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
     
            curseur =  Base.cursor() # appel au curseur
     
            # supprimer table existante
            if(detruire_table !=""):
                try:
                    curseur.execute(detruire_table)  
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ detruire_table )
                    Base.rollback()
                else:
                    Base.commit()    
     
     
            if(creer_table !=""):
                print("creer base")
                try:
                    curseur.execute(creer_table)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande /n"+ creer_table )  
                    Base.rollback()
                else:
                    Base.commit()    
     
            index_table =""" CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""       
            if(index_table !=""):
                try:
                    curseur.execute(index_table)
     
                except sqlite3.Error as e:
                    print("Problème de creation d'index : "  +   e.args[0]  + "/n" )  
                    print(index_table)
                    Base.rollback()
                else: 
                    Base.commit()      
     
     # self.GEL_CODE = self.GEL_CODE[7:12]
            pass
     
        def insertion_sqllite(self,Base):
            for actes in self.Les_Actes:
                # insrtion
     
                curseur = Base.cursor() # appel au curseur
     
                data=[actes.ACT_CODE,actes.ACT_LIBELLE]
     
                rq = """       INSERT INTO vsl_actes
                                (ACT_CODE, ACT_LIBELLE)
                                   VALUES(?, ?);"""
     
                try:
                    curseur.executemany(rq,data)
     
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion /n" )  
                    print(rq)
                    print(data)
                    Base.rollback()
                else: 
                    Base.commit() 
     
     
     
    if __name__ == '__main__':
        # Enregistre ce dialecte aupr�s du module csv
        encodage ="utf-8"
        LaBase ="actes.sq3" 
        Base = sqlite3.connect(LaBase)
        csv.register_dialect('excel-fr', ExcelFr())
     
        traiter_actes =  Les_Actes("actes.csv" , Base)
        traiter_actes.table_sqllite(Base)
        traiter_actes.insertion_sqllite(Base)
     
        Base.close()



    Problème :Incorrect number of bindings supplied. The current statement uses 2, and there are 5 supplied.
    sur commande d'insertion

    INSERT INTO vsl_actes
    (ACT_CODE, ACT_LIBELLE)
    VALUES(?, ?);
    data= ['9BLA6', '9BLA6']



    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
    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
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    # coding: utf-8  
    '''
    Created on 23 mars 2018
     
    @author: 
    '''
    import csv
    import sqlite3
    import sys
    import datetime
    import csv
    import os
    import encodings
     
    from codecs import open
     
    def convertie_date(src):
        if src =='NULL':
            valid_date = None
        else:
            alpha_aaaa = int(src[0:4]) 
            alpha_mm =   int(src[4:6]) 
            alpha_jj =  int(src[6:8]) 
            try :
                valid_date = datetime.date(alpha_aaaa,alpha_mm,alpha_jj) 
                return valid_date
            except ValueError:
                print('%s Date invalide !' % src)
                return None
    pass  
     
    def EstceNull(src):
        if src =='NULL':
            return  None
        else:
            return src
     
    def Estce_nombreNull(src):
        if src =='NULL':
            return  None
        else:
            return int(src)    
     
    class ExcelFr(csv.excel):
        # Séparateur de champ
        delimiter = ";"
        # Séparateur de ''chaîne''
        quotechar = None
        # Gestion du séparateur dans les ''chaînes''
        escapechar = None
        doublequote = True
        # Fin de ligne
        lineterminator = "\r\n"
        # Ajout automatique du séparateur de chaîne (pour ''writer'')
        quoting = csv.QUOTE_NONE
        # Ne pas ignorer les espaces entre le délimiteur de chaîne
        # et le texte
        skipinitialspace = False 
     
     
    class vls_actes(object):
     
        def __init__(self,liste):
     
            self.ACT_CODE = EstceNull(liste[0]);
            self.ACT_LIBELLE = EstceNull(liste[1]);
     
        def __str__(self):
            resultat = "Act_Code : " +  str(self.ACT_CODE) + "\n"
            resultat += "ACT_LIBELLE: " + str(self.ACT_LIBELLE )  
            return  resultat
     
        def insertion_sqllite(self,Base):
     
            curseur = Base.cursor() # appel au curseur
            data=[self.ACT_CODE,self.ACT_LIBELLE]
     
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
     
            try:
                curseur.execute(rq,data)
     
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion \n" )  
                print(rq)
                Base.rollback()
            else: 
                Base.commit()  
     
    class Les_Actes(object):
        def __init__(self,Nomfichier,Base):
            self.Les_Actes=[]
            self.Nomfichier=Nomfichier
            self.Base=Base
            file = open(self.Nomfichier,  encoding='utf8')
            i=0 # indeteur de ligne du fichier pour ne pas traiter l'entete 
            #
            # Ouverture du fichier source.
            #
            try:
                #
                # Cr�ation du ''lecteur'' CSV.
                #
                fichier_lu = csv.reader(file, 'excel-fr')
     
                max_long_ACT_CODE = 0
                max_long_ACT_LIBELLE = 0
                for row in fichier_lu:
                    i+=1
     
                    if(i>1):
                        nouvel_acte = vls_actes(row)  
                        self.Les_Actes.append(nouvel_acte) 
     
            except OSError:
                print("Problème d'access au fichier :" + self.Nomfichier)
            finally:
                #
                # Fermeture du fichier source
                #
                file.close()             
     
        def __str__(self):  
            resultat =""
            for actes in self.Les_Actes:
                if(actes ==""):
                    resultat =  actes.ACT_CODE  +"/" + actes.ACT_LIBELLE
                else:
                    resultat += "\n" + actes.ACT_CODE  +"/" + actes.ACT_LIBELLE
            return resultat
     
        def table_sqllite(self,Base):
            creer_table  = """CREATE TABLE vsl_actes(
                ACT_CODE TEXT(255) NOT NULL,
                ACT_LIBELLE TEXT(255),
                CONSTRAINT actes_pk PRIMARY KEY(ACT_CODE)
            );
            """ 
     
            detruire_table  = """DROP TABLE IF EXISTS vsl_actes;"""
     
            curseur =  Base.cursor() # appel au curseur
     
            # supprimer table existante
            if(detruire_table !=""):
                try:
                    curseur.execute(detruire_table)  
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande \n"+ detruire_table )
                    Base.rollback()
                else:
                    Base.commit()    
     
     
            if(creer_table !=""):
                print("creer base")
                try:
                    curseur.execute(creer_table)
                except sqlite3.Error as e:
                    print("Problème"+ " :" +   e.args[0]  + " sur commande \n"+ creer_table )  
                    Base.rollback()
                else:
                    Base.commit()    
     
            index_table =""" CREATE INDEX vsl_actes_IDX ON vsl_actes(ACT_LIBELLE);"""       
            if(index_table !=""):
                try:
                    curseur.execute(index_table)
     
                except sqlite3.Error as e:
                    print("Problème de creation d'index : "  +   e.args[0]  + "\n" )  
                    print(index_table)
                    Base.rollback()
                else: 
                    Base.commit()      
     
     # self.GEL_CODE = self.GEL_CODE[7:12]
            pass
     
        def insertion_sqllite(self,Base):
     
            #for actes in self.Les_Actes:
                # insrtion
     
            curseur = Base.cursor() # appel au curseur
     
            #data=[actes.ACT_CODE,actes.ACT_LIBELLE]
     
            rq = """       INSERT INTO vsl_actes
                            (ACT_CODE, ACT_LIBELLE)
                               VALUES(?, ?);"""
     
            try:
                curseur.executemany(rq,self.Les_Actes)
     
            except sqlite3.Error as e:
                print("Problème"+ " :" +   e.args[0]  + " sur commande d'insertion \n" )  
                print(rq)
     
                Base.rollback()
            else: 
                Base.commit() 
     
     
     
    if __name__ == '__main__':
        # Enregistre ce dialecte aupr�s du module csv
        encodage ="utf-8"
        LaBase ="actes.sq3" 
        Base = sqlite3.connect(LaBase)
        csv.register_dialect('excel-fr', ExcelFr())
     
        traiter_actes =  Les_Actes("actes.csv" , Base)
        traiter_actes.table_sqllite(Base)
        #print(traiter_actes)
        traiter_actes.insertion_sqllite(Base)
     
        Base.close()

    lorsque je lance ce 2ieme code problème
    creer base
    Traceback (most recent call last):
    File " actes2.py", line 218, in <module>
    traiter_actes.insertion_sqllite(Base)
    File " actes2.py", line 196, in insertion_sqllite
    curseur.executemany(rq,self.Les_Actes)
    ValueError: parameters are of unsupported type

  8. #8
    Expert confirmé
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 486
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 486
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Logiquement, executemany devrait avoir en 2ème argument une liste de listes (ou liste de tuples), chaque sous-liste étant appliquée successivement à la requête SQL. En fait, quand l'erreur dit "and there are 5 supplied", il prend chacun des caractères de '9BLA6'.

  9. #9
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Salut,

    Citation Envoyé par dedalios Voir le message
    Je cherche a comprendre pourquoi le chargement vai execute many ne fonctionne pas
    Dans votre histoire, il y a un Reader qui lit le fichier CSV et produit des enregistrements qui seront cohérents avec le schéma de la BDD et un Writer qui s'occupe d'écrire ces enregistrements et au milieu un machin qui tire les enregistrements du Reader pour les pousser dans le Writer.

    Et si on écrit çà pour voir comment çà marche, çà devrait/pourrait ressembler à:
    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
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    import csv
    import sqlite3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')
     
    class Reader:
        def __init__(self, file):
            self._reader = csv.reader(file, delimiter=' ')
     
        def get_records(self, count=2):
            records = []
            try:
                for _ in range(count):
                    row = next(self._reader)
                    records.append(record(int(row[0]), row[1]))
            except StopIteration:
                pass
            except:
                raise
            return records
     
     
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
            cnx.execute('''create table if not exists actes(code integer, libelle text);''')
     
        def write(self, records):
            with self._cnx:
                self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
     
        def dump(self):
            with self._cnx:
                for row in self._cnx.execute('select * from actes'):
                    print (row)
     
    def load(reader, writer):
        while 1:
     
            records = reader.get_records()
            if not records: break
            writer.write(records)
     
     
    if __name__ == '__main__':
        from io import StringIO
     
        actes = ('1 aaa\n'
                 '2 bbb\n'
                 '3 ccc\n'
                 '4 ddd\n'
                 '5 ddd\n'
                 )
     
        writer = Writer()
        load(Reader(StringIO(actes)), writer)
        writer.dump()
    Une fois cette mécanique maîtrisée, "spécialiser" en fonction des différents fichiers et des tables à remplir seront d'autres détails à triturer.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  10. #10
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut QUid de ce code
    Que veulent dire ces parties du code ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
    :memory: la base sql est en mémoire , pas de conservation poste traitement ?



    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
        from io import StringIO
     
        actes = ('1 aaa\n'
                 '2 bbb\n'
                 '3 ccc\n'
                 '4 ddd\n'
                 '5 ddd\n'
                 )
    il s'agit d'une simulation du fichier csv?


  11. #11
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Salut,

    Citation Envoyé par dedalios Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
    :memory: la base sql est en mémoire , pas de conservation poste traitement ?
    Est-ce que vous avez essayé avec un fichier?

    Je trouve qu'il est plus simple de commencer avec "tout en mémoire", histoire de repartir d'un état "clean" lors des premières mises au point. De même qu'il est plus simple de partir d'un exemple de fichier CSV de quelques lignes.

    L'objectif étant d'illustrer le découpage des traitements entre Reader et Writer et l'utilisation d'executemany (et la construction de listes de tuple), y a-t-il besoin de plus?

    Citation Envoyé par dedalios Voir le message
    Que veulent dire ces parties du code ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')
    collections et io sont des bibliothèques standards. Il suffit d'ouvrir la documentation pour voir ce que c'est.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  12. #12
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut
    Malheureusement cela n'est pas toujours possible ,définition des données non existante.
    Double enregistrement sur les fichiers...

    mais merci pour ces infors

  13. #13
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Malheureusement cela n'est pas toujours possible définition des données non existante.
    Double enregistrement sur les fichiers...
    Qu'est ce qui n'est pas possible? Utiliser executemany? Faire un brouillon de code avec des données significatives pour s'assurer que le code qui est derrière saura les traiter? Découper les activités en Reader et Writer?

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  14. #14
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut pourquoi la cle prmaire régit elle
    bonjour

    J'ai reprise ce code et j'ai ajouter
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
                    if(record(int(row[0]), row[1]) not in records):
                        records.append(record(int(row[0]), row[1]))
    ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information

    donc afin que le derniere enregsitrement ne soit pas chargé dans records

    LE CODE COMPLET
    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
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    # coding: utf-8  
    import csv
    import sqlite3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')
     
    class Reader:
        def __init__(self, file):
            self._reader = csv.reader(file, delimiter=' ')
     
        def get_records(self, count=2):
            records = []
            try:
                for _ in range(count):
                    row = next(self._reader)
                    if(record(int(row[0]), row[1]) not in records):
                        records.append(record(int(row[0]), row[1]))
     
     
            except StopIteration:
                pass
            except:
                raise
            return records
     
     
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
            cnx.execute('''create table if not exists
                actes(code integer, libelle text ,  
                CONSTRAINT code_pk PRIMARY KEY(code));''')
     
        def write(self, records):
            with self._cnx:
                self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
     
        def dump(self):
            with self._cnx:
                for row in self._cnx.execute('select * from actes'):
                    print (row)
     
    def load(reader, writer):
        while 1:
     
            records = reader.get_records()
            if not records: break
            writer.write(records)
     
     
    if __name__ == '__main__':
        from io import StringIO
     
        actes = ('1 aaa\n'
                 '2 bbb\n'
                 '3 ccc\n'
                 '4 ddd\n'
                 '4 ddd\n'
                 )
     
        writer = Writer()
        load(Reader(StringIO(actes)), writer)
        writer.dump()
    mais voila

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     Traceback (most recent call last):
      File "\src\csvconv.py", line 63, in <module>
        load(Reader(StringIO(actes)), writer)
      File "\src\csvconv.py", line 49, in load
        writer.write(records)
      File "\src\csvconv.py", line 37, in write
        self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
    sqlite3.IntegrityError: UNIQUE constraint failed: actes.code

  15. #15
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Salut,

    Citation Envoyé par dedalios Voir le message
    J'ai reprise ce code et j'ai ajouter
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
                    if(record(int(row[0]), row[1]) not in records):
                        records.append(record(int(row[0]), row[1]))
    ceci dans le but de charger records qu'a la condition de ne pas avoir déjà charge l'information
    Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
    Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

    note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  16. #16
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Salut,



    Si vous ne postez pas le code complet pas facile de savoir mais si vous avez respecté le code que j'ai posté, il charge le fichier CSV 2 lignes à la fois et ne stocke pas l'ensemble des records déjà écrits.
    Mais peut être que vous voulez dire que "not in" ne fonctionnerait pas avec des listes de tuple?

    note: en pratique, avec sqlite3, on utilise INSERT OR IGNORE pour qu'il jette les doublons ou INSERT OR REPLACE pour mettre à jour si.

    - W

    Le code complet est poste dans ma demande.
    J'ai fait des tests primaires avec les listes simples ou de tuples. Le IN ou sont contraire NOT IN pour vérifier la présence d'un éléments tuple ou autre dans une liste cela fonctionne .
    il n'y a aucun problème a tester l'existant d'un tuple dans une liste de tuple .


    voici le cas de test primaires

    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
    from collections import namedtuple
     
    enregistrement = namedtuple('enregistrement', 'code, libelle')
     
    type_enregistrement  = enregistrement(15,"coucou")
     
    print(type_enregistrement.code )
    print(type_enregistrement.libelle)
     
    z1, z2 = type_enregistrement
    print(z1)
     
    print(type_enregistrement[0]  )
    print(type_enregistrement[1]  )
     
    liste_enr =[] 
     
    liste_enr.append(  enregistrement(15,"coucou") )
    liste_enr.append(  enregistrement(1,"dodo") )
    liste_enr.append(  enregistrement(2,"KKK") )
     
    if enregistrement(1,"dodo") not  in liste_enr:
        liste_enr.append(  enregistrement(1,"dodo") )
     
    if enregistrement(1,"dodo") not in liste_enr:
        liste_enr.append(  enregistrement(2,"KKK")) 
     
    for cas in liste_enr:
        print(cas)
     
    if enregistrement(1,"dodo")  in liste_enr :
        print("oui")
    else:
        print("non")
    et le retour des print
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    15
    coucou
    15
    15
    coucou
    enregistrement(code=15, libelle='coucou')
    enregistrement(code=1, libelle='dodo')
    enregistrement(code=2, libelle='KKK')
    oui

  17. #17
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    Le code complet est poste dans ma demande
    Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  18. #18
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Ce qui ne change pas les solutions proposées: utiliser INSERT OR REPLACE ou stocker tous les enregistrements (mais il peut y en avoir beaucoup).

    - W
    Effectivement la solution de charger dans une liste de l'intégralité des enregistrements du fichier csv sous forme de tuple pour pouvoir utiliser le mécanisme d' insertion via executemany oblige a chercher une solution soit de suppression des doublons soit de non chargement des tuples csv dans la liste intémédiaire.

    Je peux faire en sorte de traiter l'insertion sql d'utiliser les exception pour traiter les blocages de type "sqlite3.IntegrityError: UNIQUE constraint failed: " pour exclure ces cas.

    une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:.
    rejet t'il l'intégralité des données ou uniquement les enregistrements en échecs ?


    et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.

  19. #19
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 709
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 709
    Par défaut
    Citation Envoyé par dedalios Voir le message
    une question toutefois comment réagit executemany si 50% des tuple à insérer en base provoque une erreur d'intégration pour sqlite3.IntegrityError: UNIQUE constraint failed:..
    Ce n'est pas si compliqué de tester... mais vous n'allez pas gérer l'erreur pour préférer INSERT OR IGNORE ou INSERT OR REPLACE i.e. laisser faire le boulot au SGDB.

    Citation Envoyé par dedalios Voir le message
    et j'aimerai bien savoir pourquoi la commande NOT in ne fonctionne pas.
    Partez du principe que "not in" fonctionne... (sinon non seulement çà se saurait mais pas grand monde développerait avec Python).
    A partir de là, le soucis est dans votre code.
    Relisez le autant de fois que nécessaire, ajouter y des "print",.... pour trouver et comprendre pourquoi.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  20. #20
    Membre éclairé Avatar de dedalios
    Homme Profil pro
    concepteur d'application
    Inscrit en
    Février 2008
    Messages
    495
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Indre et Loire (Centre)

    Informations professionnelles :
    Activité : concepteur d'application
    Secteur : Santé

    Informations forums :
    Inscription : Février 2008
    Messages : 495
    Par défaut
    Voici le code d'origine

    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
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    import csv
    import sqlite3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')
     
    class Reader:
        def __init__(self, file):
            self._reader = csv.reader(file, delimiter=' ')
     
        def get_records(self, count=1):
            records = []
            try:
                for _ in range(count):
                    row = next(self._reader)
                    records.append(record(int(row[0]), row[1]))
            except StopIteration:
                pass
            except:
                raise
            return records
     
     
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
            cnx.execute('''create table if not exists actes(code integer, libelle text);''')
     
        def write(self, records):
            with self._cnx:
                self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
     
        def dump(self):
            with self._cnx:
                for row in self._cnx.execute('select * from actes'):
                    print (row)
     
    def load(reader, writer):
        while 1:
     
            records = reader.get_records()
            if not records: break
            writer.write(records)
     
     
    if __name__ == '__main__':
        from io import StringIO
     
        actes = ('1 aaa\n'
                 '2 bbb\n'
                 '3 ccc\n'
                 '4 ddd\n'
                 '5 ddd\n'
                 '6 ddd\n'
                 '15 eeee\n'
                 '2 bbb\n'
                 '33 qqq\n'
                 )
     
        writer = Writer()
        load(Reader(StringIO(actes)), writer)
        writer.dump()


    et voici le code modifi

    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
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    # coding: utf-8  
    import csv
    import sqlite3
    from collections import namedtuple
     
    record = namedtuple('record', 'code, libelle')
     
    class Reader:
        def __init__(self, file):
            self._reader = csv.reader(file, delimiter=' ')
     
        def get_records(self, count=2):
            records = []
            try:
                for _ in range(count):
                    row = next(self._reader)
                    if(record(int(row[0]), row[1]) not in records):
                        records.append(record(int(row[0]), row[1]))
     
     
            except StopIteration:
                pass
            except:
                raise
            return records
     
     
    class Writer:
        def __init__(self, path=':memory:'):
            cnx = self._cnx = sqlite3.connect(path)
            cnx.execute('''create table if not exists
                actes(code integer, libelle text ,  
                CONSTRAINT code_pk PRIMARY KEY(code));''')
     
        def write(self, records):
            with self._cnx:
                self._cnx.executemany('''insert into actes(code, libelle) values(?,?)''', records)
     
        def dump(self):
            with self._cnx:
                for row in self._cnx.execute('select * from actes'):
                    print (row)
     
    def load(reader, writer):
        while 1:
     
            records = reader.get_records()
            print(records)
            if not records: break
            writer.write(records)
     
     
    if __name__ == '__main__':
        from io import StringIO
     
        actes = ('1 aaa\n'
                 '2 bbb\n'
                 '3 ccc\n'
                 '4 ddd\n'
                 '4 ddd\n'
                 )
     
        writer = Writer()
        load(Reader(StringIO(actes)), writer)
        writer.dump()

    Quelles sont les modifications ;

    La table sql la notion de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     CONSTRAINT code_pk PRIMARY KEY(code) :
    Hors volontairement les donnees inserer contiennent des doubles.

    Afin de ne pas charger de données en double dans la liste records j'ai modifié cette classe
    Déjà la lecture des données ce fait 1 ligne par 1 ligne .
    puis j'ai conditionné le chargement de "records" en cherchant a vérifier si le tuple record existait ou pas dans la liste "records"
    Mais visiblement je dommandej l'intégration des données via insert sql me signale qu'il ne pas pas inserer de donnée en doublesur la cle primaire alors que pour moi nous ne devrions pas avoir de donnée en double dans cette liste.
    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
    record = namedtuple('record', 'code, libelle')
     
    class Reader:
        def __init__(self, file):
            self._reader = csv.reader(file, delimiter=' ')
     
        def get_records(self, count=1):
            records = []
            try:
                for _ in range(count):
                    row = next(self._reader)
                    if(record(int(row[0]), row[1]) not in records):
                        records.append(record(int(row[0]), row[1]))
                    
                    
            except StopIteration:
                pass
            except:
                raise
            return records

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Convertion char vers int
    Par barthelv dans le forum C
    Réponses: 8
    Dernier message: 08/10/2011, 21h45
  2. Importation CSV vers base de données
    Par Brice Yao dans le forum Bases de données
    Réponses: 1
    Dernier message: 29/06/2005, 13h42
  3. [Conseil] Import de fichier CSV vers MySQL
    Par ShinJava dans le forum JDBC
    Réponses: 6
    Dernier message: 15/03/2005, 19h14
  4. Importation de fichier CSV vers une base Interbase
    Par PrinceMaster77 dans le forum ASP
    Réponses: 3
    Dernier message: 15/03/2005, 15h18

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo