How to read a file line-by-line into a list?

Как мне прочитать каждую строку файла в Python и сохранить каждую строку как элемент в списке?

Я хочу прочитать файл построчно и добавить каждую строку в конец списка.

Источник

33 ответа 

with open(fname) as f:
    content = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end of each line
content = [x.strip() for x in content]
Источник

Смотрите вход и выход:

with open('filename') as f:
    lines = f.readlines()

или с удалением символа новой строки:

lines = [line.rstrip('\n') for line in open('filename')]

Примечание редактора: оригинальная команда для удаления пробелов в этом ответе, line.strip() Как следует из комментария Януса Троелсена, удаляются все начальные и конечные пробелы, а не только конечные \n ,

Источник

Это более явно, чем необходимо, но делает то, что вы хотите.

with open("file.txt", "r") as ins:
    array = []
    for line in ins:
        array.append(line)
Источник

Это даст "массив" строк из файла.

lines = tuple(open(filename, 'r'))
Источник

Если вам не нужно закрывать файл, эта однострочная работа работает:

lines = open('file.txt').read().split("\n")

Традиционный способ:

fp = open('file.txt') # Open file on read mode
lines = fp.read().split("\n") # Create a list containing all lines
fp.close() # Close file

С помощью with а также readlines() (рекомендуемые):

with open('file.txt') as fp:
    lines = fp.read().readlines()

За python3:

with open('file.txt') as fp:
    lines = fp.readlines()
Источник

Если вы хотите \n включено:

with open(fname) as f:
    content = f.readlines()

Если вы не хотите \n включено:

with open(fname) as f:
    content = f.read().splitlines()
Источник

Вы можете просто сделать следующее, как было предложено:

with open('/your/path/file') as f:
    my_lines = f.readlines()

Обратите внимание, что у этого подхода есть 2 недостатка:

1) Вы храните все строки в памяти. В общем случае это очень плохая идея. Файл может быть очень большим, и вам может не хватить памяти. Даже если он не большой, это просто пустая трата памяти.

2) Это не позволяет обрабатывать каждую строку, когда вы их читаете. Так что если вы обрабатываете ваши строки после этого, это неэффективно (требуется два прохода, а не один).

Лучший подход для общего случая был бы следующим:

with open('/your/path/file') as f:
    for line in f:
        process(line)

Где вы определяете свою функцию процесса так, как хотите. Например:

def process(line):
    if 'save the world' in line.lower():
         superman.save_the_world()

(Реализация Superman класс оставлен как упражнение для вас).

Это будет хорошо работать при любом размере файла, и вы пройдете его всего за 1 проход. Как правило, именно так будут работать универсальные парсеры.

Источник

Данные в список

Предположим, что у нас есть текстовый файл с нашими данными, как в следующих строках:

Содержание текстового файла:

line 1
line 2
line 3
  • Откройте cmd в том же каталоге (щелкните правой кнопкой мыши и выберите cmd или PowerShell)
  • Бежать python и в интерпретаторе напишите:

Скрипт Python

>>> with open("myfile.txt", encoding="utf-8") as file:
...     x = [l.strip() for l in file]
>>> x
['line 1','line 2','line 3']

Используя приложение

x = []
with open("myfile.txt") as file:
    for l in file:
        x.append(l.strip())

Или же...

>>> x = open("myfile.txt").read().splitlines()
>>> x
['line 1', 'line 2', 'line 3']

Или же...

>>> x = open("myfile.txt").readlines()
>>> x
['linea 1\n', 'line 2\n', 'line 3\n']

Или же...

>>> y = [x.rstrip() for x in open("my_file.txt")]
>>> y
['line 1','line 2','line 3']


with open('testodiprova.txt', 'r', encoding='utf-8') as file:
    file = file.read().splitlines()
  print(file)

with open('testodiprova.txt', 'r', encoding='utf-8') as file:
  file = file.readlines()
  print(file)
Источник

Введенный в Python 3.4, pathlib имеет действительно удобный способ чтения текста из файлов, а именно:

from pathlib import Path
p = Path('my_text_file')
lines = p.read_text().splitlines()

(The splitlines вызов - это то, что превращает его из строки, содержащей все содержимое файла, в список строк в файле).

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

Источник

Чтобы прочитать файл в список, вам нужно сделать три вещи:

  • Открыть файл
  • Читать файл
  • Хранить содержимое в виде списка

К счастью, Python делает это очень легко, поэтому самый короткий способ чтения файла в список:

lst = list(open(filename))

Однако я добавлю еще несколько объяснений.

Открытие файла

Я предполагаю, что вы хотите открыть определенный файл, и вы не имеете дело непосредственно с дескриптором файла (или с дескриптором файла). Наиболее часто используемая функция для открытия файла в Python open, он принимает один обязательный аргумент и два необязательных в Python 2.7:

  • Имя файла
  • Режим
  • Буферизация (я проигнорирую этот аргумент в этом ответе)

Имя файла должно быть строкой, которая представляет путь к файлу. Например:

open('afile')   # opens the file named afile in the current working directory
open('adir/afile')            # relative path (relative to the current working directory)
open('C:/users/aname/afile')  # absolute path (windows)
open('/usr/local/afile')      # absolute path (linux)

Обратите внимание, что необходимо указать расширение файла. Это особенно важно для пользователей Windows, потому что такие расширения файлов, как .txt или же .doc и т. д. по умолчанию скрыты при просмотре в проводнике.

Второй аргумент mode, его r по умолчанию, что означает "только для чтения". Это именно то, что вам нужно в вашем случае.

Но если вы действительно хотите создать файл и / или записать в файл, вам понадобится другой аргумент. Существует отличный ответ, если вы хотите обзор.

Для чтения файла вы можете опустить mode или передать это явно:

open(filename)
open(filename, 'r')

Оба откроют файл в режиме только для чтения. Если вы хотите прочитать в двоичном файле в Windows, вам нужно использовать режим rb:

open(filename, 'rb')

На других платформах 'b' (двоичный режим) просто игнорируется.

Теперь, когда я показал, как open файл, давайте поговорим о том, что вам всегда нужно close это снова. В противном случае он будет хранить открытый дескриптор файла до тех пор, пока не завершится процесс (или Python не обработает дескриптор файла).

Пока вы можете использовать:

f = open(filename)
# ... do stuff with f
f.close()

Это не сможет закрыть файл, когда что-то между open а также close бросает исключение. Вы можете избежать этого, используя try а также finally:

f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

Однако Python предоставляет контекстные менеджеры, которые имеют более красивый синтаксис (но для open это почти идентично try а также finally выше):

with open(filename) as f:
    # do stuff with f
# The file is always closed after the with-scope ends.

Последний подход - это рекомендуемый подход для открытия файла в Python!

Чтение файла

Хорошо, вы открыли файл, теперь как его прочитать?

open функция возвращает file объект и поддерживает протокол итерации Pythons. Каждая итерация даст вам строку:

with open(filename) as f:
    for line in f:
        print(line)

Это напечатает каждую строку файла. Обратите внимание, что каждая строка будет содержать символ новой строки \n в конце (вы можете проверить, построен ли ваш Python с универсальной поддержкой новой строки - в противном случае вы также можете иметь \r\n в Windows или \r на Mac как новые строки). Если вы не хотите этого, вы можете просто удалить последний символ (или два последних символа в Windows):

with open(filename) as f:
    for line in f:
        print(line[:-1])

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

with open(filename) as f:
    for line in f:
        if line.endswith('\n'):
            line = line[:-1]
        print(line)

Но вы можете просто удалить все пробелы (включая \n символ) с конца строки, это также удалит все другие конечные пробелы, поэтому вы должны быть осторожны, если они важны:

with open(filename) as f:
    for line in f:
        print(f.rstrip())

Однако, если строки заканчиваются \r\n (Windows "новые строки"), что .rstrip() также позаботится о \r!

Хранить содержимое в виде списка

Теперь, когда вы знаете, как открыть файл и прочитать его, пришло время сохранить содержимое в списке. Самый простой вариант - использовать list функция:

with open(filename) as f:
    lst = list(f)

Если вы хотите убрать завершающие символы новой строки, вы можете использовать вместо этого понимание списка:

with open(filename) as f:
    lst = [line.rstrip() for line in f]

Или даже проще: .readlines() метод file объект по умолчанию возвращает list из линий:

with open(filename) as f:
    lst = f.readlines()

Это также будет включать в себя завершающие символы новой строки, если вы не хотите их, я бы порекомендовал [line.rstrip() for line in f] подход, потому что он избегает хранения двух списков, содержащих все строки в памяти.

Есть дополнительная опция для получения желаемого результата, однако она довольно "неоптимальная": read полный файл в строке, а затем разделить на новые строки:

with open(filename) as f:
    lst = f.read().split('\n')

или же:

with open(filename) as f:
    lst = f.read().splitlines()

Они автоматически следят за завершающими символами новой строки, потому что split персонаж не включен Однако они не идеальны, потому что вы сохраняете файл как строку и как список строк в памяти!

Резюме

  • использование with open(...) as f при открытии файлов, потому что вам не нужно заботиться о закрытии файла самостоятельно, и он закрывает файл, даже если происходит какое-то исключение.
  • file объекты поддерживают протокол итерации, поэтому чтение файла построчно так же просто, как for line in the_file_object:,
  • Всегда просматривайте документацию для доступных функций / классов. Большую часть времени идеально подходит для этой задачи или, по крайней мере, один или два хороших. Очевидный выбор в этом случае будет readlines() но если вы хотите обработать строки перед сохранением их в списке, я бы порекомендовал простое понимание списка.
Источник

Чистый и Pythonic способ чтения строк файла в список

Прежде всего, вы должны сосредоточиться на том, чтобы открыть свой файл и прочитать его содержимое эффективным и питонным способом. Вот пример того, как я лично НЕ предпочитаю:

infile = open('my_file.txt', 'r')  # Open the file for reading.

data = infile.read()  # Read the contents of the file.

infile.close()  # Close the file since we're done using it.

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

# Open the file for reading.
with open('my_file.txt', 'r') as infile:

    data = infile.read()  # Read the contents of the file into memory.

Теперь нам нужно сосредоточиться на переносе этих данных в список Python, потому что они итеративны, эффективны и гибки. В вашем случае желаемая цель - перенести каждую строку текстового файла в отдельный элемент. Для этого мы будем использовать метод splitlines() следующим образом:

# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()

Конечный продукт:

# Open the file for reading.
with open('my_file.txt', 'r') as infile:

    data = infile.read()  # Read the contents of the file into memory.

# Return a list of the lines, breaking at line boundaries.
my_list = data.splitlines()

Тестирование нашего кода:

  • Содержание текстового файла:
     A fost odatã ca-n povesti,
     A fost ca niciodatã,
     Din rude mãri împãrãtesti,
     O prea frumoasã fatã.
  • Распечатайте заявления для тестирования:
    print my_list  # Print the list.

    # Print each line in the list.
    for line in my_list:
        print line

    # Print the fourth element in this list.
    print my_list[3]
  • Вывод (другой вид из-за символов юникода):
     ['A fost odat\xc3\xa3 ca-n povesti,', 'A fost ca niciodat\xc3\xa3,',
     'Din rude m\xc3\xa3ri \xc3\xaemp\xc3\xa3r\xc3\xa3testi,', 'O prea
     frumoas\xc3\xa3 fat\xc3\xa3.']

     A fost odatã ca-n povesti, A fost ca niciodatã, Din rude mãri
     împãrãtesti, O prea frumoasã fatã.

     O prea frumoasã fatã.
Источник

Это должно инкапсулировать команду открытия.

array = []
with open("file.txt", "r") as f:
  for line in f:
    array.append(line)
Источник

Вот еще один вариант, используя списки в файлах;

lines = [line.rstrip() for line in open('file.txt')]

Это должно быть более эффективным способом, так как большая часть работы выполняется внутри интерпретатора Python.

Источник 
f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out

Теперь переменная out - это список (массив) того, что вы хотите. Вы можете сделать:

for line in out:
    print line

или же

for line in f:
    print line

вы получите те же результаты.

Источник

Другой вариант numpy.genfromtxt, например:

import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="\n")

Это сделает data массив NumPy с таким количеством строк в вашем файле.

Источник

Чтение и запись текстовых файлов с помощью Python 2 и Python 3; это работает с Unicode 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Define data
lines = ['     A first string  ',
         'A Unicode sample: €',
         'German: äöüß']

# Write text file
with open('file.txt', 'w') as fp:
    fp.write('\n'.join(lines))

# Read text file
with open('file.txt', 'r') as fp:
    read_lines = fp.readlines()
    read_lines = [line.rstrip('\n') for line in read_lines]

print(lines == read_lines)

На что обратить внимание:

  • with это так называемый контекстный менеджер. Это гарантирует, что открытый файл снова закрыт.
  • Все решения здесь, которые просто делают .strip() или же .rstrip() не сможет воспроизвести lines поскольку они также лишают белое пространство.

Общие окончания файлов

.txt

Более продвинутая запись / чтение файлов

Для вашего приложения может быть важно следующее:

  • Поддержка другими языками программирования
  • Чтение / запись производительности
  • Компактность (размер файла)

Смотрите также: Сравнение форматов сериализации данных

Если вы предпочитаете создавать конфигурационные файлы, вы можете прочитать мою короткую статью Конфигурационные файлы на Python.

Источник

Я бы сделал это так

lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)
Источник

Если вы хотите прочитать файл из командной строки или из стандартного ввода, вы также можете использовать fileinput модуль:

# reader.py
import fileinput

content = []
for line in fileinput.input():
    content.append(line.strip())

fileinput.close()

Передайте файлы ему так:

$ python reader.py textfile.txt

Подробнее читайте здесь: http://docs.python.org/2/library/fileinput.html

Источник

Самый простой способ сделать это

Простой способ состоит в том, чтобы:

  1. Прочитать весь файл как строку
  2. Разделить строку строка за строкой

В одной строке это даст:

lines = open('C:/path/file.txt').read().splitlines()
Источник

Просто используйте функции splitlines(). Вот пример.

inp = "file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3

В выводе у вас будет список строк.

Источник

Очень простой способ:

with open(file) as g:
    stuff = g.readlines()

Если вы хотите сделать его полноценной программой, введите:

file = raw_input ("Enter EXACT file name: ")
with open(file) as g:
    stuff = g.readlines()
print (stuff)
exit = raw_input("Press enter when you are done.")

По некоторым причинам он не читает файлы.py должным образом.

Источник

Вы можете просто открыть свой файл для чтения, используя:

file1 = open("filename","r")
# And for reading use
lines = file1.readlines()
file1.close()

Список lines будет содержать все ваши строки как отдельные элементы, и вы можете вызвать определенный элемент, используя lines["linenumber-1"] как Python начинает отсчет с 0.

Источник

Если вы хотите столкнуться с очень большим / огромным файлом и хотите читать быстрее (представьте, что вы участвуете в конкурсе кодирования Topcoder/Hackerrank), вы можете за один раз прочитать значительно больший кусок строк в буфер памяти, а не просто итерации построчно на уровне файла.

buffersize = 2**16
with open(path) as f: 
    while True:
        lines_buffer = f.readlines(buffersize)
        if not lines_buffer:
            break
        for line in lines_buffer:
            process(line)
Источник

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

array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)
Источник

Самый простой способ сделать это с некоторыми дополнительными преимуществами:

lines = list(open('filename'))

или же

lines = tuple(open('filename'))

или же

lines = set(open('filename'))

В случае с set, мы должны помнить, что у нас не сохранен порядок строк и избавиться от дублированных строк.

Источник

Использовать этот:

import pandas as pd
data = pd.read_csv(filename) # You can also add parameters such as header, sep, etc.
array = data.values

data тип данных и использует значения для получения ndarray. Вы также можете получить список с помощью array.tolist(),

Источник

Если в документе также есть пустые строки, я хотел бы прочитать их содержимое и пропустить filter предотвратить пустые строковые элементы

with open(myFile, "r") as f:
    excludeFileContent = list(filter(None, f.read().splitlines()))
Источник

Вы можете легко сделать это следующим фрагментом кода:

lines = open(filePath).readlines()
Источник

План и Резюме

С filename, обрабатывая файл из Path(filename) объект или непосредственно с open(filename) as f, Выполните одно из следующих действий:

  • list(fileinput.input(filename))
  • с помощью with path.open() as f, вызов f.readlines()
  • list(f)
  • path.read_text().splitlines()
  • path.read_text().splitlines(keepends=True)
  • перебрать fileinput.input или же f а также list.append каждая строка по одному
  • проходить f к пределу list.extend метод
  • использование f в понимании списка

Я объясняю вариант использования для каждого ниже.

В Python, как мне прочитать файл построчно?

Это отличный вопрос. Сначала давайте создадим несколько примеров данных:

from pathlib import Path
Path('filename').write_text('foo\nbar\nbaz')

Файловые объекты являются ленивыми итераторами, поэтому просто перебирайте их.

filename = 'filename'
with open(filename) as f:
    for line in f:
        line # do something with the line

Кроме того, если у вас есть несколько файлов, используйте fileinput.inputЕще один ленивый итератор. Всего одним файлом:

import fileinput

for line in fileinput.input(filename): 
    line # process the line

или для нескольких файлов передайте ему список имен файлов:

for line in fileinput.input([filename]*2): 
    line # process the line

Снова, f а также fileinput.input выше оба / ленивые итераторы возврата. Вы можете использовать итератор только один раз, поэтому для обеспечения функционального кода, избегая многословия, я буду использовать несколько более краткий fileinput.input(filename) где по поводу отсюда.

В Python, как я могу прочитать файл построчно в список?

Ах, но вы хотите его в списке по какой-то причине? Я бы избежал этого, если это возможно. Но если вы настаиваете... просто передать результат fileinput.input(filename) в list:

list(fileinput.input(filename))

Другой прямой ответ - позвонить f.readlines, который возвращает содержимое файла (до необязательного hint количество символов, так что вы можете разбить это на несколько списков таким образом).

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

filename = 'filename'

with open(filename) as f:
    f.readlines()

или используя новый объект Path из pathlib модуль (который я очень полюбил и буду использовать с этого момента):

from pathlib import Path

path = Path(filename)

with path.open() as f:
    f.readlines()

list также будет использовать файловый итератор и возвращать список - довольно прямой метод:

with path.open() as f:
    list(f)

Если вы не возражаете прочесть весь текст в память как одну строку перед разделением, вы можете сделать это как одну строку с Path объект и splitlines() Строковый метод. По умолчанию, splitlines удаляет новые строки:

path.read_text().splitlines()

Если вы хотите сохранить переводы строк, пройдите keepends=True:

path.read_text().splitlines(keepends=True)

Я хочу прочитать файл построчно и добавить каждую строку в конец списка.

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

С помощью list.append позволит вам отфильтровать или обработать каждую строку перед ее добавлением:

line_list = []
for line in fileinput.input(filename):
    line_list.append(line)

line_list

С помощью list.extend будет немного более прямым и, возможно, полезным, если у вас есть существующий список:

line_list = []
line_list.extend(fileinput.input(filename))
line_list

Или, более идиотски, мы могли бы вместо этого использовать понимание списка, и отображать и фильтровать его, если это желательно:

[line for line in fileinput.input(filename)]

Или, еще более прямо, чтобы замкнуть круг, просто передайте его списку, чтобы создать новый список напрямую, не работая со строками:

list(fileinput.input(filename))

Заключение

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

То есть предпочитаю fileinput.input или же with path.open() as f,

Источник

Я бы попробовал один из следующих методов. Файл примера, который я использую, имеет имя dummy.txt, Вы можете найти файл здесь. Я предполагаю, что файл находится в том же каталоге, что и код (вы можете изменить fpath включить правильное имя файла и путь к папке.)

В обоих приведенных ниже примерах список, который вы хотите получить lst,

1.> Первый способ:

fpath = 'dummy.txt'
with open(fpath, "r") as f: lst = [line.rstrip('\n \t') for line in f]

print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']

2.> Во втором методе можно использовать модуль csv.reader из стандартной библиотеки Python:

import csv
fpath = 'dummy.txt'
with open(fpath) as csv_file:
    csv_reader = csv.reader(csv_file, delimiter='   ')
    lst = [row[0] for row in csv_reader] 

print lst
>>>['THIS IS LINE1.', 'THIS IS LINE2.', 'THIS IS LINE3.', 'THIS IS LINE4.']

Вы можете использовать любой из двух методов. Время, затраченное на создание lst почти равен в двух методах.

Источник
Другие вопросы по тегам