Analyse numérique par programmation

Programmation v. feuilles de calculs

Apprendre à programmer pour l'analyse numérique, si vous effectuez habituellement les analyses complexes .

Aujourd'hui, on ne peut pas éviter de parler de nombres, surtout dans le monde du travail. Nombre de personnel, horaires travaillé, taux de non-qualité, dépense variable, prix d'achat, chiffres d'affaire, ce monde est fortement quantifié.

Il est donc logique que autant des gens ont besoin de collecter, organiser, et analyser des nombres. Il y avais quelques parts, tous cet processus sont fait sur papier : dans les tableaux physiques, comme ceci :

Aujourd'hui, la révolution informatique voit l'apparition des tableaux électronique, alternativement appelé les feuilles de calculs. Les logiciels pour leur manipuler sont nombreux : pour nommer quelques, Microsoft Excel, LibreOffice de The Document Foundation, Google Spreadsheets ... N'importe le logiciel, le principe de base reste plus ou moins le même avec les tableaux physiques : Les données sont noté en lignes et colonnes, et chaque nombre peut-être référencé par le numéro de ligne et le numéro de colonne.

La différence, c'est que les logiciels proposent aussi les analyse numérique : Les moyennes, modes, et nombreux plus indicateurs mathématiques sont au rendez-vous avec quelques clics, ou tapes, si on connaît les bonne formules.

Ces formules sont si pratique que les logiciels de feuille de calcul sont devenu incontournable dans le monde de travail. La compétence avec des feuilles de calculs sont habituellement recherché par l'entreprise, qu'il y a tellement nombreux des tutoriels, cours, voire certifications pour eux. C'est-à-dire, les gens dépensent les balles pour l'apprendre et pour attester leurs compétences.

Je ne suis pas contre les feuilles de calculs. Les tableaux sont un format très ancien pour noter les données, et ça sers bien. Et les formules sont les bonus très utiles. Pour les analyses simples, comme trouver les moyennes, il ne faut que quelques clics. Je confesse je les utilise beaucoup, partiellement par obligation, comme mes collègues ne cessent pas à m'envoyer et me solliciter les feuilles.

Cependant, après avoir leur utilisé pour des années, je suis certaine que pour les analyses plus complexes qu'un simple moyenne ou mode, il est autant plus lisible, fiable et efficace d'utiliser une scripte de programmation que les formules dans LibreOffice Calculs ou Excel.

Dès qu'il y a plusieurs étapes de calculs avec différent catégories de données, les feuilles de calculs devient déroutant.

Par exemple, ici je suis en traîne de faire une analyse de taux de rendement. Ne vous inquiétez pas si vous avez aucune idée le «taux de rendement» veut dire quoi. Ce n'est pas mon point. Le point, c'est quand on a une volume important de calculs à faire, on n'arrive pas jamais à poser les cellules de formules à côte de tous les cellules de données concerné. Ici, en C18, j'ai référé à B18 et D9. Parfois, on doit même référé aux valeurs dans une autre feuilles (e.g., l'analyse de changement historique).

Comme les valeurs en feuilles de calculs sont référé par les numéro de colonnes et lignes (A15,B123, etc.), la formule C18 =B18-D9 elle-même n'est pas si informative. Pour comprendre et vérifier l'exactitude de cette formule, on a besoin de trouver la cellule B18 et D9. B18 est facile à trouver comme il est juste à côté, mais D9 demande un peu de recherche. Avec l'habitude, c'est assez rapide : mais imaginons, pour une cellules dans une autre feuille, voire un autre fichiers, est-ce que ça convient encore dès on a développé l'habitude ? Je ne le croie pas. Surtout pas quand il y a 4-5 termes dans la formule, au lieu de juste 2 .

Dès qu'il y a pas mal de données et pas mal des étapes de calculs , les formules deviennent difficile à comprendre et vérifier. On comprend rien en lisant les formules eux-même : il faut qu'on tracer tous les cellules des données référencé, qui ne peuvent pas toujours être placé dans la proximité des formules. Les erreurs donc ne sont pas toujours identifié.

En revanche, en analyse par programmation, il n'y a pas un adresse géographique pour ni formules ni données. Chaque plage de donné est nommé pendant importation, et chaque quantité calculé est nommé pendant création. Donc au lieu des formules peu informative comme C18=B19-D9 , on a plutôt des formules lisible et claire comme total_time= total_time-total_stop_time :

from odf.opendocument import load
from odf.table import Table, TableRow, TableCell
from odf.text import P

# Path to the ODS file
ods_path = 'tableur_modele_calcul_TRG.ods'
# Sheet name
sheet_name = 'Usine1DoNald TruMp'

# Helper functions to extract cell value
def get_cell_value(cell):
	text_content = ''
	for p in cell.getElementsByType(P):
		text_content += str(p)
	return text_content.replace('<text:p>', '').replace('</text:p>', '').strip()

def expand_repeated_cells(cells):
	expanded = []
	for cell in cells:
		repeat = int(cell.getAttribute('numbercolumnsrepeated') or 1)
		expanded.extend([cell] * repeat)
	return expanded

# Load ODS file
doc = load(ods_path)
sheet = None
for t in doc.spreadsheet.getElementsByType(Table):
	if t.getAttribute('name') == sheet_name:
		sheet = t
		break
if sheet is None:
	raise ValueError(f"Sheet '{sheet_name}' not found in {ods_path}")

# ODS rows are 0-indexed, B4 is col=1,row=3, B8 is col=1,row=7, C4 is col=2,row=3, C8 is col=2,row=7
rows = sheet.getElementsByType(TableRow)

# Get B18 (col=1, row=17)
b18_row = rows[17]
b18_cells = b18_row.getElementsByType(TableCell)
expanded_b18_cells = expand_repeated_cells(b18_cells)
total_time = get_cell_value(expanded_b18_cells[1])

# stops is now a list of dictionaries with keys 'frequency' and 'duration of stop'
stops = []
for row_idx in range(3, 8):  # 3 to 7 inclusive
	row = rows[row_idx]
	cells = row.getElementsByType(TableCell)
	expanded_cells = expand_repeated_cells(cells)
	b_val = get_cell_value(expanded_cells[1])  # B col
	c_val = get_cell_value(expanded_cells[2])  # C col
	stops.append({'frequency': b_val, 'duration of stop': c_val})

print(stops)

def gross_function_time(total_time, stops: dict):
	# Placeholder function, implement your logic here if needed
    return float(total_time) - sum(float(stop['frequency']) * float(stop['duration of stop']) for stop in stops)

print('temps de fonctionnement brut=', gross_function_time(total_time, stops))
	

Bien qu'on peut aussi améliorer la lisibilité des formules en restant en feuilles de calculs par nommer tous les plages de données. , ça prend autant d'effort que programmer à la main et n'offre pas la même flexibilité en comparaison avec les listes et dictionnaires dans les langues de programmation comme Python, qui offre la possibilité d'organiser les données comme ça convient mieux pour une analyse particulière.

En plus, l'analyse par programmation est plus fiable à cause de son explicitation.

En feuilles de calculs, la réutilisation des formules sont couramment réaliser par cliquer-glisser : on saisie une fois, puis généralise la formule. Ceci est une source habituel d'erreur, comme il s'agit de pratiquement laisser la machine deviner l'intention d'utilisateur, avec un contexte limité. Bien que une rapide vérification peut identifier la plupart des problèmes, ceci n'est pas toujours effectivement pratiqué, surtout en précipitation.

En programmation, au contraire, on est obligé de spécifier chaque étape de calculs de manière explicite. C'est-à-dire, il y a pas beaucoup d'espace pour l'erreur par supposition.

Cette explication aussi assurer qu'on peut adapter un processus d'analyse sur plusieurs feuilles similaire organisé de manière différent ( souvent le cas en agglomération de donnée cars personne ne se met jamais en accord).

La cerise sur le gâteau de l'analyse par programmation est la capacité d'intégrer IA. Bien que il est aussi possible d'utiliser IA pour les feuilles de calculs, la capacité d'IA en la compréhension, la génération, et la modification des code de programmation sont significativement plus avancé que pour des feuilles de calculs, grâce à la lisibilité et l'explicitation des code. Aujourd'hui, il est même possible de demander les assistant IA de spécialisé en programmation, comme GitHub Copilot, d'écrire les scriptes entière pour les analyses numériques. L'analyse par programmation est donc facile comme jamais.

Dans les prochaine articles, nous allons explorer ensemble les méthodes de base pour l'analyse numérique par programmation, en utilisant python, une langue de programmation d'haut niveau (High-level programming language, c'est-à-dire une langue de programmation proche à la langue humain).