Discussion :

[dedalios]

bonjour

Je cherche à historiser un dictionnaire dans une base sqllite.

ce code fonctionne sans difficulté mais je cherche à l'optimiser.

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
# coding: utf-8  
import sqlite3
 
 
"""
-- TableTraduction definition
-- prealable avoir une base sqllite dénomer 'rcg-fr.sqllite' dans la racice du projet avec la table 
-- cette partie a été faite prealablement et n'est pas présente danc ce code
 
CREATE TABLE TableTraduction (
    IdK INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    Terme_Anglais TEXT,
    Terme_francais TEXT
);
 
CREATE INDEX TableTraduction_IdK_IDX ON TableTraduction (IdK);
CREATE INDEX TableTraduction_Terme_Anglais_IDX ON TableTraduction (Terme_Anglais);
 
DROP TABLE TableTraduction;
 
"""
 
 
if __name__ == '__main__':
 
    Base_traduction = {
"Bionic Hands Weapons and Tools" : "Main Bionique de type arme ou outils" , 
"FingerJack" : "FingerJack (Doigt pistolet)" ,
"Laser Utility Finger" : "Doigt laser" ,
"Hand and Arm Weapons & Tools" :"Main ou bras  de type arme ou outils" ,
"Pair of Additional Hands and Arms" : "Paire de mains et de bras supplémentaires" ,
"Leg Weapons and Accessories"   : "Armes de jambe et accessoires" ,
"Head and Throat Features"      : "Caractéristiques de la tête et de la gorge" ,
"Bionic Eyes & Sensors"         : "Yeux et capteurs bioniques" ,
"Cyborg Armor"                  : "Armure Cyborg" 
 }
 
 
    try: 
        # Etablir une connexion à la base de données 'rcg-fr.sqllite'
        # et créer un objet de connexion
        connection_rcgfr = sqlite3.connect('rcg-fr.sqllite')
        # Créer un curseur vers la base de données
        cur_rcgfr = connection_rcgfr.cursor()
        print("Ouverture de la base de données rcg-fr.sqllite")
 
        requete ='INSERT INTO TableTraduction (Terme_Anglais, Terme_francais) VALUES(?, ?)' 
 
        #Exécutions multiples
        for donnee_dic in Base_traduction:
            valeur = (donnee_dic ,Base_traduction[donnee_dic])
            print(valeur)
            cur_rcgfr.execute(requete, valeur)
 
        connection_rcgfr.commit()
        # vérification
 
        requete ='select  Terme_Anglais, Terme_francais from TableTraduction'  
 
        try:
 
            cur_rcgfr.execute(requete)
            result = cur_rcgfr.fetchall()  # fetchall() : récupère toutes les lignes
            print("-------------dico recreer--------------------------------")
            Base_traduction_2 = {None : None }
            Base_traduction_2.clear()
 
            for ligne in result:
                Base_traduction_2[ligne[0]] = ligne[1]
 
            print(Base_traduction_2.items())    
        except  Exception as erreur:
            print("Erreur:" , erreur)   
            Base_traduction =''
    except  Exception as erreur:
        print("Erreur:" , erreur)
        connection_rcgfr.rollback()
    finally:    
        connection_rcgfr.close()

Je cherche à l'optimiser sur la partie concernant l'enregistrement en base en utilisant plutôt une commande executemany()

Code :

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

1
2
3
4
5
6
7
...       for donnee_dic in Base_traduction:
            valeur = (donnee_dic ,Base_traduction[donnee_dic])
            print(valeur)
            cur_rcgfr.execute(requete, valeur)
 
        connection_rcgfr.commit()
...

Le but global est de conserver le dictionnaire pour l'utiliser comme outils d'optimisation de traduction.
on charge celui-ci au début des opérations, on lui apporte de nouvelle valeur et on le redépose dans la base.

en réfléchissant je m’aperçois que le plus cohérent serait que la table soit plus proche du dictionnaire avec comme définition

Code SQL :

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

1
2
3
4
5
6
CREATE TABLE TableTraduction2 (
    Terme_Anglais TEXT NOT NULL PRIMARY KEY,
    Terme_francais TEXT
);
 
CREATE INDEX TableTraduction_Terme_Anglais_IDX2 ON TableTraduction2 (Terme_Anglais);

Serait-il plus pertinent de cloner cette table avec la base en RAM

Code :

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

connexion = sqlite3.connect(":memory:")  #BDD dans la RAM

que d'utiliser un dictionnaire ?

[wiztricks]

Salut,

Serait plus pertinent de cloner cette table avec la base en RAM

Code :

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

connexion = sqlite3.connect(":memory:")  #BDD dans la RAM

que d'utiliser un dictionnaire ?

Déjà on peut se demander pourquoi sqlite plutôt qu'un fichier JSON (si on peut tout charger en mémoire) où on va pouvoir ajouter des entrées avec un simple éditeur de texte?

Après tout dépend des query: pas être simple de coder l'équivalent d'une query avec des LIKE avec les clefs d'un dictionnaire.

- W

[Sve@r]

Bonjour

Je cherche à l'optimiser sur la partie concernant l'enregistrement en base en utilisant plutôt une commande executemany()
en réfléchissant je m’aperçois que le plus cohérent serait que la table soit plus proche du dictionnaire avec comme définition

Moi je me demande l'utilité d'une base de données (avec ses systèmes d'index, de contraintes, de clefs) pour un simple dictionnalre. Un simple dump pickle dans un fichier me semble plutôt suffisant.

Code python :

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
#!/usr/bin/env python3
# coding: utf-8
 
import pickle
 
if __name__ == '__main__':
 
	t1 = {
"Bionic Hands Weapons and Tools" : "Main Bionique de type arme ou outils" , 
"FingerJack" : "FingerJack (Doigt pistolet)" ,
"Laser Utility Finger" : "Doigt laser" ,
"Hand and Arm Weapons & Tools" :"Main ou bras  de type arme ou outils" ,
"Pair of Additional Hands and Arms" : "Paire de mains et de bras supplémentaires" ,
"Leg Weapons and Accessories"   : "Armes de jambe et accessoires" ,
"Head and Throat Features"	  : "Caractéristiques de la tête et de la gorge" ,
"Bionic Eyes & Sensors"		 : "Yeux et capteurs bioniques" ,
"Cyborg Armor"				  : "Armure Cyborg" 
}
 
	with open("svg.bin", "wb") as fp: pickle.dump(t1, fp)
	with open("svg.bin", "rb") as fp: t2=pickle.load(fp)
	print(t1 == t2)

Serait-il plus pertinent de cloner cette table avec la base en RAM

Code :

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

connexion = sqlite3.connect(":memory:")  #BDD dans la RAM

que d'utiliser un dictionnaire ?

A mon avis non. Le dictionnaire est quand-même plus proche de Python que la bdd sqlite. Et aussi moins gourmand.

[dedalios]

merci je vais suivre cette idee

[dedalios]

Salut,



Déjà on peut se demander pourquoi sqlite plutôt qu'un fichier JSON (si on peut tout charger en mémoire) où on va pouvoir ajouter des entrées avec un simple éditeur de texte?

Après tout dépend des query: pas être simple de coder l'équivalent d'une query avec des LIKE avec les clefs d'un dictionnaire.

- W

je ne connais pas JSON simplement. Ou du moins uniquement de façon général.