Discussion :

[shaiHulud]

Bonjour,

Comment puis-je envoyer des floats dans un fichier binaire en python ? Comment puis-je ensuite les récupérer ?

Je souhaite garder le fichier ouvert et les ajouter un par un ou 2 par 2, et je cherche une solution performante.

Merci d'avance

[stalacta]

Du côté du module pickle il y a moyen de faire quelque chose, on peut envoyer plein d'objets dans un fichier :

Code :

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

1
2
3
4
5
6
7
8
9
10
import pickle
 
#Pour variable vers fichier :
with open('monfichier.extension','wb') as f :
    p=pickle.Pickler(f)
    p.dump(variable)
#Pour fichier vers variable :
with open('monfichier.extension','rb') as f :
    p=pickle.Unpickler(f)
    variable=p.load()

Sinon c'est possible de passer par des str.

[wiztricks]

Salut,

Un float (binaire) est représenté par une suite de 4 ou 8 bytes.
Pour transformer un float (object) en bytes, le module struct apporte les fonctions pack et unpack.
La rapidité dépendra du file system cache de l'OS.

- W

[shaiHulud]

Merci pour votre aide.

Une dernière question, j'essaye d'utiliser pack_into avec un fichier, mais sans succès.
- Est ce que pack_into(...) serait plus performant que file.write(pack(...)) ?
- Comment puis obtenir à partir d'un fichier le second argument à passer à pack_into ?
pack_into lève une TypeError: expected a writeable buffer object lorsque je lui fournit pour second argument open(r'C:\Programs\text.bin','wb'), io.open(r'C:\Programs\text.bin','wb') ou encore io.FileIO(r'C:\Programs\text.bin','wb').

J'ai croisé une solution avec memoryview, mais je suis encore en Py2.6. Comment puis-je procéder ?

[wiztricks]

Une dernière question, j'essaye d'utiliser pack_into avec un fichier, mais sans succès.

Si vous ne postez pas de code, vous n'aurez que vos mouchoirs...

J'ai croisé une solution avec memoryview, mais je suis encore en Py2.6. Comment puis-je procéder ?

Postez l'URL pour qu'on voit a quoi ça ressemble.

- W
PS: pack_into, c'est pour une version mmap i.e. il faut un truc entre le "fichier" et les objets qui sera une structure semblable a un array du module array: la mmap. Pas besoin de memory view a priori.

[shaiHulud]

J'ai enfin un code qui a l'air de marcher, mais qui me pose encore des problèmes ...

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
 
import struct, mmap
def test_struct():
    """ Envoie 2 floats dans un binaire, puis les lis"""
    with open(r'C:\Programs\text.bin','w+b') as f :        
        f.flush() #inutile si non bufferisé
        m=mmap.mmap(f.fileno(),256,"w+b")        
        fmt= 'd'        
        struct.pack_into(fmt, m,0, 1.11)
        struct.pack_into(fmt, m,8, 2.222)    
        m.close()
    with open(r'C:\Programs\text.bin','r+b') as f :
        m=mmap.mmap(f.fileno(),256,'r+b')   
        print struct.unpack_from(fmt,m)
        print struct.unpack_from(fmt,m,8)
        m.close()

Est-ce la bonne manière de procéder ? C'est bien à moi d'ajuster les offsets à la main selon ce que j'ai déjà parcouru ?

Comment dois-je procéder si je ne connais pas la taille du fichier à l'avance ? Catcher une IOError et créer un nouveau mmap ?

Puis-je utiliser unpack(f.readline()) à la place de unpack_from() (sachant que j'ai utilisé pack_into et non pack) ?

[wiztricks]

Est-ce la bonne manière de procéder?

Pour l'instant, c'est juste un test des fonctionnalités a utiliser "pour" la réalisation particulière.

Pour le reste, je vois surtout un reader qui a une méthode .next et un writer qui a une méthode .append et un constructeur qui récupère un identifiant de type str.

C'est bien assez pour définir une interface et l'utiliser comme abstraction pour construire le programme qui en dépendra, l'utilisera.
C'est ce qu'en fera le programme qui dira s'il faut ajouter des primitives a cette interface et comment la réaliser concrètement.

Imaginez que dans un premier temps la réalisation soit construite avec de simples listes Python. On pourrait les lire et les écrire "one-shot" au lancement et a la sortie avec une mécanique de sérialisation quelconque.
Ce sera "good enough" pour gérer quelques centaines de float et tester les fonctionnalités de bases du programme.
Comme il n'y a pas d’accès disque (autre que la pagination) "pendant" les .append et les .next, difficile de faire mieux cote "perf".

Ce n'est qu’après avoir stabilise le fonctionnel du programme qu'on pourra décider "avec quoi" réaliser cette fonctionnalité pour de bon.
Peut être qu'une écriture au fil de l'eau sera suffisante, peut être pas...
Dans ce cas, vous aurez une motivation fondée pour apprendre a utiliser mmap, des threads ou autre technique de buffering.

- W