PY-004 : Initiation Qt6

Objectif⚓

UI avec Qt6

Cahier des charges⚓

1
copier fichier qt6.md

⚓

Objectif⚓

Concepts fondamentaux de PyQt6

Import des modules système⚓

Documentation

1
# Qt6_01_minimum.py — Import des modules système
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant concepts fondamentaux de pyqt6.
4
5
## Catégorie
6
**Base Qt6**
7
8
## Objectifs pédagogiques
9
- Vérification de l'installation minimale de PyQt6
10
- Création de l'application PyQt6
11
- QApplication gère la boucle d'événements et les paramètres globaux de l'application
12
- Création d'un widget QLabel (étiquette de texte)
13
- Ce sera notre fenêtre principale avec un texte affiché
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QLabel
19
```
20
21
## Exécution
22
```bash
23
python Qt6_01_minimum.py
24
```
25
26
## Fichier source
27
Le code source complet se trouve dans : `004/Qt6_01_minimum.py`
28
29
## Points clés
30
- Interface graphique avec PyQt6
31
- Concepts fondamentaux de PyQt6
32
- Application des bonnes pratiques de développement
33
34
---
35
*Documentation générée automatiquement pour le projet gimdidpy*
36
Code Python
1
# Vérification de l'installation minimale de PyQt6 
2
# Exécution : python Qt6_01_minimum.py
3
4
# Import des modules système
5
import sys  
6
7
# Import des composants PyQt6 nécessaires
8
from PyQt6.QtWidgets import QApplication, QLabel  
9
10
# Création de l'application PyQt6
11
# QApplication gère la boucle d'événements et les paramètres globaux de l'application
12
app = QApplication(sys.argv) 
13
# Création d'un widget QLabel (étiquette de texte)
14
# Ce sera notre fenêtre principale avec un texte affiché
15
label = QLabel('   Bonjour, PyQt6 !!!   ')  
16
# Affichage du widget à l'écran
17
# Sans cette ligne, la fenêtre resterait invisible
18
label.show()  
19
# Lancement de la boucle d'événements de l'application
20
# app.exec() démarre l'interface graphique et attend les interactions utilisateur
21
# sys.exit() garantit une fermeture propre de l'application
22
sys.exit(app.exec()) 
Création d'un widget parent⚓
Documentation
1
# Qt6_02_minimum.py — Création d'un widget parent
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant concepts fondamentaux de pyqt6.
4
5
## Catégorie
6
**Base Qt6**
7
8
## Objectifs pédagogiques
9
- Création d'un widget parent
10
- Création d'un label avec un alignement de texte centré
11
- Utilisation de l'énumération pour centrer le texte
12
13
## Imports principaux
14
```python
15
from PyQt6.QtWidgets import QLabel, QWidget, QVBoxLayout,QApplication
16
from PyQt6.QtCore import Qt
17
```
18
19
## Exécution
20
```bash
21
python Qt6_02_minimum.py
22
```
23
24
## Fichier source
25
Le code source complet se trouve dans : `004/Qt6_02_minimum.py`
26
27
## Points clés
28
- Interface graphique avec PyQt6
29
- Concepts fondamentaux de PyQt6
30
- Application des bonnes pratiques de développement
31
32
---
33
*Documentation générée automatiquement pour le projet gimdidpy*
34
Code Python
1
from PyQt6.QtWidgets import QLabel, QWidget, QVBoxLayout,QApplication  
2
from PyQt6.QtCore import Qt  
3
app = QApplication([])  
4
# Création d'un widget parent  
5
widget = QWidget()
6
7
layout = QVBoxLayout(widget)  
8
# Création d'un label avec un alignement de texte centré  
9
label = QLabel("Hello, PyQt6!")  
10
# Utilisation de l'énumération pour centrer le texte  
11
label.setAlignment(Qt.AlignmentFlag.AlignCenter)   
12
layout.addWidget(label)  
13
widget.show()  
14
app.exec() 
Qt6 03 bt fermer⚓
Documentation
1
# Qt6_03_bt_fermer.py — Qt6 03 bt fermer
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant concepts fondamentaux de pyqt6.
4
5
## Catégorie
6
**Base Qt6**
7
8
## Objectifs pédagogiques
9
- Configuration de la fenêtre
10
- Création d'un layout vertical
11
- Création du bouton "Fermer"
12
- Connexion du signal clicked au slot exemple_slot
13
- Association du layout à la fenêtre
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton
19
```
20
21
## Éléments principaux
22
- Classe : `FenetreSimple`
23
- Fonction : `init_ui()`
24
- Fonction : `exemple_slot()`
25
26
## Exécution
27
```bash
28
python Qt6_03_bt_fermer.py
29
```
30
31
## Fichier source
32
Le code source complet se trouve dans : `004/Qt6_03_bt_fermer.py`
33
34
## Points clés
35
- Interface graphique avec PyQt6
36
- Concepts fondamentaux de PyQt6
37
- Application des bonnes pratiques de développement
38
39
---
40
*Documentation générée automatiquement pour le projet gimdidpy*
41
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton  
3
4
class FenetreSimple(QWidget):  
5
    def __init__(self):  
6
        super().__init__()  
7
        self.init_ui()  
8
9
    def init_ui(self):  
10
        # Configuration de la fenêtre  
11
        self.setWindowTitle("Signaux et slots")  
12
        self.resize(250, 300)  
13
        self.move(50, 500)  
14
15
        # Création d'un layout vertical  
16
        self.disposition = QVBoxLayout()  
17
18
19
        # Création du bouton "Fermer"  
20
        self.fermer = QPushButton("Fermer")  
21
        self.disposition.addWidget(self.fermer)  
22
23
        # Connexion du signal clicked au slot exemple_slot  
24
        self.fermer.clicked.connect(self.exemple_slot)  
25
26
        # Association du layout à la fenêtre  
27
        self.setLayout(self.disposition)  
28
29
        # Affichage de la fenêtre  
30
        self.show() 
31
    
32
    # Définition du slot  
33
    def exemple_slot(self):  
34
        print("Le bouton a été appuyé.")
35
        # Fermeture de la fenêtre
36
        self.close()
37
38
if __name__ == "__main__":  
39
    application = QApplication(sys.argv)  
40
    fenetre = FenetreSimple()  
41
    sys.exit(application.exec()) 
Qt6 04 read write⚓
Documentation
1
# Qt6_04_read_write.py — Qt6 04 read write
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant concepts fondamentaux de pyqt6.
4
5
## Catégorie
6
**Base Qt6**
7
8
## Objectifs pédagogiques
9
- Widget central et layout
10
- Label explicatif
11
- Premier champ de saisie (source)
12
- Label séparateur
13
- Second champ de saisie (destination)
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QLineEdit, QLabel
19
```
20
21
## Éléments principaux
22
- Classe : `MainWindow`
23
- Fonction : `copier_texte()`
24
- Fonction : `main()`
25
26
## Exécution
27
```bash
28
python Qt6_04_read_write.py
29
```
30
31
## Fichier source
32
Le code source complet se trouve dans : `004/Qt6_04_read_write.py`
33
34
## Points clés
35
- Interface graphique avec PyQt6
36
- Concepts fondamentaux de PyQt6
37
- Application des bonnes pratiques de développement
38
39
---
40
*Documentation générée automatiquement pour le projet gimdidpy*
41
Code Python
1
import sys
2
from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QLineEdit, QLabel
3
4
"""
5
Qt6 Example 04 - Read and Write with Signal Data Transmission
6
==============================================================
7
8
This example demonstrates how signals can carry data between widgets.
9
We create two QLineEdit fields where text from the first is automatically
10
copied to the second using the textChanged signal.
11
12
Key Concepts:
13
- Signals with parameters (textChanged carries the text string)
14
- Connecting signal data to slot parameters
15
- Automatic data flow between widgets
16
"""
17
18
19
20
class MainWindow(QMainWindow):
21
    def __init__(self):
22
        super().__init__()
23
        self.setWindowTitle("Qt6 - 04 - Signal avec transmission de données")
24
        self.setGeometry(100, 100, 400, 200)
25
        
26
        # Widget central et layout
27
        central_widget = QWidget()
28
        self.setCentralWidget(central_widget)
29
        layout = QVBoxLayout(central_widget)
30
        
31
        # Label explicatif
32
        label_instruction = QLabel("Tapez du texte dans le premier champ :")
33
        layout.addWidget(label_instruction)
34
        
35
        # Premier champ de saisie (source)
36
        self.champ_source = QLineEdit()
37
        self.champ_source.setPlaceholderText("Champ source...")
38
        layout.addWidget(self.champ_source)
39
        
40
        # Label séparateur
41
        label_separateur = QLabel("Le texte apparaît automatiquement ci-dessous :")
42
        layout.addWidget(label_separateur)
43
        
44
        # Second champ de saisie (destination)
45
        self.champ_destination = QLineEdit()
46
        self.champ_destination.setPlaceholderText("Champ destination (lecture seule)")
47
        self.champ_destination.setReadOnly(True)  # En lecture seule pour la démonstration
48
        layout.addWidget(self.champ_destination)
49
        
50
        # Connexion du signal avec transmission de données
51
        # textChanged(str) émet le texte actuel à chaque modification
52
        self.champ_source.textChanged.connect(self.copier_texte)
53
        
54
        # Alternative : connexion directe au slot setText du second champ
55
        # self.champ_source.textChanged.connect(self.champ_destination.setText)
56
    
57
    def copier_texte(self, texte):
58
        """
59
        Slot qui reçoit le texte du signal textChanged.
60
        
61
        Args:
62
            texte (str): Le texte actuel du champ source
63
        """
64
        self.champ_destination.setText(texte)
65
        print(f"Texte copié : '{texte}'")  # Debug dans la console
66
67
68
def main():
69
    app = QApplication(sys.argv)
70
    window = MainWindow()
71
    window.show()
72
    sys.exit(app.exec())
73
74
75
if __name__ == "__main__":
76
    main()
⚓
Objectif⚓
Gestion des layouts et des widgets
Création de l'application et de la fenêtre⚓
Documentation
1
# Qt6_11_QHBoxLayout.py — Création de l'application et de la fenêtre
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de l'application et de la fenêtre
10
- Création du layout vertical et ajout des widgets
11
- Association du layout à la fenêtre
12
- Affichage de la fenêtre
13
14
## Imports principaux
15
```python
16
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout
17
```
18
19
## Exécution
20
```bash
21
python Qt6_11_QHBoxLayout.py
22
```
23
24
## Fichier source
25
Le code source complet se trouve dans : `004/Qt6_11_QHBoxLayout.py`
26
27
## Points clés
28
- Interface graphique avec PyQt6
29
- Gestion des layouts et des widgets
30
- Application des bonnes pratiques de développement
31
32
---
33
*Documentation générée automatiquement pour le projet gimdidpy*
34
Code Python
1
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout  
2
3
# Création de l'application et de la fenêtre  
4
app = QApplication([])    
5
fenetre = QWidget()  
6
7
# Création du layout vertical et ajout des widgets  
8
disposition = QVBoxLayout()    
9
disposition.addWidget(QPushButton('Premier'))    
10
disposition.addWidget(QPushButton('Second'))    
11
disposition.addWidget(QPushButton('Troisième'))    
12
disposition.addWidget(QPushButton('Quatrième'))    
13
disposition.addWidget(QPushButton('Cinquième'))  
14
15
# Association du layout à la fenêtre  
16
fenetre.setLayout(disposition)  
17
18
# Affichage de la fenêtre  
19
fenetre.show()  
20
app.exec() 
21
22
'''
23
Explication du code PyQt6 - Interface avec boutons verticaux
24
Ce code illustre la création d'une interface graphique simple avec PyQt6, démontrant les concepts fondamentaux de la gestion des layouts et des widgets.
25
26
Architecture de l'application
27
L'application suit le pattern classique de PyQt6 avec trois composants essentiels : 
28
    QApplication qui gère l'environnement global, 
29
    QWidget servant de fenêtre conteneur, 
30
    QVBoxLayout pour organiser les éléments visuels. 
31
Cette structure respecte le paradigme orienté objet de Qt où chaque élément graphique hérite d'une classe de base commune.
32
33
Gestion du layout vertical
34
    Le QVBoxLayout (disposition verticale) est un gestionnaire de mise en page qui empile automatiquement les widgets les uns sous les autres. 
35
    Contrairement au positionnement absolu, ce layout s'adapte dynamiquement aux redimensionnements de la fenêtre et maintient l'alignement des éléments. 
36
    Chaque appel à addWidget() ajoute séquentiellement un nouveau bouton dans la pile verticale.
37
38
Cycle de vie de l'interface
39
    La méthode fenetre.show() rend la fenêtre visible mais ne bloque pas l'exécution, tandis que app.exec() lance la boucle d'événements principale. 
40
    Cette boucle reste active jusqu'à la fermeture de l'application, traitant en continu les interactions utilisateur (clics, redimensionnements, etc.). 
41
    C'est le mécanisme central qui maintient l'interface responsive.
42
43
Points d'attention pour les débutants
44
    Un piège fréquent est d'oublier l'appel à setLayout(disposition) qui associe le gestionnaire de mise en page à la fenêtre - sans cette étape,
45
    les boutons ne s'afficheraient pas. De plus, les boutons créés ici sont purement visuels : 
46
    ils ne déclenchent aucune action car aucun slot (fonction de callback) n'est connecté à leurs signaux de clic.
47
'''
Création de l'application et de la fenêtre⚓
Documentation
1
# Qt6_12_QVBoxLayout.py — Création de l'application et de la fenêtre
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de l'application et de la fenêtre
10
- Création du layout horizontal et ajout des widgets
11
- Association du layout à la fenêtre
12
- Affichage de la fenêtre
13
14
## Imports principaux
15
```python
16
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QHBoxLayout
17
```
18
19
## Exécution
20
```bash
21
python Qt6_12_QVBoxLayout.py
22
```
23
24
## Fichier source
25
Le code source complet se trouve dans : `004/Qt6_12_QVBoxLayout.py`
26
27
## Points clés
28
- Interface graphique avec PyQt6
29
- Gestion des layouts et des widgets
30
- Application des bonnes pratiques de développement
31
32
---
33
*Documentation générée automatiquement pour le projet gimdidpy*
34
Code Python
1
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QHBoxLayout  
2
# Création de l'application et de la fenêtre  
3
app = QApplication([])    
4
fenetre = QWidget()  
5
# Création du layout horizontal et ajout des widgets  
6
disposition = QHBoxLayout()    
7
disposition.addWidget(QPushButton('Premier'))    
8
disposition.addWidget(QPushButton('Second'))    
9
disposition.addWidget(QPushButton('Troisième'))    
10
disposition.addWidget(QPushButton('Quatrième'))    
11
disposition.addWidget(QPushButton('Cinquième'))  
12
# Association du layout à la fenêtre  
13
fenetre.setLayout(disposition)  
14
# Affichage de la fenêtre  
15
fenetre.show()  
16
app.exec() 
Création de l'application⚓
Documentation
1
# Qt6_13_QGridLayout.py — Création de l'application
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de l'application
10
- Création de la fenêtre principale
11
- Création du layout en grille
12
- Ajout des boutons avec leurs coordonnées (ligne, colonne)
13
- Ajout de boutons supplémentaires avec fusion de cellules
14
15
## Imports principaux
16
```python
17
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout
18
```
19
20
## Exécution
21
```bash
22
python Qt6_13_QGridLayout.py
23
```
24
25
## Fichier source
26
Le code source complet se trouve dans : `004/Qt6_13_QGridLayout.py`
27
28
## Points clés
29
- Interface graphique avec PyQt6
30
- Gestion des layouts et des widgets
31
- Application des bonnes pratiques de développement
32
33
---
34
*Documentation générée automatiquement pour le projet gimdidpy*
35
Code Python
1
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout  
2
# Création de l'application  
3
app = QApplication([])  
4
# Création de la fenêtre principale  
5
fenetre = QWidget()  
6
fenetre.setGeometry(100, 100, 300, 200)  
7
fenetre.setWindowTitle("Exemple avec QGridLayout")  
8
# Création du layout en grille  
9
disposition = QGridLayout()  
10
# Ajout des boutons avec leurs coordonnées (ligne, colonne)  
11
disposition.addWidget(QPushButton("0"), 0, 0)  
12
disposition.addWidget(QPushButton("1"), 0, 1)  
13
disposition.addWidget(QPushButton("2"), 0, 2)  
14
disposition.addWidget(QPushButton("3"), 1, 0)  
15
disposition.addWidget(QPushButton("4"), 1, 1)  
16
disposition.addWidget(QPushButton("5"), 1, 2)  
17
disposition.addWidget(QPushButton("6"), 2, 0)  
18
disposition.addWidget(QPushButton("7"), 2, 1)  
19
disposition.addWidget(QPushButton("8"), 2, 2)  
20
disposition.addWidget(QPushButton("9"), 3, 0)  
21
disposition.addWidget(QPushButton("+"), 3, 1)  
22
disposition.addWidget(QPushButton("="), 3, 2)  
23
# Ajout de boutons supplémentaires avec fusion de cellules
24
disposition.addWidget(QPushButton("*"), 4, 1, 1, 2)  
25
disposition.addWidget(QPushButton("/"), 4, 3, 2, 2)  
26
# Association du layout à la fenêtre  
27
fenetre.setLayout(disposition)  
28
# Affichage de la fenêtre  
29
fenetre.show()  
30
# Boucle principale de l'application  
31
app.exec() 
Création de l'application⚓
Documentation
1
# Qt6_14_QformLayout.py — Création de l'application
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de l'application
10
- Création de la fenêtre principale
11
- Création du layout du formulaire
12
- Ajout des champs au formulaire
13
- Ajout des boutons en bas
14
15
## Imports principaux
16
```python
17
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QFormLayout, QLabel, QLineEdit, QComboBox
18
```
19
20
## Exécution
21
```bash
22
python Qt6_14_QformLayout.py
23
```
24
25
## Fichier source
26
Le code source complet se trouve dans : `004/Qt6_14_QformLayout.py`
27
28
## Points clés
29
- Interface graphique avec PyQt6
30
- Gestion des layouts et des widgets
31
- Application des bonnes pratiques de développement
32
33
---
34
*Documentation générée automatiquement pour le projet gimdidpy*
35
Code Python
1
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QFormLayout, QLabel, QLineEdit, QComboBox  
2
# Création de l'application  
3
app = QApplication([])  
4
# Création de la fenêtre principale  
5
fenetre = QWidget()  
6
fenetre.setGeometry(100, 100, 300, 200)  
7
fenetre.setWindowTitle("QFormLayout")  
8
9
# Création du layout du formulaire  
10
disposition = QFormLayout()  
11
12
# Ajout des champs au formulaire  
13
nomLabel = QLabel("Nom : ")  
14
nom = QLineEdit()  
15
disposition.addRow(nomLabel, nom)  
16
17
prenomLabel = QLabel("Prénom : ")  
18
prenom = QLineEdit()  
19
disposition.addRow(prenomLabel, prenom)  
20
21
loisirLabel = QLabel("Loisir préféré : ")  
22
loisir = QComboBox()  
23
loisir.addItems(["Pratique sportive", "Pratique artistique", "Programmation informatique", "Voyage"])  
24
disposition.addRow(loisirLabel, loisir)  
25
26
# Ajout des boutons en bas  
27
envoyerButton = QPushButton("Envoyer")  
28
annulerButton = QPushButton("Annuler")  
29
disposition.addRow(envoyerButton, annulerButton)  
30
31
# Association du layout à la fenêtre  
32
fenetre.setLayout(disposition)  
33
34
# Affichage de la fenêtre  
35
fenetre.show()  
36
37
# Boucle principale de l'application  
38
app.exec() 
Qt6 15 QtabWidget⚓
Documentation
1
# Qt6_15_QtabWidget.py — Qt6 15 QtabWidget
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Définition de la classe principale pour gérer les onglets
10
- Création des onglets
11
- Ajout des onglets au QTabWidget
12
- Configuration de chaque onglet
13
- Titre de la fenêtre
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import (QApplication, QTabWidget, QWidget,
19
```
20
21
## Éléments principaux
22
- Classe : `MyQTabWidget`
23
- Fonction : `creationOnglet1()`
24
- Fonction : `creationOnglet2()`
25
- Fonction : `creationOnglet3()`
26
- Fonction : `updateDB()`
27
- Fonction : `principal()`
28
29
## Exécution
30
```bash
31
python Qt6_15_QtabWidget.py
32
```
33
34
## Fichier source
35
Le code source complet se trouve dans : `004/Qt6_15_QtabWidget.py`
36
37
## Points clés
38
- Interface graphique avec PyQt6
39
- Gestion des layouts et des widgets
40
- Application des bonnes pratiques de développement
41
42
---
43
*Documentation générée automatiquement pour le projet gimdidpy*
44
Code Python
1
import sys
2
from PyQt6.QtWidgets import (QApplication, QTabWidget, QWidget, 
3
                             QFormLayout, QVBoxLayout, QHBoxLayout,
4
                             QLineEdit, QCheckBox)
5
from PyQt6 import QtCore, QtSql 
6
# Définition de la classe principale pour gérer les onglets
7
class MyQTabWidget(QTabWidget):
8
    def __init__(self, parent=None):
9
        super(MyQTabWidget, self).__init__(parent)
10
11
        # Création des onglets
12
        self.onglet1 = QWidget()
13
        self.onglet2 = QWidget()
14
        self.onglet3 = QWidget()
15
16
        # Ajout des onglets au QTabWidget
17
        self.addTab(self.onglet1, "Données générales")
18
        self.addTab(self.onglet2, "Sports préférés")
19
        self.addTab(self.onglet3, "Loisirs culturels préférés")
20
21
        # Configuration de chaque onglet
22
        self.creationOnglet1()
23
        self.creationOnglet2()
24
        self.creationOnglet3()
25
26
        # Titre de la fenêtre
27
        self.setWindowTitle("QTabWidget")
28
29
    # Configuration du premier onglet
30
    def creationOnglet1(self):
31
        disposition = QFormLayout()
32
        disposition.addRow("Nom", QLineEdit())
33
        disposition.addRow("Prénom", QLineEdit())
34
        disposition.addRow("Ville", QLineEdit())
35
        self.onglet1.setLayout(disposition)
36
37
    # Configuration du second onglet
38
    def creationOnglet2(self):
39
        disposition = QVBoxLayout()
40
        disposition.addWidget(QCheckBox("Football"))
41
        disposition.addWidget(QCheckBox("Cyclisme"))
42
        disposition.addWidget(QCheckBox("Tennis"))
43
        self.onglet2.setLayout(disposition)
44
45
    # Configuration du troisième onglet
46
    def creationOnglet3
47
    import sys  
48
49
50
def updateDB():  
51
    app = QtCore.QCoreApplication(sys.argv)  
52
53
    db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
54
    db.setDatabaseName('Baselivres.db')  
55
    print("Connexion base ok")  
56
57
    if not db.open():  
58
        print("La Db ne peut pas s'ouvrir.")  
59
        return False  
60
61
    query = QtSql.QSqlQuery()  
62
    query.exec("UPDATE SUJET SET SUJET = 'Microsoft C#' WHERE id = 1")  
63
64
    query.exec("SELECT COUNT(*) FROM SUJET")  
65
    while query.next():  
66
        print(query.value(0))  
67
68
    query.exec("SELECT SUJET FROM SUJET WHERE id = 1")  
69
    while query.next():  
70
        print(query.value(0))  
71
72
if __name__ == '__main__':
73
    updateDB()
74
    self = MyQTabWidget()
75
    disposition = QHBoxLayout()
76
    disposition.addWidget(QCheckBox("Visite de musées"))
77
    disposition.addWidget(QCheckBox("Musique"))
78
    disposition.addWidget(QCheckBox("Dessin et arts graphiques"))
79
    self.onglet3.setLayout(disposition)
80
81
# Fonction principale
82
def principal():
83
    app = QApplication(sys.argv)
84
    fenetre = MyQTabWidget()
85
    fenetre.resize(400, 300)
86
    fenetre.show()
87
    sys.exit(app.exec())
88
89
90
if __name__ == "__main__":
91
    principal() 
Qt6 16 QGroupBox⚓
Documentation
1
# Qt6_16_QGroupBox.py — Qt6 16 QGroupBox
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de la fenêtre principale
10
- Disposition principale
11
- Groupe 1 : Validation
12
- Contenu du groupe 1
13
- Groupe 2 : Loisirs sportifs
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import (  QApplication, QWidget, QVBoxLayout, QHBoxLayout,  QGridLayout, QGroupBox, QPushButton, QRadioButton)
19
```
20
21
## Éléments principaux
22
- Fonction : `principal()`
23
24
## Exécution
25
```bash
26
python Qt6_16_QGroupBox.py
27
```
28
29
## Fichier source
30
Le code source complet se trouve dans : `004/Qt6_16_QGroupBox.py`
31
32
## Points clés
33
- Interface graphique avec PyQt6
34
- Gestion des layouts et des widgets
35
- Application des bonnes pratiques de développement
36
37
---
38
*Documentation générée automatiquement pour le projet gimdidpy*
39
Code Python
1
import sys  
2
from PyQt6.QtWidgets import (  QApplication, QWidget, QVBoxLayout, QHBoxLayout,  QGridLayout, QGroupBox, QPushButton, QRadioButton)  
3
4
def principal():  
5
    app = QApplication(sys.argv)  
6
7
    # Création de la fenêtre principale  
8
    fenetre = QWidget()  
9
    fenetre.setGeometry(100, 100, 400, 200)  
10
    fenetre.setWindowTitle("QGroupBox")  
11
12
    # Disposition principale  
13
    disposition = QGridLayout()  
14
    fenetre.setLayout(disposition)  
15
16
    # Groupe 1 : Validation  
17
    groupe1 = QGroupBox("Validation")  
18
    groupe1.setCheckable(True)  # Active ou désactive le groupe  
19
    disposition.addWidget(groupe1, 0, 0)  
20
21
    # Contenu du groupe 1  
22
    boite1 = QVBoxLayout()  
23
    groupe1.setLayout(boite1)  
24
    boite1.addWidget(QPushButton("Valider"))  
25
    boite1.addWidget(QPushButton("Annuler")) 
26
27
    # Groupe 2 : Loisirs sportifs  
28
    groupe2 = QGroupBox("Loisirs sportifs")  
29
    groupe2.setCheckable(True)  
30
    disposition.addWidget(groupe2, 1, 0)  
31
32
    # Contenu du groupe 2  
33
    boite2 = QVBoxLayout()  
34
    groupe2.setLayout(boite2)  
35
    boite2.addWidget(QRadioButton("Cyclisme"))  
36
    boite2.addWidget(QRadioButton("Football"))  
37
    boite2.addWidget(QRadioButton("Rugby"))  
38
39
    # Affichage de la fenêtre  
40
    fenetre.show()  
41
    sys.exit(app.exec())  
42
43
if __name__ == "__main__":  
44
    principal() 
45
Qt6 17 QToolBar⚓
Documentation
1
# Qt6_17_QToolBar.py — Qt6 17 QToolBar
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant gestion des layouts et des widgets.
4
5
## Catégorie
6
**Widgets Qt6**
7
8
## Objectifs pédagogiques
9
- Création de la fenêtre principale
10
- Création de la barre d'outils
11
- Ajout des actions à la barre d'outils
12
- Gestion des événements pour la barre d'outils
13
- Affichage de la fenêtre
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QMainWindow, QToolBar
19
from PyQt6.QtGui import QAction
20
```
21
22
## Éléments principaux
23
- Fonction : `boutonPresse()`
24
- Fonction : `principal()`
25
26
## Exécution
27
```bash
28
python Qt6_17_QToolBar.py
29
```
30
31
## Fichier source
32
Le code source complet se trouve dans : `004/Qt6_17_QToolBar.py`
33
34
## Points clés
35
- Interface graphique avec PyQt6
36
- Gestion des layouts et des widgets
37
- Application des bonnes pratiques de développement
38
39
---
40
*Documentation générée automatiquement pour le projet gimdidpy*
41
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QMainWindow, QToolBar 
3
from PyQt6.QtGui import QAction  
4
5
def boutonPresse(bouton):  
6
    print(f"Le bouton pressé est le suivant : {bouton.text()}")  
7
8
def principal():  
9
    app = QApplication(sys.argv)  
10
11
    # Création de la fenêtre principale  
12
    fenetre = QMainWindow()  
13
    fenetre.setGeometry(100, 100, 400, 200)  
14
    fenetre.setWindowTitle("QToolBar")  
15
16
    # Création de la barre d'outils  
17
    barre = QToolBar("Barre d'outils d'exemple")  
18
    fenetre.addToolBar(barre)  
19
20
    # Ajout des actions à la barre d'outils  
21
    action1 = QAction("Créer", fenetre)  
22
    barre.addAction(action1)  
23
24
    action2 = QAction("Ouvrir", fenetre)  
25
    barre.addAction(action2)  
26
27
    action3 = QAction("Copier", fenetre)  
28
    barre.addAction(action3)  
29
30
    action4 = QAction("Coller", fenetre)  
31
    barre.addAction(action4)  
32
33
    # Gestion des événements pour la barre d'outils  
34
    barre.actionTriggered.connect(boutonPresse) µ 
35
36
    # Affichage de la fenêtre  
37
    fenetre.show()  
38
    sys.exit(app.exec())  
39
40
if __name__ == "__main__":  
41
    principal() 
⚓
Objectif⚓
Architecture MVC (Model-View-Controller)
Qt6 21 MVC Main⚓
Documentation
1
# Qt6_21_MVC_Main.py — Qt6 21 MVC Main
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant architecture mvc (model-view-controller).
4
5
## Catégorie
6
**Application métier Qt6**
7
8
## Objectifs pédagogiques
9
- Création de l'application
10
- Instanciation des composants MVC
11
- Contrôleur avec modèle et vue
12
- Affichage de la fenêtre principale
13
14
## Imports principaux
15
```python
16
import sys
17
from PyQt6.QtWidgets import QApplication
18
from Qt6_20_MVC_01_Vue import Calculatrice
19
from Qt6_20_MVC_03_Controleur import Controleur
20
from Qt6_20_MVC_02_Modele import evaluation
21
```
22
23
## Exécution
24
```bash
25
python Qt6_21_MVC_Main.py
26
```
27
28
## Fichier source
29
Le code source complet se trouve dans : `004/Qt6_21_MVC_Main.py`
30
31
## Points clés
32
- Interface graphique avec PyQt6
33
- Architecture MVC (Model-View-Controller)
34
- Application des bonnes pratiques de développement
35
36
---
37
*Documentation générée automatiquement pour le projet gimdidpy*
38
Code Python
1
if __name__ == "__main__":  
2
    import sys  
3
    from PyQt6.QtWidgets import QApplication  
4
    from Qt6_20_MVC_01_Vue import Calculatrice  
5
    from Qt6_20_MVC_03_Controleur import Controleur
6
    from Qt6_20_MVC_02_Modele import evaluation
7
    
8
    # Création de l'application  
9
    app = QApplication(sys.argv)  
10
        
11
    # Instanciation des composants MVC  
12
    vue = Calculatrice()  # Vue  
13
    controleur = Controleur(modele=evaluation, vue=vue)  
14
    # Contrôleur avec modèle et vue  
15
        
16
    # Affichage de la fenêtre principale  
17
    vue.show()  
18
        
19
    # Exécution de l'application  
20
    sys.exit(app.exec()) 
-*- coding: utf-8 -*-⚓
Documentation
1
# Qt6_22_MVC_Modele.py — -*- coding: utf-8 -*-
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant architecture mvc (model-view-controller).
4
5
## Catégorie
6
**Application métier Qt6**
7
8
## Objectifs pédagogiques
9
- !/usr/bin/env python3
10
- -*- coding: utf-8 -*-
11
- Utilisation sécurisée de eval() pour évaluer des expressions mathématiques
12
- Les deux dictionnaires vides limitent l'accès aux fonctions intégrées
13
- et aux variables globales pour des raisons de sécurité
14
15
## Imports principaux
16
```python
17
from PyQt6.QtWidgets import QApplication
18
```
19
20
## Éléments principaux
21
- Fonction : `evaluation()`
22
- Fonction : `valider_expression()`
23
- Fonction : `formater_resultat()`
24
25
## Exécution
26
```bash
27
python Qt6_22_MVC_Modele.py
28
```
29
30
## Fichier source
31
Le code source complet se trouve dans : `004/Qt6_22_MVC_Modele.py`
32
33
## Points clés
34
- Interface graphique avec PyQt6
35
- Architecture MVC (Model-View-Controller)
36
- Application des bonnes pratiques de développement
37
38
---
39
*Documentation générée automatiquement pour le projet gimdidpy*
40
Code Python
1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*-
3
"""
4
Modèle pour une calculatrice simple utilisant le pattern MVC avec PyQt6
5
6
Ce fichier contient la logique métier de la calculatrice (le "M" de MVC).
7
Le modèle est responsable de :
8
- L'évaluation des expressions mathématiques
9
- La gestion des erreurs de calcul
10
- La transformation des données d'entrée en résultats
11
12
Dans le pattern MVC :
13
- Modèle (Model) : Logique métier et données (ce fichier)
14
- Vue (View) : Interface utilisateur (widgets PyQt6)
15
- Contrôleur (Controller) : Gestion des interactions utilisateur
16
17
Auteur: Franck OURION
18
Date: 2025
19
"""
20
21
22
def evaluation(expression: str) -> str:
23
    """
24
    Évalue une expression mathématique et retourne le résultat sous forme de chaîne.
25
    
26
    Cette fonction constitue le cœur de la logique métier de la calculatrice.
27
    Elle prend en entrée une expression mathématique sous forme de chaîne
28
    et retourne le résultat calculé ou un message d'erreur.
29
    
30
    Args:
31
        expression (str): Expression mathématique à évaluer (ex: "2+3*4")
32
    
33
    Returns:
34
        str: Résultat du calcul ou 'erreur' si l'évaluation échoue
35
    
36
    Exemples:
37
        >>> evaluation("2+3")
38
        '5'
39
        >>> evaluation("10/2")
40
        '5.0'
41
        >>> evaluation("2+")
42
        'erreur'
43
    
44
    Note:
45
        L'utilisation d'eval() est limitée à un environnement sécurisé
46
        (dictionnaires vides) pour éviter l'exécution de code malveillant.
47
    """
48
    try:
49
        # Utilisation sécurisée de eval() pour évaluer des expressions mathématiques
50
        # Les deux dictionnaires vides limitent l'accès aux fonctions intégrées
51
        # et aux variables globales pour des raisons de sécurité
52
        resultat = str(eval(expression, {}, {}))
53
        
54
        # Affichage du résultat pour le débogage
55
        print(f"Expression '{expression}' évaluée : {resultat}")
56
        
57
    except Exception as e:
58
        # Gestion des erreurs : syntaxe invalide, division par zéro, etc.
59
        print(f"Erreur lors de l'évaluation de '{expression}' : {e}")
60
        resultat = 'erreur'
61
    
62
    return resultat
63
64
65
# Fonctions auxiliaires pour la calculatrice
66
67
def valider_expression(expression: str) -> bool:
68
    """
69
    Valide une expression mathématique avant évaluation.
70
    
71
    Args:
72
        expression (str): Expression à valider
73
    
74
    Returns:
75
        bool: True si l'expression semble valide, False sinon
76
    """
77
    # Vérification des caractères autorisés
78
    caracteres_autorises = set('0123456789+-*/.() ')
79
    
80
    # Vérifie que tous les caractères sont autorisés
81
    for char in expression:
82
        if char not in caracteres_autorises:
83
            return False
84
    
85
    # Vérification basique : l'expression ne doit pas être vide
86
    if not expression.strip():
87
        return False
88
    
89
    return True
90
91
92
def formater_resultat(resultat: str) -> str:
93
    """
94
    Formate le résultat pour l'affichage dans l'interface.
95
    
96
    Args:
97
        resultat (str): Résultat brut du calcul
98
    
99
    Returns:
100
        str: Résultat formaté pour l'affichage
101
    """
102
    # Si c'est une erreur, retourner tel quel
103
    if resultat == 'erreur':
104
        return resultat
105
    
106
    try:
107
        # Convertir en float pour vérifier si c'est un nombre
108
        nombre = float(resultat)
109
        
110
        # Si c'est un entier, afficher sans décimales
111
        if nombre.is_integer():
112
            return str(int(nombre))
113
        else:
114
            # Limiter à 10 décimales maximum
115
            return f"{nombre:.10g}"
116
            
117
    except ValueError:
118
        # Si ce n'est pas un nombre, retourner tel quel
119
        return resultat 
Qt6 23 MVC Controleur⚓
Documentation
1
# Qt6_23_MVC_Controleur.py — Qt6 23 MVC Controleur
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant architecture mvc (model-view-controller).
4
5
## Catégorie
6
**Application métier Qt6**
7
8
## Objectifs pédagogiques
9
- Comprendre l'utilisation de PyQt6
10
- Développer des interfaces graphiques
11
- Maîtriser les widgets et layouts
12
13
## Imports principaux
14
```python
15
from PyQt6.QtWidgets import QApplication
16
import sys
17
```
18
19
## Éléments principaux
20
- Classe : `Controleur`
21
- Fonction : `connectionSignaux()`
22
- Fonction : `construireExpression()`
23
- Fonction : `calculer()`
24
25
## Exécution
26
```bash
27
python Qt6_23_MVC_Controleur.py
28
```
29
30
## Fichier source
31
Le code source complet se trouve dans : `004/Qt6_23_MVC_Controleur.py`
32
33
## Points clés
34
- Interface graphique avec PyQt6
35
- Architecture MVC (Model-View-Controller)
36
- Application des bonnes pratiques de développement
37
38
---
39
*Documentation générée automatiquement pour le projet gimdidpy*
40
Code Python
1
from PyQt6.QtWidgets import QApplication  
2
import sys  
3
4
class Controleur:  
5
    def __init__(self, modele, vue):  
6
        """  
7
        Initialise le contrôleur avec le modèle et la vue.  
8
        """  
9
        self._evaluation = modele  
10
        self._vue = vue  
11
        self.connectionSignaux()  
12
13
    def connectionSignaux(self):  
14
        """  
15
        Connecte les signaux des boutons aux slots correspondants. 
16
        """  
17
        for texte, bouton in self._vue.boutons.items():  
18
            if texte == "=":  
19
                bouton.clicked.connect(self.calculer)  
20
            elif texte == "C":  
21
                bouton.clicked.connect(self._vue.nettoyer)  
22
            else:  
23
                bouton.clicked.connect(lambda _, t=texte: self.construireExpression(t))  
24
25
    def construireExpression(self, btn: str):  
26
        """  
27
        Concatène le caractère du bouton pressé à l'expression  
28
        en cours et met à jour l'affichage.  
29
        """  
30
        expression = self._vue.getAffichage() + btn  
31
        self._vue.setAffichage(expression)  
32
33
    def calculer(self):  
34
        """  
35
        Évalue l'expression mathématique et affiche le résultat.  
36
        """  
37
        expression = self._vue.getAffichage()  
38
        resultat = self._evaluation(expression)  
39
        self._vue.setAffichage(resultat)
Qt6 24 MVC Vue⚓
Documentation
1
# Qt6_24_MVC_Vue.py — Qt6 24 MVC Vue
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant architecture mvc (model-view-controller).
4
5
## Catégorie
6
**Application métier Qt6**
7
8
## Objectifs pédagogiques
9
- Configuration du layout principal
10
- Création des éléments de l'interface
11
12
## Imports principaux
13
```python
14
from PyQt6.QtWidgets import (
15
```
16
17
## Éléments principaux
18
- Classe : `Calculatrice`
19
- Fonction : `creationZoneAffichage()`
20
- Fonction : `creationBoutons()`
21
- Fonction : `setAffichage()`
22
- Fonction : `getAffichage()`
23
- Fonction : `nettoyer()`
24
25
## Exécution
26
```bash
27
python Qt6_24_MVC_Vue.py
28
```
29
30
## Fichier source
31
Le code source complet se trouve dans : `004/Qt6_24_MVC_Vue.py`
32
33
## Points clés
34
- Interface graphique avec PyQt6
35
- Architecture MVC (Model-View-Controller)
36
- Application des bonnes pratiques de développement
37
38
---
39
*Documentation générée automatiquement pour le projet gimdidpy*
40
Code Python
1
from PyQt6.QtWidgets import (  
2
QApplication, QMainWindow, QVBoxLayout, QGridLayout,  
3
QLineEdit, QPushButton, QWidget  
4
)  
5
from PyQt6.QtCore import Qt  
6
7
class Calculatrice(QMainWindow):  
8
    def __init__(self):  
9
        super().__init__()  
10
            
11
        self.setWindowTitle("Calculatrice")  
12
        self.setFixedSize(235, 235)  
13
            
14
        # Configuration du layout principal  
15
        self.disposition = QVBoxLayout()  
16
        self._widget = QWidget(self)  
17
        self.setCentralWidget(self._widget)  
18
        self._widget.setLayout(self.disposition)  
19
            
20
        # Création des éléments de l'interface  
21
        self.creationZoneAffichage()  
22
        self.creationBoutons()
23
    
24
    def creationZoneAffichage(self):  
25
        self.resultat = QLineEdit()  
26
        self.resultat.setFixedHeight(60)  
27
        self.resultat.setContentsMargins(10, 10, 10, 10)  
28
        self.resultat.setAlignment(Qt.AlignmentFlag.AlignRight)  
29
        self.resultat.setReadOnly(True)   
30
        self.disposition.addWidget(self.resultat)  
31
        self.resultat.setText('')
32
    def creationBoutons(self):  
33
        self.boutons = {}  
34
        dispositionBoutons = QGridLayout()  
35
                
36
        boutons = {  
37
                '7': (0, 0), '8': (0, 1), '9': (0, 2), '/': (0, 3),  
38
                '4': (1, 0), '5': (1, 1), '6': (1, 2), '*': (1, 3),  
39
                '1': (2, 0), '2': (2, 1), '3': (2, 2), '-': (2, 3),  
40
                '0': (3, 0), 'C': (3, 1), '=': (3, 2), '+': (3, 3),  
41
        }  
42
                
43
        for btnTexte, pos in boutons.items():  
44
            self.boutons[btnTexte] = QPushButton(btnTexte)  
45
            self.boutons[btnTexte].setFixedSize(40, 40)  
46
            dispositionBoutons.addWidget(self.boutons[btnTexte], pos[0], pos[1])  
47
                
48
        self.disposition.addLayout(dispositionBoutons)
49
    
50
    def setAffichage(self, texte: str):  
51
        self.resultat.setText(texte)  
52
        self.resultat.repaint()  
53
54
    def getAffichage(self) -> str:  
55
        return self.resultat.text()  
56
    
57
    def nettoyer(self):  
58
        self.setAffichage('') 
⚓
Objectif⚓
Manipulation de bases de données SQLite
Qt6 31 SQL Bdd Create⚓
Documentation
1
# Qt6_31_SQL_Bdd_Create.py — Qt6 31 SQL Bdd Create
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant manipulation de bases de données sqlite.
4
5
## Catégorie
6
**Base de données et Qt6**
7
8
## Objectifs pédagogiques
9
- Bouton associé à la méthode `creationDB`
10
- Création d'une base de données SQLite
11
- Création des requêtes SQL
12
13
## Imports principaux
14
```python
15
import sys
16
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton
17
from PyQt6 import QtSql
18
```
19
20
## Éléments principaux
21
- Classe : `FenetreSimple`
22
- Fonction : `creationDB()`
23
- Fonction : `execute()`
24
25
## Exécution
26
```bash
27
python Qt6_31_SQL_Bdd_Create.py
28
```
29
30
## Fichier source
31
Le code source complet se trouve dans : `004/Qt6_31_SQL_Bdd_Create.py`
32
33
## Points clés
34
- Interface graphique avec PyQt6
35
- Manipulation de bases de données SQLite
36
- Application des bonnes pratiques de développement
37
38
---
39
*Documentation générée automatiquement pour le projet gimdidpy*
40
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton  
3
from PyQt6 import QtSql  
4
5
class FenetreSimple(QWidget):  
6
    def __init__(self):  
7
        super().__init__()  
8
9
        self.disposition = QVBoxLayout()  
10
11
        # Bouton associé à la méthode `creationDB`  
12
        self.clickbouton = QPushButton("Click", clicked=self.creationDB)   
13
        self.disposition.addWidget(self.clickbouton)  
14
15
        self.setLayout(self.disposition)  
16
        self.execute()  
17
18
    def creationDB(self):  
19
        # Création d'une base de données SQLite  
20
        db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
21
        db.setDatabaseName('Baselivres.db')  
22
        print("Création base ok")  
23
24
        if not db.open():  
25
            print("La Db ne peut pas s'ouvrir.")  
26
            return False  
27
28
        # Création des requêtes SQL  
29
        creationTableLivre = """create table LIVRE(  
30
            id INTEGER PRIMARY KEY AUTOINCREMENT,   
31
            TITRE TEXT NOT NULL,  
32
            ANNEE int,  
33
            sujet_id INTEGER REFERENCES SUJET(id),  
34
            personne_id INTEGER REFERENCES PERSONNE(id)  
35
        );"""  
36
37
        creationTableSujet = """create table SUJET(  
38
            id INTEGER PRIMARY KEY AUTOINCREMENT,   
39
            SUJET TEXT NOT NULL  
40
        );"""  
41
42
        creationTablePersonne = """create table PERSONNE(  
43
            id INTEGER PRIMARY KEY AUTOINCREMENT,  
44
            NOM TEXT NOT NULL,   
45
            PRENOM TEXT NOT NULL  
46
        );"""  
47
48
        # Exécution des requêtes SQL  
49
        query = QtSql.QSqlQuery()  
50
51
        if query.exec(creationTableLivre):  
52
            print("Création table LIVRE ok")  
53
54
        if query.exec(creationTableSujet):  
55
            print("Création table SUJET ok")  
56
57
        if query.exec(creationTablePersonne):  
58
            print("Création table PERSONNE ok")  
59
60
    def execute(self):  
61
        self.resize(250, 300)  
62
        self.move(50, 500)  
63
        self.setWindowTitle("Qt6-30 - création base de données") 
64
        self.show()  
65
66
67
if __name__ == '__main__':  
68
    application = QApplication(sys.argv)  
69
    fenetre = FenetreSimple()  
70
    sys.exit(application.exec()) 
Qt6 32 SQL Bdd Update⚓
Documentation
1
# Qt6_32_SQL_Bdd_Update.py — Qt6 32 SQL Bdd Update
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant manipulation de bases de données sqlite.
4
5
## Catégorie
6
**Base de données et Qt6**
7
8
## Objectifs pédagogiques
9
- Comprendre l'utilisation de PyQt6
10
- Développer des interfaces graphiques
11
- Maîtriser les widgets et layouts
12
13
## Imports principaux
14
```python
15
import sys
16
from PyQt6 import QtCore, QtSql
17
```
18
19
## Éléments principaux
20
- Fonction : `updateDB()`
21
22
## Exécution
23
```bash
24
python Qt6_32_SQL_Bdd_Update.py
25
```
26
27
## Fichier source
28
Le code source complet se trouve dans : `004/Qt6_32_SQL_Bdd_Update.py`
29
30
## Points clés
31
- Interface graphique avec PyQt6
32
- Manipulation de bases de données SQLite
33
- Application des bonnes pratiques de développement
34
35
---
36
*Documentation générée automatiquement pour le projet gimdidpy*
37
Code Python
1
import sys  
2
from PyQt6 import QtCore, QtSql  
3
4
def updateDB():  
5
    app = QtCore.QCoreApplication(sys.argv)  
6
7
    db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
8
    db.setDatabaseName('Baselivres.db')  
9
    print("Connexion base ok")  
10
11
    if not db.open():  
12
        print("La Db ne peut pas s'ouvrir.")  
13
        return False  
14
15
    query = QtSql.QSqlQuery()  
16
    query.exec("UPDATE SUJET SET SUJET = 'Microsoft C#' WHERE id = 1")  
17
18
    query.exec("SELECT COUNT(*) FROM SUJET")  
19
    while query.next():  
20
        print(query.value(0))  
21
22
    query.exec("SELECT SUJET FROM SUJET WHERE id = 1")  
23
    while query.next():  
24
        print(query.value(0))  
25
26
if __name__ == '__main__':  
27
    updateDB() 
Qt6 33 SQL Bdd Join⚓
Documentation
1
# Qt6_33_SQL_Bdd_Join.py — Qt6 33 SQL Bdd Join
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant manipulation de bases de données sqlite.
4
5
## Catégorie
6
**Base de données et Qt6**
7
8
## Objectifs pédagogiques
9
- Comprendre l'utilisation de PyQt6
10
- Développer des interfaces graphiques
11
- Maîtriser les widgets et layouts
12
13
## Imports principaux
14
```python
15
import sys
16
from PyQt6 import QtCore, QtSql
17
```
18
19
## Éléments principaux
20
- Fonction : `joinDB()`
21
22
## Exécution
23
```bash
24
python Qt6_33_SQL_Bdd_Join.py
25
```
26
27
## Fichier source
28
Le code source complet se trouve dans : `004/Qt6_33_SQL_Bdd_Join.py`
29
30
## Points clés
31
- Interface graphique avec PyQt6
32
- Manipulation de bases de données SQLite
33
- Application des bonnes pratiques de développement
34
35
---
36
*Documentation générée automatiquement pour le projet gimdidpy*
37
Code Python
1
import sys  
2
from PyQt6 import QtCore, QtSql  
3
4
def joinDB():  
5
    app = QtCore.QCoreApplication(sys.argv)   
6
7
    db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
8
    db.setDatabaseName('Baselivres.db')  
9
    print("Connexion base ok")  
10
11
    if not db.open():  
12
        print("La Db ne peut pas s'ouvrir.")  
13
        return False  
14
15
    query = QtSql.QSqlQuery()  
16
17
    query.exec("""  
18
        SELECT PERSONNE.PRENOM, PERSONNE.NOM  
19
        FROM PERSONNE, LIVRE, SUJET  
20
        WHERE PERSONNE.id = LIVRE.personne_id  
21
        AND SUJET.id = LIVRE.sujet_id  
22
        AND SUJET.SUJET = 'Microsoft C#'  
23
        AND LIVRE.ANNEE = 2019  
24
    """)  
25
26
    while query.next():  
27
        print(query.value(0), query.value(1))  
28
29
if __name__ == '__main__':  
30
    joinDB() 
Ajout d'une instance QCoreApplication⚓
Documentation
1
# Qt6_34_SQL_Bdd_Add_Tuples.py — Ajout d'une instance QCoreApplication
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant manipulation de bases de données sqlite.
4
5
## Catégorie
6
**Base de données et Qt6**
7
8
## Objectifs pédagogiques
9
- Ajout d'une instance QCoreApplication
10
11
## Imports principaux
12
```python
13
import sys
14
from PyQt6 import QtCore, QtSql
15
```
16
17
## Éléments principaux
18
- Fonction : `insertionDB()`
19
20
## Exécution
21
```bash
22
python Qt6_34_SQL_Bdd_Add_Tuples.py
23
```
24
25
## Fichier source
26
Le code source complet se trouve dans : `004/Qt6_34_SQL_Bdd_Add_Tuples.py`
27
28
## Points clés
29
- Interface graphique avec PyQt6
30
- Manipulation de bases de données SQLite
31
- Application des bonnes pratiques de développement
32
33
---
34
*Documentation générée automatiquement pour le projet gimdidpy*
35
Code Python
1
import sys  
2
from PyQt6 import QtCore, QtSql  
3
4
def insertionDB():  
5
    # Ajout d'une instance QCoreApplication  
6
    app = QtCore.QCoreApplication(sys.argv)   
7
    db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
8
    db.setDatabaseName('Baselivres.db')  
9
    print("Connexion base ok")  
10
11
    if not db.open():  
12
        print("La Db ne peut pas s'ouvrir.")  
13
        return False  
14
15
    query = QtSql.QSqlQuery()  
16
17
    print(query.exec("SELECT COUNT(*) FROM PERSONNE"))  
18
    while query.next():  
19
        print(query.value(0))  
20
21
    query.exec("INSERT INTO PERSONNE('NOM', 'PRENOM') VALUES('Prieur', 'Benoît')")  
22
    query.exec("INSERT INTO PERSONNE('NOM', 'PRENOM') VALUES('Mocq', 'François')")  
23
    query.exec("INSERT INTO PERSONNE('NOM', 'PRENOM') VALUES('Lacaze', 'Sarah')")  
24
25
    print(query.exec("SELECT COUNT(*) FROM PERSONNE"))  
26
    while query.next():  
27
        print(query.value(0))  
28
29
    print(query.exec("SELECT COUNT(*) FROM SUJET"))  
30
    while query.next():  
31
        print(query.value(0))  
32
33
    query.exec("INSERT INTO SUJET('SUJET') VALUES('C Sharp')")  
34
    query.exec("INSERT INTO SUJET('SUJET') VALUES('Raspberry Pi')")  
35
    query.exec("INSERT INTO SUJET('SUJET') VALUES('Scratch')")  
36
37
    print(query.exec("SELECT COUNT(*) FROM SUJET"))  
38
    while query.next():  
39
        print(query.value(0))  
40
41
    print(query.exec("SELECT COUNT(*) FROM LIVRE"))  
42
    while query.next():  
43
        print(query.value(0))  
44
45
    query.exec("INSERT INTO LIVRE('TITRE', 'ANNEE', 'sujet_id', 'personne_id') VALUES('Programmation en C# - Préparation aux certifications MCSA - Examen 70-483', 2018, 1, 1)")  
46
    query.exec("INSERT INTO LIVRE('TITRE', 'ANNEE', 'sujet_id', 'personne_id') VALUES('WPF - Développez des applications structurées (MVVM, XAML...)', 2017, 1, 1)")  
47
    query.exec("INSERT INTO LIVRE('TITRE', 'ANNEE', 'sujet_id', 'personne_id') VALUES('Raspberry Pi 4', 2019, 2, 2)")  
48
    query.exec("INSERT INTO LIVRE('TITRE', 'ANNEE', 'sujet_id', 'personne_id') VALUES('Scratch 3', 2019, 1, 1)")  
49
50
    print(query.exec("SELECT COUNT(*) FROM LIVRE"))  
51
    while query.next():  
52
        print(query.value(0))  
53
54
if __name__ == '__main__':  
55
    insertionDB() 
Qt6 35 SQL Bdd Join Param⚓
Documentation
1
# Qt6_35_SQL_Bdd_Join_Param.py — Qt6 35 SQL Bdd Join Param
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant manipulation de bases de données sqlite.
4
5
## Catégorie
6
**Base de données et Qt6**
7
8
## Objectifs pédagogiques
9
- Utilisation d'une requête préparée pour éviter l'injection SQL  SQL
10
11
## Imports principaux
12
```python
13
import sys
14
from PyQt6 import QtCore, QtSql
15
```
16
17
## Éléments principaux
18
- Fonction : `joinDB()`
19
20
## Exécution
21
```bash
22
python Qt6_35_SQL_Bdd_Join_Param.py
23
```
24
25
## Fichier source
26
Le code source complet se trouve dans : `004/Qt6_35_SQL_Bdd_Join_Param.py`
27
28
## Points clés
29
- Interface graphique avec PyQt6
30
- Manipulation de bases de données SQLite
31
- Application des bonnes pratiques de développement
32
33
---
34
*Documentation générée automatiquement pour le projet gimdidpy*
35
Code Python
1
import sys  
2
from PyQt6 import QtCore, QtSql  
3
4
def joinDB():  
5
    app = QtCore.QCoreApplication(sys.argv)  
6
7
    db = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
8
    db.setDatabaseName('Baselivres.db')  
9
    print("Connexion base ok")  
10
11
    if not db.open():  
12
        print("La Db ne peut pas s'ouvrir.")  
13
        return False  
14
15
    query = QtSql.QSqlQuery()  
16
        
17
    sujet = 'Microsoft C#'  
18
    annee = 2019  
19
20
    # Utilisation d'une requête préparée pour éviter l'injection SQL  SQL  
21
    requete = """  
22
        SELECT PERSONNE.PRENOM, PERSONNE.NOM  
23
        FROM PERSONNE, LIVRE, SUJET  
24
        WHERE PERSONNE.id = LIVRE.personne_id  
25
        AND SUJET.id = LIVRE.sujet_id  
26
        AND SUJET.SUJET = :sujet  
27
        AND LIVRE.ANNEE = :annee  
28
    """  
29
30
    print("Requête exécutée :", requete)  
31
32
    query.prepare(requete)  
33
    query.bindValue(":sujet", sujet)  
34
    query.bindValue(":annee", annee)  
35
36
    if query.exec():  
37
        while query.next():  
38
            print(query.value(0), query.value(1))  
39
    else:  
40
        print("Erreur dans l'exécution de la requête :", query.lastError().text())  
41
42
if __name__ == '__main__':  
43
    joinDB() 
⚓
Objectif⚓
Modèles SQL et widgets de données
Qt6 41 QsqlTableModel⚓
Documentation
1
# Qt6_41_QsqlTableModel.py — Qt6 41 QsqlTableModel
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant modèles sql et widgets de données.
4
5
## Catégorie
6
**SQL Qt6**
7
8
## Objectifs pédagogiques
9
- Connexion à la base de données SQLite
10
- Définition du modèle
11
- Modification immédiate
12
- Création de la vue et association au modèle
13
- Création de la boîte de dialogue
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QVBoxLayout, QPushButton, QTableView, QDialog
19
from PyQt6 import QtSql, QtCore
20
```
21
22
## Exécution
23
```bash
24
python Qt6_41_QsqlTableModel.py
25
```
26
27
## Fichier source
28
Le code source complet se trouve dans : `004/Qt6_41_QsqlTableModel.py`
29
30
## Points clés
31
- Interface graphique avec PyQt6
32
- Modèles SQL et widgets de données
33
- Application des bonnes pratiques de développement
34
35
---
36
*Documentation générée automatiquement pour le projet gimdidpy*
37
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QVBoxLayout, QPushButton, QTableView, QDialog  
3
from PyQt6 import QtSql, QtCore  
4
5
if __name__ == '__main__':  
6
    app = QApplication(sys.argv)  
7
8
    # Connexion à la base de données SQLite  
9
    base = QtSql.QSqlDatabase.addDatabase('QSQLITE')  
10
    base.setDatabaseName('Baselivres.db')  
11
12
    # Définition du modèle  
13
    modele = QtSql.QSqlTableModel()  
14
    modele.setTable('SUJET')  
15
    modele.setEditStrategy(QtSql.QSqlTableModel.EditStrategy.OnFieldChange) 
16
    # Modification immédiate  
17
    modele.select()  
18
    modele.setHeaderData(0, QtCore.Qt.Orientation.Horizontal, "id")  
19
    modele.setHeaderData(1, QtCore.Qt.Orientation.Horizontal, "SUJET")  
20
21
    # Création de la vue et association au modèle  
22
    vue = QTableView()  
23
    vue.setModel(modele)  
24
25
    # Création de la boîte de dialogue  
26
    dialogue = QDialog()  
27
    disposition = QVBoxLayout()  
28
    disposition.addWidget(vue)  
29
30
    # Bouton d'ajout  
31
    bouton_ajout = QPushButton("ajouter un sujet")  
32
    bouton_ajout.clicked.connect(lambda: modele.insertRows(modele.rowCount(), 1))  
33
    disposition.addWidget(bouton_ajout)  
34
35
    # Bouton de suppression  
36
    bouton_suppression = QPushButton("supprimer un sujet")  
37
    bouton_suppression.clicked.connect(lambda: modele.removeRow(vue.currentIndex().row()))  
38
    disposition.addWidget(bouton_suppression)  
39
40
    # Finalisation de l'interface  
41
    dialogue.setLayout(disposition)  
42
    dialogue.setWindowTitle("Usage de QSqlTableModel")  
43
    dialogue.show()  
44
45
    sys.exit(app.exec()) 
Qt6 42 QsqlRelationalTableModel⚓
Documentation
1
# Qt6_42_QsqlRelationalTableModel.py — Qt6 42 QsqlRelationalTableModel
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant modèles sql et widgets de données.
4
5
## Catégorie
6
**SQL Qt6**
7
8
## Objectifs pédagogiques
9
- Connexion à la base de données SQLite
10
- Création du modèle relationnel
11
- Définition des relations pour les clés étrangères
12
- Définition des en-têtes de colonnes pour une meilleure lisibilité
13
- Sélection des données après configuration du modèle
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QVBoxLayout, QPushButton, QTableView, QDialog
19
from PyQt6 import QtSql, QtCore
20
from PyQt6.QtSql import QSqlDatabase, QSqlRelationalTableModel, QSqlRelation, QSqlRelationalDelegate
21
```
22
23
## Exécution
24
```bash
25
python Qt6_42_QsqlRelationalTableModel.py
26
```
27
28
## Fichier source
29
Le code source complet se trouve dans : `004/Qt6_42_QsqlRelationalTableModel.py`
30
31
## Points clés
32
- Interface graphique avec PyQt6
33
- Modèles SQL et widgets de données
34
- Application des bonnes pratiques de développement
35
36
---
37
*Documentation générée automatiquement pour le projet gimdidpy*
38
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QVBoxLayout, QPushButton, QTableView, QDialog  
3
from PyQt6 import QtSql, QtCore  
4
from PyQt6.QtSql import QSqlDatabase, QSqlRelationalTableModel, QSqlRelation, QSqlRelationalDelegate  
5
6
if __name__ == '__main__':  
7
    app = QApplication(sys.argv)  
8
9
    # Connexion à la base de données SQLite  
10
    base = QSqlDatabase.addDatabase('QSQLITE')  
11
    base.setDatabaseName('Baselivres.db')  
12
13
    # Création du modèle relationnel  
14
    modele = QSqlRelationalTableModel()  
15
    modele.setTable('LIVRE')  
16
    modele.setEditStrategy(QSqlRelationalTableModel.EditStrategy. OnFieldChange)  
17
18
    # Définition des relations pour les clés étrangères  
19
    modele.setRelation(3, QSqlRelation("SUJET", "id", "SUJET")) 
20
    modele.setRelation(4, QSqlRelation("PERSONNE", "id", "PRENOM"))  
21
22
    # Définition des en-têtes de colonnes pour une meilleure lisibilité  
23
    modele.setHeaderData(3, QtCore.Qt.Orientation.Horizontal, "Sujet")  
24
    modele.setHeaderData(4, QtCore.Qt.Orientation.Horizontal, "Prénom")  
25
26
    # Sélection des données après configuration du modèle  
27
    modele.select()  
28
29
    # Création de la vue associée au modèle  
30
    vue = QTableView()  
31
    vue.setModel(modele)  
32
    vue.setItemDelegate(QSqlRelationalDelegate(vue))  
33
34
    # Création de la boîte de dialogue  
35
    dialogue = QDialog()  
36
    disposition = QVBoxLayout()  
37
    disposition.addWidget(vue)  
38
39
    # Bouton pour ajouter un livre  
40
    bouton_ajout = QPushButton("Ajouter un livre")  
41
    bouton_ajout.clicked.connect(lambda: modele.insertRows(modele.rowCount(), 1))  
42
    disposition.addWidget(bouton_ajout)  
43
44
    # Bouton pour supprimer un livre  
45
    bouton_suppression = QPushButton("Supprimer un livre")  
46
    bouton_suppression.clicked.connect(lambda: modele.removeRow(vue.currentIndex().row()))  
47
    disposition.addWidget(bouton_suppression)  
48
49
    # Finalisation de l'interface  
50
    dialogue.setLayout(disposition)  
51
    dialogue.setWindowTitle("Usage de QSqlRelationalTableModel") 
52
    dialogue.show()  
53
54
    sys.exit(app.exec()) 
Qt6 43 QDataWidgetMapper⚓
Documentation
1
# Qt6_43_QDataWidgetMapper.py — Qt6 43 QDataWidgetMapper
2
3
Ce script Python fait partie de la série d'initiation à PyQt6, illustrant modèles sql et widgets de données.
4
5
## Catégorie
6
**SQL Qt6**
7
8
## Objectifs pédagogiques
9
- Création de la boîte de dialogue
10
- Champs d'édition
11
- Boutons de navigation
12
- Connexion à la base de données
13
- Définition du modèle
14
15
## Imports principaux
16
```python
17
import sys
18
from PyQt6.QtWidgets import QApplication, QDialog, QLineEdit, QPushButton, QFormLayout, QDataWidgetMapper
19
from PyQt6 import QtSql
20
from PyQt6.QtSql import QSqlTableModel, QSqlDatabase
21
```
22
23
## Éléments principaux
24
- Fonction : `prec()`
25
- Fonction : `suiv()`
26
27
## Exécution
28
```bash
29
python Qt6_43_QDataWidgetMapper.py
30
```
31
32
## Fichier source
33
Le code source complet se trouve dans : `004/Qt6_43_QDataWidgetMapper.py`
34
35
## Points clés
36
- Interface graphique avec PyQt6
37
- Modèles SQL et widgets de données
38
- Application des bonnes pratiques de développement
39
40
---
41
*Documentation générée automatiquement pour le projet gimdidpy*
42
Code Python
1
import sys  
2
from PyQt6.QtWidgets import QApplication, QDialog, QLineEdit, QPushButton, QFormLayout, QDataWidgetMapper  
3
from PyQt6 import QtSql  
4
from PyQt6.QtSql import QSqlTableModel, QSqlDatabase  
5
6
def prec():  
7
    print("Bouton précédent")  
8
    mapping.toPrevious()  
9
    id.repaint()  
10
    sujet.repaint()  
11
12
def suiv():  
13
    print("Bouton suivant")  
14
    mapping.toNext()  
15
    id.repaint()  
16
    sujet.repaint()  
17
18
if __name__ == '__main__':  
19
    app = QApplication(sys.argv)  
20
21
    # Création de la boîte de dialogue  
22
    dialogue = QDialog()  
23
    disposition = QFormLayout()  
24
25
    # Champs d'édition  
26
    id = QLineEdit()  
27
    id.setReadOnly(True)  # L'ID ne doit pas être modifiable  
28
    sujet = QLineEdit()  
29
30
    disposition.addRow("ID :", id)  
31
    disposition.addRow("Sujet :", sujet)  
32
33
    # Boutons de navigation  
34
    precedentBouton = QPushButton("Précédent")  
35
    suivantBouton = QPushButton("Suivant")  
36
    disposition.addRow(precedentBouton, suivantBouton)  
37
38
    dialogue.setLayout(disposition)  
39
    dialogue.setWindowTitle("Usage de QDataWidgetMapper")  
40
41
    # Connexion à la base de données  
42
    base = QSqlDatabase.addDatabase('QSQLITE')  
43
    base.setDatabaseName('Baselivres.db')  
44
45
    # Définition du modèle  
46
    modele = QSqlTableModel()  
47
    modele.setTable('SUJET')  
48
    modele.setEditStrategy(QSqlTableModel.EditStrategy.OnFieldChange)  
49
    modele.select()  
50
51
    # Mapping des champs aux colonnes  
52
    mapping = QDataWidgetMapper()  
53
    mapping.setModel(modele)  
54
    mapping.addMapping(id, 0)  
55
    mapping.addMapping(sujet, 1)  
56
    mapping.toFirst()  
57
58
    # Connexion des boutons aux fonctions  
59
    precedentBouton.clicked.connect(prec)  
60
    suivantBouton.clicked.connect(suiv)  
61
62
    dialogue.show()  
63
    sys.exit(app.exec())