在 Python 中迭代 CSV 读卡器 object

Question

I have two CSV files, one of which is likely to contain a few more records that the other. I am writing a function to iterate over each and determine which records are in dump but not liar.

My code is as follows:

def update_lib(x, y):
    dump = open(x, newline='')
    libr = open(y, newline='')
    dump_reader = csv.reader(dump)
    for dump_row in dump_reader:
        libr_reader = csv.reader(libr)
        for libr_row in libr_reader:
            if dump_row[0] == libr_row[0]:
                break

I am expecting this to take the first row in dump (dump_row) and iterate over each row in library (libr_row) to see if the first elements match. If they do then I want to move to the next row in dump and if not I will do something else eventually.

My issue is that libr_reader appears to "remember" where it is and I can't get it to go back to the first row in libr, even when the break has been reached and I would therefore expect libr_reader to be re-initiated. I have even tried del libr_row and del libr_reader but this doesn't appear to make a difference. I suspect I am misunderstanding iterators, any help gratefully received.

Answer 1

As it's pasted in your question, you'll be creating a libr_reader object every time you iterate over a row in dump_reader .

dump_reader = csv.reader(dump)
for dump_row in dump_reader:
    libr_reader = csv.reader(libr)

dump_reader here is created once. Assuming there are 10 rows from dump_reader , you will be creating 10 libr_reader instances, all from the same file handle.

Per our discussion in the comments, you're aware of that, but what you're unaware of is that the reader object is working on the same file handle and thus, is still at the same cursor.

Consider this example:

>>> import io
>>> my_file = io.StringIO("""Line 1
... Another Line
... Finally, a third line.""")

This is creating a simulated file object. Now I'll create a "LineReader" class.

>>> class LineReader:
...     def __init__(self, file):
...         self.file = file
...     def show_me_a_line(self):
...         print(self.file.readline())
... 

If I use three line readers on the same file, the file still remembers its place:

>>> line_reader = LineReader(my_file)
>>> line_reader.show_me_a_line()
Line 1

>>> second_line_reader = LineReader(my_file)
>>> second_line_reader.show_me_a_line()
Another Line

>>> third_line_reader = LineReader(my_file)
>>> third_line_reader.show_me_a_line()
Finally, a third line.

To the my_file object, there's no material difference between what I just did, and doing this directly. First, I'll "reset" the file to the beginning by calling seek(0):

>>> my_file.seek(0)
0
>>> my_file.readline()
'Line 1\n'
>>> my_file.readline()
'Another Line\n'
>>> my_file.readline()
'Finally, a third line.'

There you have it.

So TL/DR: Files have cursors and remember where they are. Think of the file handle as a thing that remembers where the file is, yes, but also remembers where in the file your program is.