Как я могу читать большие текстовые файлы в Python, построчно, не загружая их в память?

Мне нужно прочитать большой файл, строка за строкой. Допустим, файл имеет более 5 ГБ, и мне нужно прочитать каждую строку, но, очевидно, я не хочу использовать, readlines()потому что это создаст очень большой список в памяти.

Как будет работать код ниже для этого случая? Читает ли xreadlinesсам по себе в память? Нужно ли выражение генератора?

f = (line for line in open("log.txt").xreadlines())  # how much is loaded in memory?

f.next()  

Кроме того, что я могу сделать, чтобы прочитать это в обратном порядке, так же, как команда Linux tail?

Я нашел:

http://code.google.com/p/pytailer/

и

« голова питона, хвост и назад читаются по строкам текстового файла »

Оба работали очень хорошо!

Я представил этот ответ , потому что Кит, в то время как сжато, не закрывает файл явно

with open("log.txt") as infile:
    for line in infile:
        do_something_with(line)

Все, что вам нужно сделать, это использовать объект файла в качестве итератора.

for line in open("log.txt"):
    do_something_with(line)

Еще лучше использовать контекстный менеджер в последних версиях Python.

with open("log.txt") as fileobject:
    for line in fileobject:
        do_something_with(line)

Это также автоматически закроет файл.

Старый школьный подход:

fh = open(file_name, 'rt')
line = fh.readline()
while line:
    # do stuff with line
    line = fh.readline()
fh.close()

Вместо этого вам лучше использовать итератор. Соответствующий: http://docs.python.org/library/fileinput.html

Из документов:

import fileinput
for line in fileinput.input("filename"):
    process(line)

Это позволит избежать копирования всего файла в память сразу.

Вот что вы делаете, если в файле нет новых строк:

with open('large_text.txt') as f:
  while True:
    c = f.read(1024)
    if not c:
      break
    print(c)

Пожалуйста, попробуйте это:

with open('filename','r',buffering=100000) as f:
    for line in f:
        print line

Я не мог поверить, что это может быть так просто, как кажется от ответа @ john-la-rooy. Итак, я воссоздал cpкоманду, используя построчное чтение и запись. Это безумно быстро.

#!/usr/bin/env python3.6

import sys

with open(sys.argv[2], 'w') as outfile:
    with open(sys.argv[1]) as infile:
        for line in infile:
            outfile.write(line)

За последние 6 лет этот блестящий проект прошел долгий путь. Он имеет простой API, охватывающий полезный набор функций панд.

dask.dataframe обеспечивает внутреннее распределение, поддерживает множество параллельных операций и позволяет легко экспортировать фрагменты обратно в панды для операций в памяти.

import dask.dataframe as dd

df = dd.read_csv('filename.csv')
df.head(10)  # return first 10 rows
df.tail(10)  # return last 10 rows

# iterate rows
for idx, row in df.iterrows():
    ...

# group by my_field and return mean
df.groupby(df.my_field).value.mean().compute()

# slice by column
df[df.my_field=='XYZ'].compute()

Вот код для загрузки текстовых файлов любого размера без проблем с памятью. Он поддерживает файлы размером в гигабайты

https://gist.github.com/iyvinjose/e6c1cb2821abd5f01fd1b9065cbc759d

скачайте файл data_loading_utils.py и импортируйте его в свой код

использование

import data_loading_utils.py.py
file_name = 'file_name.ext'
CHUNK_SIZE = 1000000


def process_lines(data, eof, file_name):

    # check if end of file reached
    if not eof:
         # process data, data is one single line of the file

    else:
         # end of file reached

data_loading_utils.read_lines_from_file_as_data_chunks(file_name, chunk_size=CHUNK_SIZE, callback=self.process_lines)

Метод process_lines является функцией обратного вызова. Он будет вызываться для всех строк, причем данные параметров представляют одну строку файла за раз.

Вы можете настроить переменную CHUNK_SIZE в зависимости от конфигурации оборудования вашего компьютера.

Как насчет этого? Разделите ваш файл на куски, а затем прочитайте его построчно, потому что когда вы читаете файл, ваша операционная система будет кэшировать следующую строку. Если вы читаете файл построчно, вы неэффективно используете кэшированную информацию.

Вместо этого разделите файл на куски и загрузите весь кусок в память, а затем выполните обработку.

def chunks(file,size=1024):
    while 1:

        startat=fh.tell()
        print startat #file's object current position from the start
        fh.seek(size,1) #offset from current postion -->1
        data=fh.readline()
        yield startat,fh.tell()-startat #doesnt store whole list in memory
        if not data:
            break
if os.path.isfile(fname):
    try:
        fh=open(fname,'rb') 
    except IOError as e: #file --> permission denied
        print "I/O error({0}): {1}".format(e.errno, e.strerror)
    except Exception as e1: #handle other exceptions such as attribute errors
        print "Unexpected error: {0}".format(e1)
    for ele in chunks(fh):
        fh.seek(ele[0])#startat
        data=fh.read(ele[1])#endat
        print data

Спасибо! Недавно я перешел на Python 3 и был разочарован использованием readlines (0) для чтения больших файлов. Это решило проблему. Но чтобы получить каждую строчку, мне пришлось сделать пару дополнительных шагов. Каждой строке предшествовала буква «b», которая, я думаю, была в двоичном формате. Использование «decode (utf-8)» изменило его ascii.

Затем мне пришлось удалить «= \ n» в середине каждой строки.

Затем я разбил строки на новой строке.

b_data=(fh.read(ele[1]))#endat This is one chunk of ascii data in binary format
        a_data=((binascii.b2a_qp(b_data)).decode('utf-8')) #Data chunk in 'split' ascii format
        data_chunk = (a_data.replace('=\n','').strip()) #Splitting characters removed
        data_list = data_chunk.split('\n')  #List containing lines in chunk
        #print(data_list,'\n')
        #time.sleep(1)
        for j in range(len(data_list)): #iterate through data_list to get each item 
            i += 1
            line_of_data = data_list[j]
            print(line_of_data)

Вот код, начинающийся чуть выше «данных печати» в коде Арохи.

Я продемонстрировал подход произвольного доступа с параллельным байтовым уровнем здесь в этом другом вопросе:

Получение количества строк в текстовом файле без readlines

Некоторые из уже предоставленных ответов хороши и лаконичны. Мне нравятся некоторые из них. Но это действительно зависит от того, что вы хотите сделать с данными в файле. В моем случае я просто хотел посчитать строки как можно быстрее для больших текстовых файлов. Мой код может быть изменен, чтобы делать другие вещи, конечно, как любой код.

Лучшее решение, которое я нашел в отношении этого, и я попробовал это на 330 МБ файла.

lineno = 500
line_length = 8
with open('catfour.txt', 'r') as file:
    file.seek(lineno * (line_length + 2))
    print(file.readline(), end='')

Где line_length - это количество символов в одной строке. Например, «abcd» имеет длину строки 4.

Я добавил 2 в длину строки, чтобы пропустить символ '\ n' и перейти к следующему символу.

Это может быть полезно, когда вы хотите работать параллельно и читать только фрагменты данных, но сохраняйте их чистыми с новыми строками.

def readInChunks(fileObj, chunkSize=1024):
    while True:
        data = fileObj.read(chunkSize)
        if not data:
            break
        while data[-1:] != '\n':
            data+=fileObj.read(1)
        yield data

f=open('filename','r').read()
f1=f.split('\n')
for i in range (len(f1)):
    do_something_with(f1[i])

надеюсь это поможет.