mjhjmtu

I have this code that reads a file and after processing a few lines writes the output to a second file:

num_reads = 7
with open('data.txt') as read_file:
 with open('new_data.txt', 'w') as write_file:

 while (True):
 lines = 
 try: # expect errors if the number of lines in the file are not a multiplication of num_reads
 for i in range(num_reads): 
 lines.append(next(read_file)) # when the file finishes an exception occurs here

 #do sutff with the lines (exactly num_reads number of lines)
 processed = " ".join(list(map(lambda x: x.replace("n", ''), lines)))
 write_file.write(processed + 'n')

 except StopIteration: # here we process the (possibly) insufficent last lines
 #do stuff with the lines (less that num_reads)
 processed = " ".join(list(map(lambda x: x.replace("n", ''), lines)))
 write_file.write(processed + 'n')
 break

Here is the input file (data.txt):

line1
line2
line3
line4
line5
line7
line8
line9

And this is the output file that has the desired state:

line1 line2 line3 line4 line5 line7
line8 line9

This works correctly but as I wish to do the same processing and writing procedure in both cases (when the number of elements is 7 and when the file finishes and the exception is raised) I think the above code violates DRY principle even if I define a new function and call it once in try block and once in except before break. Any other ordering that I could come up with was either causing an infinite loop or losing the final lines.
I appreciate any comments on handling this issue, as it is not limited to this case and I had faced it in other cases as well.

Disclaimer: This question belongs to Stack Overflow, and I voted to migrate it. Therefore, the answer is not a review.

Keep in mind that principles are there to guide you. They should be treated like guard rails, rather than roadblocks.

I would argue that

 while (....) 
 foo(7);
 
 foo(3);

does not violate DRY. Your situation is pretty much the same.

That said, your idea of defining function is valid. You just factoring out the wrong code. Factor out reading. Consider

 def read_n_lines(infile, n):
 lines = 
 try:
 for _ in range(n):
 lines.append(next(infile))
 except StopIteration:
 pass
 return lines

and use it as

 while True:
 lines = read_n_lines(infile, 7)
 if len(lines) == 0:
 break
 process_lines(lines)

You should avoid writing code with exception-handling altogether. Usually, when you want to write a fancy loop in Python, the itertools module is your friend. In this case, I would take advantage of itertools.groupby() to form groups of lines, assisted by itertools.count() to provide the line numbers.

import itertools

def chunks(iterable, n):
 i = itertools.count()
 for _, group in itertools.groupby(iterable, lambda _: next(i) // n):
 yield group

with open('data.txt') as read_f, open('new_data.txt', 'w') as write_f:
 for group in chunks(read_f, 7):
 print(' '.join(line.rstrip() for line in group), file=write_f)

A few other minor changes:

• You only need one with block to open both files.


• 
  line.rstrip() is more convenient than lambda x: x.replace("n", '')
  


• 
  print(…, file=write_file) is slightly more elegant than write_file.write(… + 'n').