Как читать файл по строкам в списке?

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

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

1995
19 июля '10 в 1:25
источник поделиться
41 ответ
  • 1
  • 2
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] 
1928
19 июля '10 в 1:28
источник

Смотрите Input и Ouput:

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

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

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

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

864
19 июля '10 в 1:28
источник

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

with open("file.txt", "r") as ins:
    array = []
    for line in ins:
        array.append(line)
492
19 июля '10 в 1:27
источник

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

lines = tuple(open(filename, 'r'))
242
19 июля '10 в 1:27
источник

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

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

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

with open(fname) as f:
    content = f.read().splitlines()
171
02 марта '14 в 7:22
источник

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

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 проход. Как правило, общие парсеры будут работать.

126
25 февр. '16 в 12:13
источник

Обновление: в соответствии с Методами Файловых Объектов, самый простой способ прочитать файл в list:

with open('file.txt') as f:
    my_list = list(f)

Другие способы чтения текстового файла в список:

Использование with и readlines() (рекомендуется):

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

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

lines = open('file.txt').readlines()

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

fp = open('file.txt') # Open file on read mode
lines = fp.read().split("\n") # Create a list containing all lines
fp.close() # Close file
113
20 апр. '15 в 8:53
источник

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

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

Текстовое содержимое:

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']

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

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)
55
26 апр. '17 в 7:57
источник

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

array = []
with open("file.txt", "r") as f:
  for line in f:
    array.append(line)
48
28 окт. '13 в 18:40
источник

Чистый и 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ã.
40
20 дек. '14 в 21:31
источник

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

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

К счастью, 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 "newlines"), что .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() но если вы хотите обработать строки перед их сохранением в списке, я бы рекомендовал простое понимание списка.
36
17 янв. '18 в 1:33
источник

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

lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)
30
09 дек. '16 в 21:43
источник

Здесь еще один вариант с использованием списков в файлах;

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

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

26
27 мая '14 в 15:21
источник

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

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

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

25
18 июня '13 в 13:17
источник

Если вы хотите прочитать файл из командной строки или из stdin, вы также можете использовать модуль 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

23
22 нояб. '13 в 17:57
источник

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

Простым способом является:

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

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

lines = open('C:/path/file.txt').read().splitlines()
20
06 февр. '15 в 6:34
источник

Чтение и запись текстовых файлов с помощью 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 поскольку они также .rstrip() пробел.

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

.txt

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

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

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

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

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

19
16 янв. '18 в 22:42
источник

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

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

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

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

18
30 апр. '18 в 20:41
источник
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

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

16
12 янв. '14 в 13:58
источник

Реальный простой способ:

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.

15
28 марта '16 в 0:29
источник

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

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

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

14
09 сент. '16 в 12:13
источник

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

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

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

13
19 мая '17 в 13:50
источник

Если вы хотите столкнуться с очень большим/огромным файлом и хотите быстро прочитать (представьте, что вы находитесь в конкурсе кодирования 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)
11
11 марта '17 в 11:49
источник

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

array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)
8
07 марта '16 в 9:54
источник

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

lines = list(open('filename'))

или же

lines = tuple(open('filename'))

или же

lines = set(open('filename'))

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

7
14 марта '19 в 17:28
источник

Вы можете легко сделать это с помощью следующей части кода:

lines = open(filePath).readlines()
6
26 июня '17 в 4:43
источник

Используйте это:

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().

5
30 марта '16 в 18:50
источник

Вы также можете использовать команду loadtxt в NumPy. Это проверяет меньшее количество условий, чем genfromtxt, поэтому оно может быть быстрее.

import numpy
data = numpy.loadtxt(filename, delimiter="\n")
4
20 июля '15 в 20:33
источник

Проверьте этот короткий фрагмент

fileOb=open("filename.txt","r")
data=fileOb.readlines() #returns a array of lines.

или же

fileOb=open("filename.txt","r")
data=list(fileOb) #returns a array of lines.

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

4
06 нояб. '18 в 17:35
источник

План и резюме

С 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 по 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 (который мне очень 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(). По умолчанию 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.

3
16 мая '18 в 23:17
источник
  • 1
  • 2

Посмотрите другие вопросы по меткам или Задайте вопрос