Exercise 001_07

Cahier des charges⚓

1
# 001_07 — Visualisations multiples avec xlsxwriter
2
3
## Objectifs
4
- Créer plusieurs graphes dans des feuilles séparées
5
- Démontrer différents types de charts xlsxwriter
6
- Rester sur des valeurs numériques calculées (pas de formules Excel)
7
- Visualiser les données sous plusieurs angles
8
9
## Structure des feuilles
10
11
### Feuille "do"
12
Données brutes : i, ttf(i), dN(i), N(i)
13
14
### Feuille "graph_N_ttf"
15
Graphe scatter avec lignes : N(i) = f(ttf(i))
16
- Type : scatter + straight_with_markers
17
- Même graphe que 001_03 et 001_04
18
19
### Feuille "graph_histo_classes"
20
Histogramme des classes de ttf(i)
21
- Type : column (barres verticales)
22
- X : Classes [0-362), [362-725), etc.
23
- Y : Nombre de points par classe
24
25
### Feuille "graph_fiabilite"
26
Courbe de fiabilité R(i) = f(ttf(i))
27
- Type : line (courbe lisse)
28
- X : ttf(i)
29
- Y : R(i) = N(i) / N(0)
30
- Valeurs entre 0 et 1
31
32
### Feuille "graph_defaillance"
33
Courbe de défaillance cumulée F(i) = f(ttf(i))
34
- Type : line
35
- X : ttf(i)
36
- Y : F(i) = 1 - R(i)
37
- Complémentaire de la fiabilité
38
39
### Feuille "graph_barres_dN"
40
Diagramme en barres des défaillances
41
- Type : column
42
- X : i (rang)
43
- Y : dN(i) (nombre de défaillances)
44
45
## Types de graphes xlsxwriter
46
47
### Scatter (nuage de points)
48
```python
49
chart = workbook.add_chart({'type': 'scatter', 'subtype': 'straight_with_markers'})
50
```
51
52
### Column (barres verticales)
53
```python
54
chart = workbook.add_chart({'type': 'column'})
55
```
56
57
### Line (courbe)
58
```python
59
chart = workbook.add_chart({'type': 'line'})
60
```
61
62
### Bar (barres horizontales)
63
```python
64
chart = workbook.add_chart({'type': 'bar'})
65
```
66
67
## Utilisation
68
Génère 6 feuilles : 1 avec données + 5 avec graphes différents
69
Code Python⚓
1
# TD_EDC_01_001_07.py
2
# Résumé : Visualisations multiples avec xlsxwriter
3
# Génère 6 feuilles : données + 5 graphes différents
4
from pathlib import Path
5
import subprocess
6
import pandas as pd
7
import xlsxwriter
8
9
10
def build_paths() -> Path:
11
    """Calcule le chemin du fichier Excel de sortie."""
12
    script = Path(__file__).resolve()
13
    root = script.parent.parent
14
    stem = script.stem
15
    base_dir_name = script.parent.name
16
    xlsx_dir = root / f"{base_dir_name}_do"
17
    xlsx_dir.mkdir(parents=True, exist_ok=True)
18
    
19
    xlsx_path = (xlsx_dir / f"{stem}.xlsx").resolve()
20
    return xlsx_path
21
22
23
def delete_if_exists(file_path: Path) -> None:
24
    """Supprime le fichier s'il existe déjà."""
25
    if file_path.exists():
26
        file_path.unlink()
27
28
29
def prepare_data(n: int = 9, ttf_values: list = None) -> tuple:
30
    """Prépare les données de base et les données calculées."""
31
    i_values = list(range(n + 1))
32
    dN_values = [0] + [1] * n
33
    N_values = [n - i for i in range(n + 1)]
34
    
35
    df = pd.DataFrame({
36
        'i': i_values,
37
        'ttf(i)': ttf_values if ttf_values else [0] * (n + 1),
38
        'dN(i)': dN_values,
39
        'N(i)': N_values
40
    })
41
    
42
    # Calculer R(i) et F(i)
43
    N_0 = df['N(i)'].iloc[0]
44
    df['R(i)'] = df['N(i)'] / N_0
45
    df['F(i)'] = 1 - df['R(i)']
46
    
47
    # Classes pour histogramme
48
    ttf = df['ttf(i)']
49
    n_classes = 4
50
    class_width = (ttf.max() - ttf.min()) / n_classes
51
    bins = [ttf.min() + i * class_width for i in range(n_classes + 1)]
52
    df['classe'] = pd.cut(ttf, bins=bins, include_lowest=True)
53
    class_counts = df['classe'].value_counts().sort_index()
54
    
55
    df_classes = pd.DataFrame({
56
        'Classe': [f"[{bins[i]:.0f}, {bins[i+1]:.0f})" for i in range(n_classes)],
57
        'Nombre': class_counts.values
58
    })
59
    
60
    return df, df_classes
61
62
63
def create_excel_with_charts(xlsx_path: Path, df: pd.DataFrame, df_classes: pd.DataFrame) -> None:
64
    """Crée le fichier Excel avec données et 5 graphes."""
65
    workbook = xlsxwriter.Workbook(str(xlsx_path))
66
    
67
    # Feuille données
68
    ws_data = workbook.add_worksheet("do")
69
    for col_num, col_name in enumerate(df.columns[:5]):  # Exclure 'classe'
70
        ws_data.write(0, col_num, col_name)
71
    for row_num, row_data in enumerate(df.values, start=1):
72
        for col_num in range(5):
73
            ws_data.write(row_num, col_num, row_data[col_num])
74
    
75
    n_rows = len(df)
76
    
77
    # Graphe 1 : N(i) = f(ttf(i)) - Scatter avec lignes
78
    chart1 = workbook.add_chart({'type': 'scatter', 'subtype': 'straight_with_markers'})
79
    chart1.add_series({
80
        'name': 'N(ttf)',
81
        'categories': ['do', 1, 1, n_rows, 1],  # ttf(i)
82
        'values': ['do', 1, 3, n_rows, 3],      # N(i)
83
    })
84
    chart1.set_title({'name': 'N(i) en fonction de ttf(i)'})
85
    chart1.set_x_axis({'name': 'ttf(i)'})
86
    chart1.set_y_axis({'name': 'N(i)'})
87
    chart1.set_style(13)
88
    
89
    ws_chart1 = workbook.add_worksheet("graph_N_ttf")
90
    ws_chart1.insert_chart('A1', chart1, {'x_scale': 2, 'y_scale': 2})
91
    print("✓ Graphe 1: N(ttf) créé")
92
    
93
    # Graphe 2 : Histogramme des classes
94
    ws_classes = workbook.add_worksheet("data_classes")
95
    for col_num, col_name in enumerate(df_classes.columns):
96
        ws_classes.write(0, col_num, col_name)
97
    for row_num, row_data in enumerate(df_classes.values, start=1):
98
        for col_num, value in enumerate(row_data):
99
            ws_classes.write(row_num, col_num, value)
100
    
101
    chart2 = workbook.add_chart({'type': 'column'})
102
    chart2.add_series({
103
        'name': 'Nombre de points',
104
        'categories': ['data_classes', 1, 0, 4, 0],  # Classes
105
        'values': ['data_classes', 1, 1, 4, 1],      # Nombre
106
    })
107
    chart2.set_title({'name': 'Histogramme des classes de ttf(i)'})
108
    chart2.set_x_axis({'name': 'Classe'})
109
    chart2.set_y_axis({'name': 'Nombre de points'})
110
    chart2.set_style(11)
111
    
112
    ws_chart2 = workbook.add_worksheet("graph_histo_classes")
113
    ws_chart2.insert_chart('A1', chart2, {'x_scale': 2, 'y_scale': 2})
114
    print("✓ Graphe 2: Histogramme créé")
115
    
116
    # Graphe 3 : Courbe de fiabilité R(i)
117
    chart3 = workbook.add_chart({'type': 'line'})
118
    chart3.add_series({
119
        'name': 'Fiabilité R(i)',
120
        'categories': ['do', 1, 1, n_rows, 1],  # ttf(i)
121
        'values': ['do', 1, 4, n_rows, 4],      # R(i)
122
    })
123
    chart3.set_title({'name': 'Courbe de fiabilité R(i) = f(ttf(i))'})
124
    chart3.set_x_axis({'name': 'ttf(i)'})
125
    chart3.set_y_axis({'name': 'R(i)', 'min': 0, 'max': 1})
126
    chart3.set_style(10)
127
    
128
    ws_chart3 = workbook.add_worksheet("graph_fiabilite")
129
    ws_chart3.insert_chart('A1', chart3, {'x_scale': 2, 'y_scale': 2})
130
    print("✓ Graphe 3: Fiabilité créé")
131
    
132
    # Graphe 4 : Courbe de défaillance F(i)
133
    chart4 = workbook.add_chart({'type': 'line'})
134
    chart4.add_series({
135
        'name': 'Défaillance F(i)',
136
        'categories': ['do', 1, 1, n_rows, 1],  # ttf(i)
137
        'values': ['do', 1, 5, n_rows, 5],      # F(i)
138
    })
139
    chart4.set_title({'name': 'Courbe de défaillance cumulée F(i) = f(ttf(i))'})
140
    chart4.set_x_axis({'name': 'ttf(i)'})
141
    chart4.set_y_axis({'name': 'F(i)', 'min': 0, 'max': 1})
142
    chart4.set_style(12)
143
    
144
    ws_chart4 = workbook.add_worksheet("graph_defaillance")
145
    ws_chart4.insert_chart('A1', chart4, {'x_scale': 2, 'y_scale': 2})
146
    print("✓ Graphe 4: Défaillance créé")
147
    
148
    # Graphe 5 : Diagramme en barres de dN(i)
149
    chart5 = workbook.add_chart({'type': 'column'})
150
    chart5.add_series({
151
        'name': 'dN(i)',
152
        'categories': ['do', 1, 0, n_rows, 0],  # i
153
        'values': ['do', 1, 2, n_rows, 2],      # dN(i)
154
    })
155
    chart5.set_title({'name': 'Nombre de défaillances dN(i) par rang i'})
156
    chart5.set_x_axis({'name': 'Rang i'})
157
    chart5.set_y_axis({'name': 'dN(i)'})
158
    chart5.set_style(26)
159
    
160
    ws_chart5 = workbook.add_worksheet("graph_barres_dN")
161
    ws_chart5.insert_chart('A1', chart5, {'x_scale': 2, 'y_scale': 2})
162
    print("✓ Graphe 5: Barres dN(i) créé")
163
    
164
    workbook.close()
165
166
167
def open_in_excel(xlsx_path: Path) -> None:
168
    """Ouvre le classeur généré dans Excel."""
169
    subprocess.Popen(["start", "excel", str(xlsx_path)], shell=True)
170
171
172
def main() -> None:
173
    """Pipeline : génère les données et les 5 graphes."""
174
    xlsx_path = build_paths()
175
    
176
    ttf_i = [0, 250, 400, 550, 700, 850, 1000, 1150, 1300, 1450]
177
    
178
    print("Préparation des données...")
179
    df, df_classes = prepare_data(n=9, ttf_values=ttf_i)
180
    
181
    print("\nCréation des graphes...")
182
    delete_if_exists(xlsx_path)
183
    create_excel_with_charts(xlsx_path, df, df_classes)
184
    
185
    print(f"\nFichier créé : {xlsx_path}")
186
    print("6 feuilles générées : 1 données + 5 graphes")
187
    open_in_excel(xlsx_path)
188
189
190
if __name__ == "__main__":
191
    main()
192
Documentation⚓
1
# 001_07.py — Visualisations multiples avec xlsxwriter
2
3
Ce script Python génère un fichier Excel contenant des données et 5 types de graphiques différents pour visualiser les informations de manière variée.
4
5
## Objectifs pédagogiques
6
- Créer différents types de graphiques avec xlsxwriter
7
- Organiser les données et visualisations dans plusieurs feuilles
8
- Comparer différentes représentations graphiques des mêmes données
9
- Maîtriser la configuration des graphiques (axes, légendes, titres)
10
11
## Fonctionnement
12
1. **Préparation des données**
13
   - Génération d'un jeu de données de démonstration
14
   - Calculs de valeurs dérivées pour les visualisations
15
16
2. **Création des graphiques**
17
   - Graphique en ligne (line chart)
18
   - Graphique en colonnes (column chart)
19
   - Graphique en barres (bar chart)
20
   - Graphique en secteurs (pie chart)
21
   - Graphique combiné ou nuage de points (scatter/combo)
22
23
3. **Organisation multi-feuilles**
24
   - Feuille 1 : données sources
25
   - Feuilles 2-6 : un graphique par feuille
26
27
## Points techniques
28
- Utilisation avancée de `xlsxwriter.chart`
29
- Configuration des axes et des séries de données
30
- Positionnement des graphiques dans les feuilles
31
- Référencement des données entre feuilles
32
33
## Utilisation
34
Ce script sert de référence pour créer des rapports Excel avec visualisations multiples et comparaisons graphiques.
35
36
---
37
*Fichier généré automatiquement par GitHub Copilot (GPT-4.1) — 11/12/2025*
38