Lecture d'un fichier : appel / sans à un module

Version imprimable

Bonjour

Je tente d'effectuer la lecture d'un fichier binaire de 2 façons différentes. A première vue les 2 méthodes semblent identiques mais j'ai un rapport 3 en terme de délai de traitement. Je n'arrive vraiment pas à comprendre d'où vient le problème. C'est vrai aussi que je débute en Python.
Je suis en version 3.7.3

Voici le programme principal :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import time
import binarystream
import struct
 
fn = "C:/toto.bin"
 
# Ouverture du fichier
with open(fn, "rb") as file_p:
 
    # Methode 1
    file_p.seek(0)
    tmStart = time.time()
 
    index = 0
    ar = file_p.read()
 
    while index < len (ar):
 
        value = ar[index:index + 4]
        index = index + 4
        val = int.from_bytes (value, byteorder='big', signed=True)
 
    deltat = time.time() - tmStart
    print("Methode 1 : {:f}".format(deltat))
    # Fin Methode 1
 
    # Methode 2
    file_p.seek(0) 
    tmStart = time.time()
 
    ar = binarystream.BinaryStream(file_p)
 
    while ar.index < len(ar.ar):
 
        value = ar.read_int32()
 
    deltat = time.time() - tmStart
    print("Methode 2 : {:f}".format(deltat))
    # Fin Methode 2

le module binarystream

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import struct
 
class BinaryStream:
 
    def __init__(self, file):
        self.index = 0
        self.ar= file.read()
 
    def read_int32(self):
 
        value = self.ar[self.index:self.index + 4]
        self.index = self.index + 4
        val = int.from_bytes (value, byteorder='big', signed=True)
 
        return val

J'ai l'impression que les 2 méthodes sont identiques mais pour un fichier de 25Mo :
Méthode 1 : 7s
Méthode 2 : 21s

Mon erreur est certainement évidente mais rien à faire, je ne vois pas...

Merci

26/05/2019, 20h24
Sve@r
Bonjour

Moi, sur un fichier de 87M:
- Methode 1 : 24.814853
- Methode 2 : 31.165576
Maintenant, peut-être que pour faire un vrai test de benchmark il faudrait avoir deux programmes totalement indépendants. Parce que là, le fichier est d'abord lu (donc avec les méthodes de bufferisations il est alors chargé en mémoire) puis tu te replaces au début pour le relire => il y a fort à parier que l'OS va lire le buffer, pas le disque. Et en plus tu as un module "timeit" permettant de faire ce genre de tests (il te répère n fois la même fonction en la chronométrant puis te donne la moyenne des temps d'exécution => t'as même plus à t'embêter avec tes time).

Sinon en effet tes deux codes sont équivalents (ils font les mêmes opérations).
26/05/2019, 21h03
wiztricks
Salut,

Citation:

Envoyé par bobby40600

Mon erreur est certainement évidente mais rien à faire, je ne vois pas...

Comparez le cœur du bousin:
Code:

1 2 3 4 5 while index < len (ar): value = ar[index:index + 4] index = index + 4 val = int.from_bytes (value, byteorder='big', signed=True)
avec:
Code:

1 2 3 while ar.index < len(ar.ar): value = ar.read_int32()
où:
Code:

1 2 3 value = self.ar[self.index:self.index + 4] self.index = self.index + 4 val = int.from_bytes (value, byteorder='big', signed=True)
Les appels de fonctions coûtent...
Les indirections (ar.index, ar.ar, self.ar, self.index)... coûtent.

Et quand je dis "coûtent", c'est qu'il faut exécuter plus d'instructions, et donc bouffer plus de CPU et attendre plus longtemps la sortie du résultat.

- W