Forum Programmation.python Demande pour que mon code python aille 1 million de fois plus vite car j'ai au moins 4 millions de f

Posté par Lilie3887 le 03 février 2025 à 03:09. Licence CC By‑SA.

Étiquettes :

-9

fév.

2025

Bonjour,
j'aurais besoin d'aide pour que le code ci-dessous aille beaucoup beaucoup plus vite, car j'ai plus de 4 millions de fichier à exécuter avec ce code et si je le laisse tel qu'il est j'en aurais pour au moins une à 2 semaines d'exécution. Alors que je dois l'utiliser toutes les semaines. Le code fais une recherchev par rapport à mon 1er tableau et met les valeurs dans mes fichiers, fais la somme de ma recherchev, supprime les valeurs de ma recherchev et place la ligne ou il y a la somme où il doit être placé.
Ensuite il fait la même chose pour un 2ème tableau et idem pour un 3ème tableau, et pour un 4ème tableau, ça va jusqu'à 10 tableau.
S'il vous plaît, c'est complexe pour moi donc si vous pouvez m'aider. Voici le code:
import os

|| || || |import pandas as pd| |from openpyxl import load_workbook| || |# ???? Définition des chemins| |dossier_source = "D:/PYTHON/VALEUR REMPLACER ZIP"| |fichier_rebase = "D:/PYTHON/REBASE.xlsx"| || |# ???? Chargement des valeurs de REBASE.xlsx| |wb_rebase = load_workbook(fichier_rebase, data_only=True)| |ws_rebase = wb_rebase.active| || |# ???? Extraction des valeurs des Tableaux 1 (A:B), 2 (D:E), 3 (G:H) et 4 (J:K)| |tableau_1 = pd.DataFrame(ws_rebase.iter_rows(min_row=1, max_row=273, min_col=1, max_col=2, values_only=True), columns=["Clé", "Valeur"])| |tableau_2 = pd.DataFrame(ws_rebase.iter_rows(min_row=1, max_row=273, min_col=4, max_col=5, values_only=True), columns=["Clé", "Valeur"])| |tableau_3 = pd.DataFrame(ws_rebase.iter_rows(min_row=1, max_row=273, min_col=7, max_col=8, values_only=True), columns=["Clé", "Valeur"])| |tableau_4 = pd.DataFrame(ws_rebase.iter_rows(min_row=1, max_row=273, min_col=10, max_col=11, values_only=True), columns=["Clé", "Valeur"])| || |# ???? Traitement des fichiers dans le dossier source| |for fichier in os.listdir(dossier_source):| |if fichier.endswith(".xlsx"):| |chemin_fichier = os.path.join(dossier_source, fichier)| || |# ???? Charger le fichier Excel| |wb = load_workbook(chemin_fichier)| |ws = wb.active| || |# ???? Identifier la dernière ligne contenant des données (entre 1 et 19)| |last_data_row = max([i for i in range(1, 20) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))], default=1)| || |### ✅ Étape 1 : Remplacement avec le Tableau 1 (A:B)| |ligne_depart = 21| |if any(ws.cell(row=21, column=j).value for j in range(2, ws.max_column + 1)):| |ligne_depart = max([i for i in range(21, ws.max_row + 1) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))], default=20) + 2 | || |ligne_debut_bloc_1 = ligne_depart| || |# ???? Ajout des valeurs du Tableau 1| |for col in range(2, ws.max_column + 1):| |for row in range(1, last_data_row + 1):| |valeur_originale = ws.cell(row=row, column=col).value| |if valeur_originale:| |valeur_remplacee = tableau_1.loc[tableau_1["Clé"] == valeur_originale, "Valeur"]| |if not valeur_remplacee.empty:| |ws.cell(row=ligne_depart + row - 1, column=col, value=valeur_remplacee.values[0])| || |# ???? Calcul de la somme du Tableau 1| |ligne_somme_1 = ligne_depart + last_data_row + 1| |somme_bloc_1 = [sum(ws.cell(row=row, column=col).value or 0 for row in range(ligne_debut_bloc_1, ligne_somme_1) if isinstance(ws.cell(row=row, column=col).value, (int, float))) for col in range(2, ws.max_column + 1)]| || |# ???? Suppression du bloc 1 et insertion des sommes à la ligne 21| |for row in range(ligne_debut_bloc_1, ligne_somme_1):| |for col in range(2, ws.max_column + 1):| |ws.cell(row=row, column=col, value=None)| |ws.delete_rows(ligne_debut_bloc_1, ligne_somme_1 - ligne_debut_bloc_1)| |ws.insert_rows(21)| |for col_idx, somme in enumerate(somme_bloc_1, start=2):| |ws.cell(row=21, column=col_idx, value=somme)| || |### ✅ Étape 4 : Remplacement avec le Tableau 4 (J:K)| |ligne_depart = max([i for i in range(21, ws.max_row + 1) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))], default=20) + 2 | |ligne_debut_bloc_4 = ligne_depart| || |# ???? Ajout des valeurs du Tableau 4| |for col in range(2, ws.max_column + 1):| |for row in range(1, last_data_row + 1):| |valeur_originale = ws.cell(row=row, column=col).value| |if valeur_originale:| |valeur_remplacee = tableau_4.loc[tableau_4["Clé"] == valeur_originale, "Valeur"]| |if not valeur_remplacee.empty:| |ws.cell(row=ligne_depart + row - 1, column=col, value=valeur_remplacee.values[0])| || |# ???? Calcul de la somme du Tableau 4| |ligne_somme_4 = ligne_depart + last_data_row + 1| |somme_bloc_4 = [sum(ws.cell(row=row, column=col).value or 0 for row in range(ligne_debut_bloc_4, ligne_somme_4) if isinstance(ws.cell(row=row, column=col).value, (int, float))) for col in range(2, ws.max_column + 1)]| || |# ???? Suppression du bloc 4 et insertion des sommes à la ligne 24| |for row in range(ligne_debut_bloc_4, ligne_somme_4):| |for col in range(2, ws.max_column + 1):| |ws.cell(row=row, column=col, value=None)| |ws.delete_rows(ligne_debut_bloc_4, ligne_somme_4 - ligne_debut_bloc_4)| |ws.insert_rows(24)| |for col_idx, somme in enumerate(somme_bloc_4, start=2):| |ws.cell(row=24, column=col_idx, value=somme)| || |wb.save(chemin_fichier)| |print(f"✅ {fichier} mis à jour avec succès.")| || |print("✔ Tous les fichiers ont été traités correctement.")|

# code source python reformaté

Posté par Marc Quinton le 03 février 2025 à 06:49. Évalué à 3 (+2/-1). Dernière modification le 03 février 2025 à 07:52.

    # conversion/reformatage avec ...GPT.
    import os
    import pandas as pd
    from openpyxl import load_workbook

    # Définition des chemins
    dossier_source = "D:/PYTHON/VALEUR REMPLACER ZIP"
    fichier_rebase = "D:/PYTHON/REBASE.xlsx"

    # Chargement des valeurs de REBASE.xlsx
    wb_rebase = load_workbook(fichier_rebase, data_only=True)
    ws_rebase = wb_rebase.active

    # Extraction des valeurs des tableaux
    tableaux = {
        1: pd.DataFrame(
            ws_rebase.iter_rows(min_row=1, max_row=273, min_col=1, max_col=2, values_only=True),
            columns=["Clé", "Valeur"]
        ),
        2: pd.DataFrame(
            ws_rebase.iter_rows(min_row=1, max_row=273, min_col=4, max_col=5, values_only=True),
            columns=["Clé", "Valeur"]
        ),
        3: pd.DataFrame(
            ws_rebase.iter_rows(min_row=1, max_row=273, min_col=7, max_col=8, values_only=True),
            columns=["Clé", "Valeur"]
        ),
        4: pd.DataFrame(
            ws_rebase.iter_rows(min_row=1, max_row=273, min_col=10, max_col=11, values_only=True),
            columns=["Clé", "Valeur"]
        ),
    }

    # Traitement des fichiers dans le dossier source
    for fichier in os.listdir(dossier_source):
        if fichier.endswith(".xlsx"):
            chemin_fichier = os.path.join(dossier_source, fichier)

            # Charger le fichier Excel
            wb = load_workbook(chemin_fichier)
            ws = wb.active

            # Identifier la dernière ligne contenant des données (entre 1 et 19)
            last_data_row = max(
                [i for i in range(1, 20) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))],
                default=1
            )

            # Étape 1 : Remplacement avec le Tableau 1
            ligne_depart = 21
            if any(ws.cell(row=21, column=j).value for j in range(2, ws.max_column + 1)):
                ligne_depart = max(
                    [i for i in range(21, ws.max_row + 1) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))],
                    default=20
                ) + 2

            ligne_debut_bloc_1 = ligne_depart

            # Ajout des valeurs du Tableau 1
            for col in range(2, ws.max_column + 1):
                for row in range(1, last_data_row + 1):
                    valeur_originale = ws.cell(row=row, column=col).value
                    if valeur_originale:
                        valeur_remplacee = tableaux[1].loc[tableaux[1]["Clé"] == valeur_originale, "Valeur"]
                        if not valeur_remplacee.empty:
                            ws.cell(row=ligne_depart + row - 1, column=col, value=valeur_remplacee.values[0])

            # Calcul de la somme du Tableau 1
            ligne_somme_1 = ligne_depart + last_data_row + 1
            somme_bloc_1 = [
                sum(ws.cell(row=row, column=col).value or 0 for row in range(ligne_debut_bloc_1, ligne_somme_1) if isinstance(ws.cell(row=row, column=col).value, (int, float)))
                for col in range(2, ws.max_column + 1)
            ]

            # Suppression du bloc 1 et insertion des sommes à la ligne 21
            ws.delete_rows(ligne_debut_bloc_1, ligne_somme_1 - ligne_debut_bloc_1)
            ws.insert_rows(21)
            for col_idx, somme in enumerate(somme_bloc_1, start=2):
                ws.cell(row=21, column=col_idx, value=somme)

            # Étape 4 : Remplacement avec le Tableau 4
            ligne_depart = max(
                [i for i in range(21, ws.max_row + 1) if any(ws.cell(row=i, column=j).value for j in range(2, ws.max_column + 1))],
                default=20
            ) + 2

            ligne_debut_bloc_4 = ligne_depart

            # Ajout des valeurs du Tableau 4
            for col in range(2, ws.max_column + 1):
                for row in range(1, last_data_row + 1):
                    valeur_originale = ws.cell(row=row, column=col).value
                    if valeur_originale:
                        valeur_remplacee = tableaux[4].loc[tableaux[4]["Clé"] == valeur_originale, "Valeur"]
                        if not valeur_remplacee.empty:
                            ws.cell(row=ligne_depart + row - 1, column=col, value=valeur_remplacee.values[0])

            # Calcul de la somme du Tableau 4
            ligne_somme_4 = ligne_depart + last_data_row + 1
            somme_bloc_4 = [
                sum(ws.cell(row=row, column=col).value or 0 for row in range(ligne_debut_bloc_4, ligne_somme_4) if isinstance(ws.cell(row=row, column=col).value, (int, float)))
                for col in range(2, ws.max_column + 1)
            ]

            # Suppression du bloc 4 et insertion des sommes à la ligne 24
            ws.delete_rows(ligne_debut_bloc_4, ligne_somme_4 - ligne_debut_bloc_4)
            ws.insert_rows(24)
            for col_idx, somme in enumerate(somme_bloc_4, start=2):
                ws.cell(row=24, column=col_idx, value=somme)

            # Sauvegarde du fichier modifié
            wb.save(chemin_fichier)
            print(f"✅ {fichier} mis à jour avec succès.")

    print("✔ Tous les fichiers ont été traités correctement.")

[^] # Re: code source python reformaté

Posté par Benoît Sibaud (site web personnel) le 03 février 2025 à 07:52. Évalué à 4 (+1/-0).

J'ai ajouté la coloration syntaxique.

Répondre
[^] # Re: code source python reformaté

Posté par lolop (site web personnel) le 03 février 2025 à 12:55. Évalué à 6 (+4/-0).

Je ne sais pas ce qu'il a dans son tableau Excel, mais si c'est jouable, ça serait probablement plus rapide d'importer dans un tableau panda, faire toutes les manips dedans, puis exporter vers Excel. Et… s'il n'y a pas de formule dans le document, juste des valeurs, passer de Excel à CSV.

Parce que là je vois beaucoup de manips qui vont aller faire des allers/retours pour récupérer des valeurs dans le doc Excel, et je ne suis pas sûr que ça soit le plus optimal.

Votez les 30 juin et 7 juillet, en connaissance de cause. http://www.pointal.net/VotesDeputesRN

Répondre
- [^] # Re: code source python reformaté
  
  Posté par steph1978 le 24 février 2025 à 10:26. Évalué à 2 (+0/-0).
  
  je ne suis pas sûr que ça soit le plus optimal.
  
  Le mieux dans ce cas est de profiler le code pour voir où ça coince.
  
  Répondre

# C'est à dire...

Posté par Graveen le 03 février 2025 à 09:57. Évalué à 10 (+8/-0). Dernière modification le 03 février 2025 à 09:58.

… tu veux un devis ? :D :D

Répondre
- [^] # Re: C'est à dire...
  
  Posté par arnaudus le 03 février 2025 à 10:22. Évalué à 6 (+3/-0).
  
  Tu te sens de faire un devis pour accélérer un algo par un facteur 10^6? :-)
  
  Répondre
  - [^] # Re: C'est à dire...
    
    Posté par fearan le 03 février 2025 à 10:54. Évalué à 4 (+1/-0).
    Vu que c'est du python traitant du excel, en single thread, y'a moyen de décompresser le excel, travailler en sax, et faire du multithread; je suppose qu'il y'a un chargement des fichiers complet en mémoire avant de travailler
```
cell["plip"]["plop"]
```
    ensuite une fois le fichier ouvert appliquer toutes les transformations, avant de l'écrire ; je pense qu'il est facile de gagner un facteur 10, ce qui est suffisant au niveau du besoin, lancer un traitement toutes les semaines, alors qu'il en prends 2, pour plus de sécurité, je répondrais par une amélioration d'un facteur 7.
    
    ensuite ça risque d'être du c++ ou du java, ce sera plus cher en python car c'est un langage ~~de merde~~ que je n'apprécie pas.
    
    Et avoir une véritable expression du besoin plutôt que le résultat en python fera aussi partie de la question.
    
    Il ne faut pas décorner les boeufs avant d'avoir semé le vent
    Répondre
    - [^] # Re: C'est à dire...
      
      Posté par Sacha Trémoureux (site web personnel) le 03 février 2025 à 10:59. Évalué à 5 (+4/-0).
      
      Merci pour ton expertise, j’envoie tout ça au client.
      
      Rappelle moi ton TJM ? Ça te dérange qu’on envoie notre junior sorti d’école à la place ?
      
      Répondre
      - [^] # Re: C'est à dire...
        
        Posté par Maclag le 04 février 2025 à 16:45. Évalué à 9 (+6/-0).
        
        Rappelle moi ton TJM ? Ça te dérange qu’on envoie notre junior sorti d’école à la place ?
        
        Amateur! Grâce à notre gestion optimale des coûts au bénéfice de nos clients, nos stagiaires abaissent le coût pour nos clients tout en nous permettant de dégager des marges suffisantes pour une relation pérenne entre nos 2 organisations.
        
        Ah zut, j'ai écrit stagiaire? Je voulais bien entendu parler de nos collaborateurs!
        
        Répondre
  - [^] # Re: C'est à dire...
    
    Posté par steph1978 le 24 février 2025 à 15:24. Évalué à 2 (+0/-0).
    
    Tu te sens de faire un devis pour accélérer un algo par un facteur 1E6 ?
    
    oh que oui.
    sachant que 2 semaines c'est 2*168=336 heures.
    Si on accélère de 1E3, on passe à 20 min => client content.
    
    Par contre je mettrai les œillères sur comment on en est arrivé à avoir un système qui produit 4M de fichiers, patche ces fichiers 1 à 1 et probablement les retraite plus tard (car clairement, à ce stade, le système ne sert à rien, il y a forcément des étapes après).
    
    Répondre
# Moi je découperais le travail

Posté par gUI (Mastodon) le 03 février 2025 à 23:59. Évalué à 9 (+6/-0). Dernière modification le 03 février 2025 à 23:59.
Bon j'ai lu vite fait mais il me semble que je ferais 3 scripts python distincts :
- un 1er script qui bouffe le Excel et mets tout ça dans une BdD
- un 2e script qui interroge la BdD et fait les modifs nécessaires (et là tu auras ton facteur 10, 100 ou même 1000)
- un 3e script qui spamme jusqu'à ce que mort s'en suive le criminel qui a conçu cette horreur
En théorie, la théorie et la pratique c'est pareil. En pratique c'est pas vrai.
Répondre
- [^] # Re: Moi je découperais le travail
  
  Posté par Elfir3 le 04 février 2025 à 11:44. Évalué à 2 (+0/-0).
  
  Un peu de respect svp, Guido Van Rossum purge déjà sa peine.
  
  Répondre
  - [^] # Re: Moi je découperais le travail
    
    Posté par gUI (Mastodon) le 04 février 2025 à 18:15. Évalué à 4 (+1/-0). Dernière modification le 04 février 2025 à 18:16.
    
    Pour moi le scandale ne réside pas spécialement dans l'utilisation de Python. Le scandale c'est déjà d'avoir imaginé un système qui génère 4 millions de fichiers (non mais pourquoi des fichiers ???), et au format Excel qui plus est (et pourquoi pas les imprimer, les faxer, et ensuite les faire passer par OCR pour les relire ?).
    
    Vraiment, utiliser Python ou autre chose pour traiter ce gros tas d'immondice, c'est du détail.
    
    En théorie, la théorie et la pratique c'est pareil. En pratique c'est pas vrai.
    
    Répondre
    - [^] # Re: Moi je découperais le travail
      
      Posté par Elfir3 le 04 février 2025 à 18:36. Évalué à 2 (+0/-0).
      
      C'était bien entendu du second degré..
      
      Répondre
    - [^] # Re: Moi je découperais le travail
      
      Posté par cg le 06 février 2025 à 21:26. Évalué à 4 (+2/-0).
      
      et pourquoi pas les imprimer, les faxer, et ensuite les faire passer par OCR pour les relire ?
      
      S'il voulait 1 million de fois plus lent, l'idée se défend ;).
      De mémoire, l'expérience faite pour le réseau par pigeon (RFC1149) permettait d'attendre ces sommets.
      
      Répondre
# C facile

Posté par harlock974 le 04 février 2025 à 07:49. Évalué à -1 (+1/-3).

Facile, réécrit le programme en C :

https://peter-jp-xie.medium.com/how-slow-is-python-compared-to-c-3795071ce82a

Répondre
- [^] # Re: C facile
  
  Posté par Nicolas le 04 février 2025 à 08:12. Évalué à 3 (+2/-0).
  
  L'exemple est claqué au sol. Je vérifierai chez moi ce soir mais à peu près certain que le compilo optimise en supprimant purement et simplement la boucle.
  
  Répondre
  - [^] # Re: C facile
    
    Posté par Nicolas le 04 février 2025 à 21:05. Évalué à 4 (+3/-0). Dernière modification le 04 février 2025 à 21:08.
    Voilà, flemme d’expliquer parce que je suis un peu rouillé :
    
    gcc -masm=intel -O2 -S a.c
    
    Un code sans boucle :
```
        call    strtol@PLT
        xor     edx, edx
        mov     edi, 1
        lea     rsi, .LC0[rip]
        test    eax, eax
        cmovns  edx, eax
        xor     eax, eax
        call    __printf_chk@PLT
```
    VERSUS
    
    gcc -masm=intel -S a.c
    
    Un code avec boucle (jmp est l’instruction de saut pour initier la boucle et jl est l’instruction de saut tant que la boucle continue)
```
⇀       jmp⇀    .L2
.L3:
⇀       add⇀    DWORD PTR -8[rbp], 1
⇀       add⇀    DWORD PTR -4[rbp], 1
.L2:
⇀       mov⇀    eax, DWORD PTR -4[rbp]
⇀       cmp⇀    eax, DWORD PTR -12[rbp]
⇀       jl⇀     .L3
```
    En Python, tu ne vas pas écrire ton code comme tu l’écris en C. Tu va faire plutôt un truc du genre (pas testé, j’ai la flemme) :
```
import numpy
a = numpy.ones(NUMBER, numpy.int32)
s = numpy.sum(a)
```
    T’auras à peu de chose prêt les perf. du C. À fortiori.
    Répondre
# data driven

Posté par steph1978 le 23 février 2025 à 16:17. Évalué à 2 (+0/-0).

Pour ce genre de tâche le code du programme importe moins que les données elles même. Sans les données d'entrée, difficile de travailler sur une optimisation…

Répondre

Envoyer un commentaire

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.