Discussion :

[dapounet]

Bonjour,

Pour un projet que j'aimerais faire en Python, j'ai besoin de manipuler des fichiers binaires. J'ai les entêtes C qui décrivent le format des fichiers, et il faudrait que je les adapte en Python.

Il faut que je puisse facilement :

• Lire un enregistrement dans un fichier,
• Construire moi-même un enregistrement,
• Écrire un enregistrement dans un fichier,
• Afficher le contenu de chaque enregistrement de façon lisible,
• Accéder aux membres des enregistrements.

Avec le module struct ça marche bien, mais je me retrouve avec des tuples géants qui ne veulent rien dire.
Voilà un bête exemple de comment je ferais :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
40
41
42
43
#include <stdio.h>
 
enum
{
  ASTRONAUTE,
  POLITICIEN,
  CHOMEUR
};
 
struct employe
{
  const char nom[32];
  unsigned int salaire;
  int emploi;
};
 
int
main(void)
{ 
  struct employe e = {"Nom", 10000, ASTRONAUTE};
  FILE* p_fichier = NULL;
 
  p_fichier = fopen("test.bin", "wb");
 
  if (p_fichier == NULL)
  {
    perror("fopen()");
  }
  else
  {
    if (fwrite(&e, sizeof e, 1, p_fichier) != 1)
    {
      perror("fwrite()");
    }
 
    if (fclose(p_fichier) != 0)
    {
      perror("fclose()");
    }
  }
 
  return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
40
41
import struct
 
employe = struct.Struct('32sIi')
 
 
class Employe(object):
    noms_emplois = {0: 'astronaute', 1: 'politicien', 2: 'chômeur'}
 
    def __init__(self, raw=None):
        '''Crée une instance d\'Employe.
 
        raw est une chaîne qui contient un enregistrement binaire.
        '''
        if raw == None:
            self.unpacked = (None, None, None)
        else:
            self.unpacked = employe.unpack(raw)
 
        self.nom, self.salaire, self.emploi = self.unpacked
 
    def __str__(self):
        return ('Nom : {0}\nSalaire : {1}\nEmploi : {2}'
                .format(self.nom, self.salaire,
                        Employe.noms_emplois[self.emploi]))
 
    def ecrire(self, fichier):
        fichier.write(employe.pack(self.nom, self.salaire, self.emploi))
 
 
if __name__ == '__main__':
    fichier = open('/home/bastien/info/c/test.bin', 'r+b')
    lu = fichier.read(employe.size)
 
    e = Employe(lu)
    print e
 
    # ecriture de l'enregistement apres l'avoir modifie
    e.nom = 'Test'
    fichier.seek(0)
    e.ecrire(fichier)
    fichier.close()

Comme je débute en Python, j'ai un peu de mal à m'y retrouver et je me demande si il n'y a pas une solution plus pythonique. Est-ce que vous en voyez une ?

Merci.

[kango]

bonsoir,

je ne suis pas sûr d'avoir compris. le fichier binaire tu veux y accéder uniquement depuis python ou aussi depuis C ?

si c'est une solution 100% pythonique que tu souhaites, peut être que Pickle peut répondre à ton besoin:

http://docs.python.org/library/pickle.html

de manière plus générale, si j'ai bien compris ce que tu veux faire, je crois que le terme approprié est "sérialisation" de données.

[DelphiManiac]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Avec le module struct ça marche bien, mais je me retrouve avec des tuples géants qui ne veulent rien dire.

Je ne comprend pas cette remarque. Qu'est ce qui te gène dans le code que tu présentes ?

[dapounet]

Bonjour,

je ne suis pas sûr d'avoir compris. le fichier binaire tu veux y accéder uniquement depuis python ou aussi depuis C ?

Si on veut. Je ne choisis par le format, ce sont des fichiers ELF : http://www.sco.com/developers/gabi/2.../contents.html.

Je ne comprend pas cette remarque. Qu'est ce qui te gène dans le code que tu présentes ?

Je me demande si il n'y a pas un moyen simple pour avoir l'équivalent des structures en C : la même chose que les tuples que j'obtiens avec le module struct mais en pouvant nommer les éléments, et les enums qui représentent les valeurs que peuvent prendre les membres.

[DelphiManiac]

Il n'y a pas à ma connaissance d'équivalent direct du struct C en python.

Par contre, il ne me parait pas très difficile de créer un objet qui stocke tes propriétés et dans lequel tu implémentes 2 méthodes qui savent sérialiser et désérialiser à partir du fichier binaire en utilisant struct de python.

[tamiel]

Perso je fais comme ça pour ce genre de manipulation (un exemple basique ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import struct
 
class employe:
  def __init__(self):
    self.nom = ''
    self.salaire = 0
    self.emploi = 0
 
  def pack(self):
    fmt = "32s1I1i"
    return struct.pack(fmt, self.nom, self.salaire, self.emploi)
 
  @classmethod
  def unpack(cls, binbuff):
    fmt = "32s1I1i"
    nom, salaire, emploi = struct.unpack(fmt, binbuff)
    cls = employe()
    cls.nom = nom
    cls.salaire = salaire
    cls.emploi = emploi
    return cls
 
 
e1 = employe()
e1.nom = 'toto'
e1.salaire = 1500
e1.emploi = 10
bindata = e1.pack()
e2 = employe.unpack(bindata)
print e2.nom
print e2.salaire
print e2.emploi