Wie lese ich zwei Zeilen aus einer Datei gleichzeitig mit Python

Ähnliche Frage hier. Sie können nicht mischen-iteration und readline, so müssen Sie eins oder das andere.

while True:
    line1 = f.readline()
    line2 = f.readline()
    if not line2: break  # EOF
    ...

InformationsquelleAutor der Antwort robince

verwenden Sie line.next(), eg

f=open("file")
for line in f:
    print line
    nextline=f.next()
    print "next line", nextline
    ....
f.close()

InformationsquelleAutor der Antwort ghostdog74

Arbeitet für gerade und ungerade-Länge-Dateien. Es ignoriert die unübertroffene letzten Zeile.

f=file("file")

lines = f.readlines()
for even, odd in zip(lines[0::2], lines[1::2]):
    print "even : ", even
    print "odd : ", odd
    print "end cycle"
f.close()

Wenn Sie große Dateien, ist dies nicht der richtige Ansatz. Sie laden die Datei in den Speicher mit readlines(). Ich schrieb einmal eine Klasse, Lesen Sie die Datei speichern der fseek-position von jedem Zeilenanfang. Dies ermöglicht Ihnen, bestimmte Zeilen, ohne dass alle die Datei in den Speicher, und Sie können auch vorwärts und rückwärts gehen.

Ich füge es hier. Lizenz ist Public domain, was bedeutet, zu tun, was Sie wollen mit ihm. Bitte beachten Sie, dass diese Klasse wurde geschrieben 6 Jahren, und ich habe nicht berührt oder kontrolliert es da. Ich denke, es ist auch nicht die Datei kompatibel ist. Caveat emptor. Beachten Sie auch, dass dies übertrieben ist, für Ihr problem. Ich bin nicht fordern, sollten Sie auf jeden Fall diesen Weg gehen, aber ich hatte diesen code und ich genieße es wenn Sie mehr brauchen komplexe access.

import string
import re

class FileReader:
    """ 
    Similar to file class, but allows to access smoothly the lines 
    as when using readlines(), with no memory payload, going back and forth,
    finding regexps and so on.
    """
    def __init__(self,filename): # fold>>
        self.__file=file(filename,"r")
        self.__currentPos=-1
        # get file length
        self.__file.seek(0,0)
        counter=0
        line=self.__file.readline()
        while line != '':
            counter = counter + 1
            line=self.__file.readline()
        self.__length = counter
        # collect an index of filedescriptor positions against
        # the line number, to enhance search
        self.__file.seek(0,0)
        self.__lineToFseek = []

        while True:
            cur=self.__file.tell()
            line=self.__file.readline()
            # if it's not null the cur is valid for
            # identifying a line, so store
            self.__lineToFseek.append(cur)
            if line == '':
                break
    # <<fold
    def __len__(self): # fold>>
        """
        member function for the operator len()
        returns the file length
        FIXME: better get it once when opening file
        """
        return self.__length
        # <<fold
    def __getitem__(self,key): # fold>>
        """ 
        gives the "key" line. The syntax is

        import FileReader
        f=FileReader.FileReader("a_file")
        line=f[2]

        to get the second line from the file. The internal
        pointer is set to the key line
        """

        mylen = self.__len__()
        if key < 0:
            self.__currentPos = -1
            return ''
        elif key > mylen:
            self.__currentPos = mylen
            return ''

        self.__file.seek(self.__lineToFseek[key],0)
        counter=0
        line = self.__file.readline()
        self.__currentPos = key
        return line
        # <<fold
    def next(self): # fold>>
        if self.isAtEOF():
            raise StopIteration
        return self.readline()
    # <<fold
    def __iter__(self): # fold>>
        return self
    # <<fold
    def readline(self): # fold>>
        """
        read a line forward from the current cursor position.
        returns the line or an empty string when at EOF
        """
        return self.__getitem__(self.__currentPos+1)
        # <<fold
    def readbackline(self): # fold>>
        """
        read a line backward from the current cursor position.
        returns the line or an empty string when at Beginning of
        file.
        """
        return self.__getitem__(self.__currentPos-1)
        # <<fold
    def currentLine(self): # fold>>
        """
        gives the line at the current cursor position
        """
        return self.__getitem__(self.__currentPos)
        # <<fold
    def currentPos(self): # fold>>
        """ 
        return the current position (line) in the file
        or -1 if the cursor is at the beginning of the file
        or len(self) if it's at the end of file
        """
        return self.__currentPos
        # <<fold
    def toBOF(self): # fold>>
        """
        go to beginning of file
        """
        self.__getitem__(-1)
        # <<fold
    def toEOF(self): # fold>>
        """
        go to end of file
        """
        self.__getitem__(self.__len__())
        # <<fold
    def toPos(self,key): # fold>>
        """
        go to the specified line
        """
        self.__getitem__(key)
        # <<fold
    def isAtEOF(self): # fold>>
        return self.__currentPos == self.__len__()
        # <<fold
    def isAtBOF(self): # fold>>
        return self.__currentPos == -1
        # <<fold
    def isAtPos(self,key): # fold>>
        return self.__currentPos == key
        # <<fold

    def findString(self, thestring, count=1, backward=0): # fold>>
        """
        find the count occurrence of the string str in the file
        and return the line catched. The internal cursor is placed
        at the same line.
        backward is the searching flow.
        For example, to search for the first occurrence of "hello
        starting from the beginning of the file do:

        import FileReader
        f=FileReader.FileReader("a_file")
        f.toBOF()
        f.findString("hello",1,0)

        To search the second occurrence string from the end of the
        file in backward movement do:

        f.toEOF()
        f.findString("hello",2,1)

        to search the first occurrence from a given (or current) position
        say line 150, going forward in the file 

        f.toPos(150)
        f.findString("hello",1,0)

        return the string where the occurrence is found, or an empty string
        if nothing is found. The internal counter is placed at the corresponding
        line number, if the string was found. In other case, it's set at BOF
        if the search was backward, and at EOF if the search was forward.

        NB: the current line is never evaluated. This is a feature, since
        we can so traverse occurrences with a

        line=f.findString("hello")
        while line == '':
            line.findString("hello")

        instead of playing with a readline every time to skip the current
        line.
        """
        internalcounter=1
        if count < 1:
            count = 1
        while 1:
            if backward == 0:
                line=self.readline()
            else:
                line=self.readbackline()

            if line == '':
                return ''
            if string.find(line,thestring) != -1 :
                if count == internalcounter:
                    return line
                else:
                    internalcounter = internalcounter + 1
                    # <<fold
    def findRegexp(self, theregexp, count=1, backward=0): # fold>>
        """
        find the count occurrence of the regexp in the file
        and return the line catched. The internal cursor is placed
        at the same line.
        backward is the searching flow.
        You need to pass a regexp string as theregexp.
        returns a tuple. The fist element is the matched line. The subsequent elements
        contains the matched groups, if any.
        If no match returns None
        """
        rx=re.compile(theregexp)
        internalcounter=1
        if count < 1:
            count = 1
        while 1:
            if backward == 0:
                line=self.readline()
            else:
                line=self.readbackline()

            if line == '':
                return None
            m=rx.search(line)
            if m != None :
                if count == internalcounter:
                    return (line,)+m.groups()
                else:
                    internalcounter = internalcounter + 1
    # <<fold
    def skipLines(self,key): # fold>>
        """
        skip a given number of lines. Key can be negative to skip
        backward. Return the last line read.
        Please note that skipLines(1) is equivalent to readline()
        skipLines(-1) is equivalent to readbackline() and skipLines(0)
        is equivalent to currentLine()
        """
        return self.__getitem__(self.__currentPos+key)
    # <<fold
    def occurrences(self,thestring,backward=0): # fold>>
        """
        count how many occurrences of str are found from the current
        position (current line excluded... see skipLines()) to the
        begin (or end) of file.
        returns a list of positions where each occurrence is found,
        in the same order found reading the file.
        Leaves unaltered the cursor position.
        """
        curpos=self.currentPos()
        list = []
        line = self.findString(thestring,1,backward)
        while line != '':
            list.append(self.currentPos())
            line = self.findString(thestring,1,backward)
        self.toPos(curpos)
        return list
        # <<fold
    def close(self): # fold>>
        self.__file.close()
    # <<fold

InformationsquelleAutor der Antwort Stefano Borini

file_name = "your_file_name' 
file_open = open(Dateiname, 'r') 

def handler(line_one, line_two): 
print(line_one, line_two) 

während file_open: 
versuchen: 
eins = file_open.die next () - 
zwei = file_open.die next () - 
handler(eins, zwei) 
außer(StopIteration): 
file_open.close() 
Pause 

InformationsquelleAutor der Antwort Martin P. Hellwig

f = open(filename, "r")
for line in f:
    line1 = line
    f.next()

f.close

Jetzt können Sie die Datei Lesen, alle zwei Linie. Wenn Sie möchten, können Sie auch überprüfen Sie den f-status vor f.next()

InformationsquelleAutor der Antwort Kimmi

Habe ich ein ähnliches problem letzten Monat. Ich habe versucht, eine while-Schleife mit f.readline() sowie f.readlines().
Meine Daten-Datei ist nicht sehr groß, so dass ich schließlich für f ist.readlines(), das gibt mir mehr Kontrolle über den index, sonst
Ich habe mittels f.seek() zu hin und her bewegen des Dateizeigers.

Meinem Fall ist komplizierter, als OP. Da meine Daten-Datei ist flexibler, wie viele Zeilen analysiert werden, jedes mal, so
Ich habe zu prüfen, ein paar Bedingungen vor, ich kann die Daten analysieren.

Einem anderen problem, das ich fand heraus, über f.seek() ist, dass es gar nicht mit utf-8 sehr gut wenn ich die benutzen codecs.open(", 'r', 'utf-8'), (nicht ganz sicher über den Täter ist, schließlich gab ich auf diesen Ansatz.)

InformationsquelleAutor der Antwort Dingle

Wenn die Datei ist von angemessener Größe, ein anderer Ansatz, der verwendet list-comprehension zum Lesen der gesamten Datei in eine Liste von 2-Tupeln, ist dies:

filaname = '/path/to/file/name'

with open(filename, 'r') as f:
    list_of_2tuples = [ (line,f.readline()) for line in f ]

for (line1,line2) in list_of_2tuples: # Work with them in pairs.
    print('%s :: %s', (line1,line2))

InformationsquelleAutor der Antwort prismalytics.io