Comment réparer un programme de fenêtre glissante qui ne place pas de données dans toutes les fenêtres?

Question

Remarque: Le générateur fonctionne définitivement. Ce n'est pas le problème.

Je traite un grand fichier texte contenant les décimales de pi qui a ce format. Notez que l'en-tête est tous les nombres et n'a pas de chaîne.

Format d'en-tête: Number_of_sequences Total_Pi_Digits File_Version_Number

550 10000 5 

*Pi Sequence Part 1 
1415926535897932384 
*Pi Sequence Part 2 
6264338327950288419 
*Pi Sequence Part 3 
1693993751058209749 

Je dois faire une fenêtre glissante que les cultures le fichier en utilisant trois arguments (window_size, step_size et last_windowstart). last_windowstart est l'endroit où commence la dernière fenêtre.

Le nombre de fichiers est déterminé en divisant les Total_Pi_Digits par la fenêtre.

Si le fichier avait 99 Total_Pi_Digits, window_size de 10, et un step_size de zéro, il y aurait un total de 11 fenêtres depuis 99 // 10 = 10 et 99% 10 feuilles 9 dans la fenêtre 11.

lastwindow_start devrait être 90 je suppose que pour cet exemple. Je ne suis pas sûr que j'ai besoin de commencer last_window.

Pour chaque fenêtre, un fichier sera créé avec le nom PiSubsection # où # est le numéro de fenêtre.

Pour chaque fichier, chaque fenêtre doit avoir le même en-tête où Number_of_sequences Total_Pi_Digits File_Version_Number est le format d'en-tête.

Number_of_sequences Total_Pi_Digits changera en fonction de window_size et step_size mais File_Version_Number ne doit pas changer.

Mon problème est que mon programme ne remplit pas toutes les fenêtres avec des chiffres de Pi. Tous les fichiers après la fenêtre 7 ont seulement l'en-tête et aucun chiffre de pi. Ainsi, seule la moitié du fichier texte est placée dans les fenêtres.

Le problème est lié à la façon dont islice prend windows [0] et windows [1]. Pour une raison quelconque, les fenêtres d'islice [0] et les fenêtres [1] diffèrent des fenêtres [0] et des fenêtres [1] produites par mon générateur.

Pourquoi les fenêtres islice [0] et windows [1] sont-elles différentes des fenêtres [0] et des fenêtres [1] produites par mon générateur? Comment puis-je réparer ça?

inputFileName = "sample.txt" 

import itertools 
import linecache 

def sliding_window(windows_size, step_size, lastwindow_start): 
    for i in xrange(0, lastwindow_start, step_size): 
     yield (i, i + windows_size) 

def PiCrop(windows_size, step_size): 

    f = open(inputFileName, 'r') 
    first_line = f.readline().split() 

    Total_Pi_Digits = int(first_line[0]) 

    lastwindow_start = Total_Pi_Digits-(Total_Pi_Digits%windows_size) 

    lastcounter = (Total_Pi_Digits//windows_size)*(windows_size/step_size) 

    flags = [False for i in range(lastcounter)] 

    first_line[0] = str(windows_size) 

    second_line = f.readline().split() 

    offset = int(round(float(second_line[0].strip('\n')))) 

    first_line = " ".join(first_line) 

    f. close() 

    with open(inputFileName, 'r') as input: 
     for line in input: 
      for counter, window in enumerate(sliding_window(windows_size,step_size,lastwindow_start)): 
       with open('PiSubsection_{}.txt'.format(counter), 'w+') as output: 
        if (flags[counter] == False): 
         flags[counter] = True 
         headerline = float(linecache.getline(inputFileName, window[1]+1)) - offset 
         output.write(str(windows_size) + " " + str(headerline) + " " + 'L' + '\n') 

        for xline in itertools.islice(input, window[0], window[1], None): 
         newline = str("{0:.4f}".format(float(xline.strip('\n'))-offset)) 
         output.write(str(newline) + '\n') 
         input 

Answer 1

J'ai travaillé sur le problème pendant quelques heures. Avec l'aide de quelques amis, j'ai décidé de stocker le fichier texte dans la mémoire sous forme de liste géante et d'utiliser pour les boucles avec des morceaux de fenêtre [0]: window [1] au lieu de islice.

La suppression d'islice a résolu le problème.

inputFileName = "sample.txt" 

import itertools 
import linecache 

def sliding_window(window_size, step_size, lastwindow_start): 
    for i in xrange(0, lastwindow_start, step_size): 
     yield (i, i + window_size) 

def PiCrop(window_size, step_size): 

f = open(inputFileName, 'r') 

first_line = f.readline().split() 

Total_Pi_Digits = int(first_line[0]) 

lastwindow_start = Total_Pi_Digits-(Total_Pi_Digits%window_size) 

lastcounter = (Total_Pi_Digits//window_size)*(window_size/step_size) 

flags = [False for i in range(lastcounter)] 

first_line[0] = str(window_size) 
second_line = f.readline().split() 
offset = int(round(float(second_line[0].strip('\n')))) 
first_line = " ".join(first_line) 

f. close() 

with open(inputFileName, 'r') as f: 
    header = f.readline() 
    data = [line.strip().split(',') for line in f.readlines()] 

    for counter, window in enumerate(sliding_window(window_size,step_size,lastwindow_start)): 
     chunk = data[window[0]:window[1]] 

     with open('PiCrop_{}.txt'.format(counter), 'w') as output: 

      if (flags[counter] == False): 
       flags[counter] = True 

       headerline = float(linecache.getline(inputFileName, window[1]+1)) - offset 
       output.write(str(window_size) + " " + str("{0:.4f}".format(headerline)) + " " + 'L' + '\n') 

      for item in chunk: 
       newline = str("{0:.4f}".format(float(str(item).translate(None, "[]'"))-offset)) 
       output.write(str(newline) + '\n') 

PiCrop(1000,500)