提问



如何在Python中读取文件的每一行并将每一行存储为列表中的元素?


我想逐行读取文件,并将每行附加到列表的末尾。

最佳参考


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] 

其它参考1


见输入和输出:[175]


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


或者剥离换行符:


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


编者注:这个答案的原始空白剥离命令,line.strip(),正如Janus Troelsen的评论所暗示的,将删除所有前导和尾随空白,而不仅仅是尾随\n

其它参考2


这比必要的更明确,但是做你想要的。


with open("file.txt", "r") as ins:
    array = []
    for line in ins:
        array.append(line)

其它参考3


这将从文件中生成一行数组。


lines = tuple(open(filename, 'r'))

其它参考4


如果你想要\n包括:


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


如果你不想要\n包括:


with open(fname) as f:
    content = f.read().splitlines()

其它参考5


您可以简单地执行以下操作,如建议的那样:


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


请注意,此方法有两个缺点:


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遍即可完成文件。这通常是通用解析器的工作方式。

其它参考6


如果你不关心关闭文件,这个单线程工作:


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(推荐):


with open('file.txt') as fp:
    lines = fp.read().split("\n")

其它参考7


这应该封装open命令。


array = []
with open("file.txt", "r") as f:
  for line in f:
    array.append(line)

其它参考8


数据到列表中


假设我们有一个包含我们数据的文本文件,如下所示:


文本文件内容:



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


或者...



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

其它参考9


将文件行读入列表的清除和pythonic方式





首先,您应该专注于打开文件并以高效和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 List ,因为它们是可迭代的,高效的和灵活的。在您的情况下,期望的目标是将文本文件的每一行放入单独的元素中。为此,我们将使用 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]



  • 输出(由于unicode字符而看起来不同):



     ['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ã.

其它参考10


我是这样做的。


lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)

其它参考11


要将文件读入列表,您需要做三件事:



  • 打开文件

  • 阅读文件

  • 将内容存储为列表



幸运的是,Python可以很容易地完成这些操作,因此将文件读入列表的最短方法是:


lst = list(open(filename))


但是我会添加更多解释。


打开文件



我假设您要打开一个特定的文件,而不是直接处理文件句柄(或类似文件的句柄)。在Python中打开文件最常用的函数是open,它在Python 2.7中需要一个强制参数和两个可选参数:[176]



  • 文件名

  • 模式

  • 缓冲(我会在这个答案中忽略这个论点)



文件名应该是一个字符串,表示文件的路径。例如:


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


openclose之间的某些内容抛出异常时,将无法关闭文件。您可以通过使用tryfinally来避免这种情况:


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


然而,Python提供了具有更漂亮语法的上下文管理器(但open它几乎与上面的tryfinally相同:


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


最后一种方法是用推荐方法在Python中打开文件!


读取文件



好的,你已经打开了文件,现在该如何阅读?


open函数返回file对象,它支持Pythons迭代协议。每次迭代都会给你一行:[178]


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


这将打印文件的每一行。但请注意,每行最后都会包含换行符\n(您可能需要检查Python是否使用通用换行符支持构建 - 否则您也可以在Windows上使用\r\n\r]]在Mac上作为换行符)。如果你不想要你可以简单地删除最后一个字符(或Windows上的最后两个字符):[179]


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函数:[180]


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


如果要删除尾随换行符,可以使用列表推导:


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


甚至更简单:file对象的.readlines()方法默认返回行list:[181]


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


这也将包括尾部换行符,如果你不想要它们我会推荐[line.rstrip() for line in f]方法,因为它避免保留两个包含内存中所有行的列表。


有一个额外的选项来获得所需的输出,但它相当次优:read字符串中的完整文件然后拆分换行:[182]


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()但是如果你想在将它们存储在列表中之前处理这些行,我会推荐一个简单的列表理解。


其它参考12


这是通过对文件使用列表推导的另一个选项;


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


这应该是更有效的方式,因为大多数工作都是在Python解释器内完成的。

其它参考13


另一种选择是numpy.genfromtxt,例如:[183]​​]]


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


这将使data为NumPy数组,其行数与文件中的数量相同。

其它参考14


如果您想从命令行或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 [184]

其它参考15


最简单的方法


一个简单的方法是:



  1. 将整个文件作为字符串
  2. 读取
  3. 逐行拆分字符串



在一行中,这将给出:


lines = open('C:/path/file.txt').read().splitlines()

其它参考16


f = open("your_file.txt",'r')
out = f.readlines() # will append in the list out


现在变量输出是你想要的列表(数组)。你可以这样做:


for line in out:
    print line


要么


for line in f:
    print line


你会得到相同的结果。

其它参考17


只需使用splitlines()函数。这是一个例子。


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


在输出中,您将获得行列表。

其它参考18


一个真正简单的方法:


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文件。

其它参考19


您可以使用以下命令打开文件进行阅读:


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


列表lines将包含所有行作为单独的元素,并且可以使用lines["linenumber-1"]调用特定元素,因为Python从0开始计数。

其它参考20


使用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 [185]


更高级的文件写入/阅读




  • CSV:超简单格式(读取和写入)

  • JSON:很适合编写人类可读的数据;非常常用(读和写)

  • YAML:YAML是JSON的超集,但更容易阅读(读取和写入,比较JSON和YAML)

  • pickle:Python序列化格式(读取和写入)

  • MessagePack(Python包):更紧凑的表示(读和写)

  • HDF5(Python包):很适合矩阵(读和写)

  • XML:也存在*叹气*(读和写)



对于您的应用,以下可能很重要: [191] [192] [194] [195]



  • 其他编程语言的支持

  • 阅读/写作表现

  • 紧凑度(文件大小)



另请参阅:数据序列化格式的比较 [199]


如果您正在寻找制作配置文件的方法,您可能需要阅读我的简短文章 Python中的配置文件。[200]

其它参考21


如果您想要面对非常大/巨大的文件并希望更快地阅读(想象您参加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)

其它参考22


据我所知,Python没有本机数组数据结构。但它确实支持列表数据结构,它比数组更简单易用。


array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)

其它参考23


用这个:


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()获取列表。

其它参考24


您可以通过以下代码轻松完成:


lines = open(filePath).readlines()

其它参考25


您也可以在NumPy中使用loadtxt命令。这会检查比genfromtxt更少的条件,因此它可能更快。


import numpy
data = numpy.loadtxt(filename, delimiter="\n")

其它参考26


在Python 3.4中引入,pathlib有一个非常方便的文件读取方法,如下所示:[201]


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


(splitlines调用将其从包含文件全部内容的字符串转换为文件中的行列表。


pathlib有很多方便的便利。 read_text简洁明了,你不必担心打开和关闭文件。如果你需要对文件进行一次性阅读,那么这是一个不错的选择。

其它参考27


命令行版本



#!/bin/python3
import os
import sys
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
filename = dname + sys.argv[1]
arr = open(filename).read().split("\n") 
print(arr)


以:

运行

python3 somefile.py input_file_name.txt

其它参考28


我喜欢使用以下内容。立刻读线。


contents = []
for line in open(filepath, 'r').readlines():
    contents.append(line.strip())


或者使用列表理解:


contents = [line.strip() for line in open(filepath, 'r').readlines()]

其它参考29


概要和摘要



使用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.inputflist.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


同样,上面的ffileinput.input都是/return惰性迭代器。
你只能使用迭代器一次,所以提供功能代码同时避免冗长我会使用稍微简洁fileinput.input(filename)来自这里的apropos。



  

在Python中,如何将文件逐行读入列表?




啊但你出于某种原因想要它在列表中吗?如果可能,我会避免这种情况。但如果你坚持......只是将fileinput.input(filename)的结果传递给list:


list(fileinput.input(filename))


另一个直接的答案是调用f.readlines,它返回文件的内容(最多可选hint个字符数,因此可以将其分解为多个列表办法)。


您可以通过两种方式获取此文件对象。一种方法是将文件名传递给open内置:


filename = 'filename'

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


或者使用pathlib模块中的新Path对象(我已经非常喜欢它,并将在这里使用):


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.inputwith path.open() as f