linux "plus" comme du code en python pour de très grands enregistrements tuple/fichier/db/numpy.darray?

Question

Je suis à la recherche d'un code tampon pour traiter d'énormes enregistrements dans le fichier tuple/csv/sqlite enregistrements db/numpy.darray, le tampon peut tout comme la commande linux "more".

La demande est venu de traiter d'énormes enregistrements de données (100.000.000 lignes peut-être), les enregistrements peuvent ressembler à ceci:

0.12313 0.231312 0.23123 0.152432 
0.22569 0.311312 0.54549 0.224654 
0.33326 0.654685 0.67968 0.168749 
... 
0.42315 0.574575 0.68646 0.689596 

Je veux les traiter numpy.darray. Par exemple, trouvez des données spéciales, traitez-les et stockez-les, ou traitez 2 colonnes. Cependant, il est trop grand alors si numpy lire le fichier directement, il me donnera une erreur de mémoire. Ensuite, je pense qu'un adaptateur comme la page mem cache ou la commande linux "more file" peut sauvegarder la mémoire lors du traitement. Parce que ces données brutes peuvent présenter un format différent - csv/sqlite_db/hdf5/xml. Je veux que cet adaptateur soit plus normalisé, alors, utilisez le "[]" comme une "rangée" peut être un moyen plus commun car je pense que chaque enregistrement peut être représenté comme un [].

donc l'adaptateur ce que je veux peut ressemble à ceci:

fd = "a opend big file" # or a tuple of objects, whatever, it is an iterable object can access all the raw rows 

page = pager(fd) 

page.page_buffer_size = 100 # buffer 100 line or 100 object in tuple 

page.seek_to(0)  # move to start 
page.seek_to(120)  # move to line #120 
page.seek_to(-10)  # seek back to #120 

page.next_page()   
page.prev_page() 

page1 = page.copy() 

page.remove(0) 

page.sync() 

que quelqu'un peut me montrer quelques conseils pour éviter de réinventer la roue? A propos, ATpy, http://atpy.sourceforge.net/ est un module qui peut synchroniser le numpy.array avec une source de données brute dans un format différent, mais il lit aussi toutes les données en mémoire.

Et le pytable ne me convient pas pour l'instant car SQL n'est pas supporté par lui et le fichier HDF5 peut ne pas être aussi populaire que sqlite db (pardonnez moi si c'est faux).

My plan is write this tools in this way: 
    1. helper.py  <-- define all the house-keeping works for different file format 
          |- load_file() 
          |- seek_backword()  
          |- seek_forward() 
          | ... 
    2. adapter.py  <-- define all the interface and import the helper to interact 
          with raw data and get a way to interact with numpy.darray in somehow. 
          |- load() 
          |- seek_to() 
          |- next_page() 
          |- prev_page() 
          |- sync() 
          |- self.page_buffer_size 
          |- self.abs_index_in_raw_for_this_page = [] 
          |- self.index_for_this_page = [] 
          |- self.buffered_rows = [] 

Merci,

RBP,

KC

Answer 1

Ummmm .... Vous ne parlez pas vraiment de quelque chose de plus qu'une liste.

fd = open("some file", "r") 
data = fd.readlines() 

page_size = 100 

data[0:0+page_size] # move to start 
data[120:120+page_size] # move to line 120 
here= 120 
data[here-10:here-10+page_size] # move back 10 from here 
here -= 10 
data[here:here+page_size] 
here += page_size 
data[here:here+page_size] 

Je ne suis pas sûr que vous ayez réellement besoin d'inventer quoi que ce soit.

Answer 2

Le module linecache peut être utile - vous pouvez appeler getline(filename, lineno) pour récupérer efficacement les lignes du fichier donné.

Vous devrez toujours déterminer la hauteur et la largeur de l'écran. Un googlance rapide suggère qu'il y a environ 14 façons différentes de le faire, dont certaines sont probablement périmées. Le module curses peut être votre meilleur pari, et je pense que ce sera nécessaire si vous voulez être en mesure de faire défiler vers l'arrière en douceur.