python:如何将文件逐行读取到列表中?


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

我想逐行读取文件，并将每一行追加到列表的末尾。

相关讨论

1
2
3
4
5
with open(fname) as f:
    content = f.readlines()
# you may also want to remove whitespace characters like `
` at the end of each line
content = [x.strip() for x in content]
相关讨论

见输入和输出:

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

或者去掉换行符:

1
2
lines = [line.rstrip('
') for line in open('filename')]

Editor's note:正如Janus Troelsen的评论所暗示的，这个答案的原始空格剥离命令line.strip()将删除所有前边和后面的空格，而不仅仅是后面的
。

相关讨论

这比必要的更明确，但是做了您想做的。

1
2
3
4
with open("file.txt","r") as ins:
    array = []
    for line in ins:
        array.append(line)
相关讨论

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

1
lines = tuple(open(filename, 'r'))
相关讨论

如果你想包含
:

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

如果你不想包含
:

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

按照建议，您可以简单地执行以下操作:

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

注意这种方法有两个缺点:

你把所有的行都存储在内存中。在一般情况下，这是一个非常糟糕的主意。文件可能非常大，您可能会耗尽内存。即使它不是很大，也只是浪费内存。

这并不允许在您阅读每一行时处理它们。因此，如果您在此之后处理您的行，那么效率就不高(需要两次传递而不是一次)。

对于一般情况，较好的办法是:

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

您可以任意定义流程函数。例如:

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

(Superman类的实现留给您作为练习)。

这将很好地工作，任何大小的文件，你通过你的文件在短短一个通行证。这就是泛型解析器的典型工作方式。

相关讨论

如果你不关心关闭文件，这一行代码可以:

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

传统的方法:

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

使用with和readlines()(推荐):

1
2
with open('file.txt') as fp:
    lines = fp.readlines()
相关讨论

数据列表

假设我们有一个文本文件与我们的数据如下行:

文本文件内容:

1
2
3
line 1
line 2
line 3

在相同的目录中打开cmd(右键单击鼠标并选择cmd或PowerShell)运行python，在解释器中写入:

的Python脚本

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

使用附加

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

或…

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

或…

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

或…

1
2
3
4
5
6
7
8
9
10
11
12
>>> 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)
相关讨论

这应该封装open命令。

1
2
3
4
array = []
with open("file.txt","r") as f:
  for line in f:
    array.append(line)
相关讨论

将文件行读入列表的一种简洁的python方法

首先，也最重要的是，您应该专注于打开文件并以一种高效且符合python的方式读取其内容。下面是我个人不喜欢的一个例子:

1
2
3
4
5
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 '。"一旦密码进去了此语句已运行完毕，文件将自动关闭。

1
2
3
4
# 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()方法如下:

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

最终产品:

1
2
3
4
5
6
7
# 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()

测试代码:

文本文件内容:

1
2
3
4
     A fost odat? ca-n povesti,
     A fost ca niciodat?,
     Din rude m?ri ?mp?r?testi,
     O prea frumoas? fat?.

打印测试语句:

1
2
3
4
5
6
7
8
    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字符不同，外观不同):

1
2
3
4
5
6
7
8
     ['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?.

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

打开文件读取文件将内容存储为列表

幸运的是，Python使这些事情变得非常容易，所以将文件读入列表的捷径是:

1
lst = list(open(filename))

不过，我将添加更多的解释。

打开文件

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

文件名模式缓冲(在这个答案中我将忽略这个参数)

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

1
2
3
4
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或显式传递:

1
2
open(filename)
open(filename, 'r')

两者都将以只读模式打开文件。如果你想在Windows上读取二进制文件，你需要使用模式rb:

1
open(filename, 'rb')

在其他平台上，'b'(二进制模式)被简单地忽略。

现在我已经展示了如何处理open这个文件，让我们讨论一下您总是需要再次处理close这个事实。否则，它将保持文件的打开文件句柄，直到进程退出(或者Python将文件句柄丢弃)。

而你可以用:

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

当open和close之间的某个对象抛出异常时，将无法关闭文件。你可以使用try和finally来避免这种情况:

1
2
3
4
5
6
f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

但是Python提供了语法更漂亮的上下文管理器(但是对于open，它几乎与上面的try和finally相同):

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

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

读取文件

好了，你已经打开了文件，现在怎么读呢?

函数返回一个file对象，它支持python的迭代协议。每次迭代都会给你一行:

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

这将打印文件的每一行。但是请注意，每一行的末尾都包含一个换行符
(您可能想要检查您的Python是否使用了通用换行支持—否则您还可以在Windows上使用

或在Mac上使用
作为换行)。如果你不想这样，你可以简单地删除最后一个字符(或Windows上的最后两个字符):

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

但最后一行不一定有换行符，所以不应该用它。可以检查它是否以换行符结尾，如果以换行符结尾，则删除它:

1
2
3
4
5
6
with open(filename) as f:
    for line in f:
        if line.endswith('
'):
            line = line[:-1]
        print(line)

但你可以简单地删除字符串末尾的所有空格(包括
字符)，这也会删除所有其他尾随的空格，所以如果这些空格很重要，你必须小心:

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

但是，如果行以

结束(Windows"newlines")，那么.rstrip()也将处理
!

将内容存储为列表

现在您已经知道了如何打开文件并读取它，现在是时候将内容存储到列表中了。最简单的选择是使用list函数:

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

如果你想去掉后面的换行符，你可以使用列表理解:

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

或者更简单:file对象的.readlines()方法默认返回一行list:

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

这还将包括尾随的换行符，如果您不需要它们，我建议使用[line.rstrip() for line in f]方法，因为它避免了在内存中保留两个包含所有行的列表。

还有一个额外的选项来获得想要的输出，但是它相当"次优":read一个字符串中的完整文件，然后在换行:

1
2
3
with open(filename) as f:
    lst = f.read().split('
')

或者:

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

因为没有包含split字符，所以这些自动处理尾随的换行。然而，它们并不理想，因为您将文件作为字符串和行列表保存在内存中!

总结打开文件时使用with open(...) as f，因为您不需要亲自关闭文件，即使发生了一些异常，它也会关闭文件。file对象支持迭代协议，因此逐行读取文件与for line in the_file_object:一样简单。始终浏览文档以找到可用的函数/类。大多数时候，有一个完美的匹配的任务，或至少一个或两个好的。在这种情况下，最明显的选择是readlines()，但是如果您想在将行存储到列表之前处理它们，我建议您使用一个简单的列表理解。

相关讨论

我会这样做。

1
2
3
4
lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)
相关讨论

这里还有一个选项是对文件使用列表理解;

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

这应该是更有效的方法，因为大部分工作是在Python解释器中完成的。

相关讨论

另一个选项是numpy.genfromtxt，例如:

1
2
3
import numpy as np
data = np.genfromtxt("yourfile.dat",delimiter="
")

这将使data成为一个NumPy数组，其行数与文件中的行数相同。

如果你想从命令行或stdin中读取文件，你也可以使用fileinput模块:

1
2
3
4
5
6
7
8
# reader.py
import fileinput

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

fileinput.close()

将文件像这样传递给它:

1
$ python reader.py textfile.txt

更多信息请访问:http://docs.python.org/2/library/fileinput.html

最简单的方法

一个简单的方法是:

将整个文件作为字符串读取逐行分割字符串

在一行中，这将给出:

1
lines = open('C:/path/file.txt').read().splitlines()
用python2和python3读写文本文件;它适用于Unicode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/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('
'.join(lines))

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

print(lines == read_lines)

事情要注意:

with是一个所谓的上下文管理器。它确保打开的文件再次被关闭。这里所有简单地生成.strip()或.rstrip()的解决方案都无法复制lines，因为它们也会删除空白。

公共文件结尾

.txt

更高级的文件写入/读取CSV:超简单格式(read &写)JSON:用于编写人类可读的数据;非常常用(读&放;写)YAML: YAML是JSON的一个超集，但是更容易读(读&放大;JSON和YAML的编写、比较)pickle: Python序列化格式(read &写)MessagePack (Python包):更紧凑的表示(read &写)HDF5 (Python包):适合矩阵(读&放;写)XML:也存在*叹气* (read &写)

对于你的申请，以下几点可能很重要:

其他编程语言的支持阅读/写作表现密实度(文件大小)

参见:数据序列化格式的比较

如果您正在寻找一种生成配置文件的方法，那么您可能想要阅读我的用Python编写的简短文章配置文件。

在Python 3.4中引入的pathlib有一个非常方便的方法从文件中读取文本，如下:

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

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

pathlib里面有很多方便的东西。read_text是友好和简洁的，您不必担心打开和关闭文件。如果您只需要一次性读取所有文件，那么这是一个不错的选择。

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

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

1
2
for line in out:
    print line

或

1
2
for line in f:
    print line

你会得到同样的结果。

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

1
2
3
4
5
6
inp ="file.txt"
data = open(inp)
dat = data.read()
lst = dat.splitlines()
print lst
# print(lst) # for python 3

在输出中，您将得到行列表。

一个真正简单的方法:

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

如果你想让它成为一个成熟的程序，请输入以下内容:

1
2
3
4
5
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文件。

你可以打开你的文件阅读使用:

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

列表lines将包含作为单个元素的所有行，当Python从0开始计数时，您可以使用lines["linenumber-1"]调用特定的元素。

相关讨论

如果你想要面临一个非常大的/大量文件和想读得更快(想象你在一个Topcoder / Hackerrank编码竞争),你可能会相当大一部分行读入内存缓冲区,而不是在文件级别逐行进行迭代。

1
2
3
4
5
6
7
8
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没有原生数组数据结构。但是它支持列表数据结构，使用起来比数组简单得多。

1
2
3
4
array = [] #declaring a list with name '**array**'
with open(PATH,'r') as reader :
    for line in reader :
        array.append(line)
相关讨论

你可以很容易地做到这一点，由以下一段代码:

1
lines = open(filePath).readlines()
相关讨论

用这个:

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

data是一种数据aframe类型，使用值来获取ndarray。您还可以使用array.tolist()获得列表。

您还可以在NumPy中使用loadtxt命令。这比genfromtxt检查更少的条件，所以它可能更快。

1
2
3
import numpy
data = numpy.loadtxt(filename, delimiter="
")

最简单的方法是:

1
lines = list(open('filename'))

或

1
lines = tuple(open('filename'))

或

1
lines = set(open('filename'))

在使用set的情况下，我们必须记住，我们没有保留行顺序并删除重复的行。

看看这个小片段

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

或

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

参考文献

<

大纲和总结/ hh2 >

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

我将在下面解释每种方法的用例。

In Python, how do I read a file line-by-line?

这是个很好的问题。首先，让我们创建一些示例数据:

1
2
3
4
from pathlib import Path
Path('filename').write_text('foo
bar
baz')

文件对象是惰性迭代器，因此只需对其进行迭代。

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

或者，如果您有多个文件，使用fileinput.input，另一个懒惰的迭代器。只有一个文件:

1
2
3
4
import fileinput

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

或者对于多个文件，传递一个文件名列表:

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

同样，上面的f和fileinput.input都是/返回惰性迭代器。您只能使用一个迭代器一次，所以为了提供函数代码，同时避免冗长，我将使用稍微简洁一点的fileinput.input(filename)，这是本文的重点。

In Python, how do I read a file line-by-line into a list?

但出于某种原因你想把它列在列表里?如果可能的话，我会尽量避免。但如果你坚持……只需将fileinput.input(filename)的结果传递给list:

1
list(fileinput.input(filename))

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

有两种方法可以访问这个file对象。一种方法是将文件名传递给open内置程序:

1
2
3
4
filename = 'filename'

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

或者使用来自pathlib模块的新Path对象(我已经非常喜欢它，并将从这里开始使用):

1
2
3
4
5
6
from pathlib import Path

path = Path(filename)

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

list还将使用文件迭代器并返回一个列表——这也是一个非常直接的方法:

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

如果您不介意在拆分之前将整个文本作为一个字符串读入内存，那么您可以使用Path对象和splitlines() string方法作为一行代码来实现这一点。默认情况下，splitlines删除新行:

1
path.read_text().splitlines()

如果您想保留换行，传递keepends=True:

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

I want to read the file line by line and append each line to the end of the list.

考虑到我们已经用几种方法轻松地演示了最终结果，现在要求这样做有点傻。但是您可能需要在列出列表时对这些行进行过滤或操作，所以让我们来处理这个请求。

使用list.append可以让你在添加之前过滤或操作每一行:

1
2
3
4
5
line_list = []
for line in fileinput.input(filename):
    line_list.append(line)

line_list

使用list.extend会更直接一些，如果你有一个预先存在的列表，也许会有用:

1
2
3
line_list = []
line_list.extend(fileinput.input(filename))
line_list

或者更通俗地说，我们可以使用列表理解，并在其中映射和过滤(如果需要的话):

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

或者更直接地，要关闭这个圆圈，只需将它传递给list，就可以直接创建一个新的list，而不需要对行进行操作:

1
list(fileinput.input(filename))

结论

您已经看到了将文件中的行放入列表的许多方法，但是我建议您避免将大量数据物化到列表中，而是尽可能使用Python的延迟迭代来处理数据。

也就是说，更喜欢fileinput.input或with path.open() as f。

命令行版本

1
2
3
4
5
6
7
8
9
#!/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("
")
print(arr)

运行:

1
python3 somefile.py input_file_name.txt

我喜欢用下面这些。马上读台词。

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

或者使用列表理解:

1
contents = [line.strip() for line in open(filepath, 'r').readlines()]
相关讨论

我将尝试下面提到的方法之一。我使用的示例文件名为dummy.txt。你可以在这里找到这个文件。我假定该文件与代码位于同一个目录中(您可以更改fpath以包含正确的文件名和文件夹路径)。

在下面的两个例子中，您想要的列表由lst给出。

1.>第一个方法:

1
2
3
4
5
6
fpath = 'dummy.txt'
with open(fpath,"r") as f: lst = [line.rstrip('
 \t') for line in f]

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

2.在第二种方法中，可以使用csv。Python标准库的reader模块:

1
2
3
4
5
6
7
8
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所花费的时间几乎相等。

相关讨论

如果文档中还有空行，我喜欢在内容中读取并通过filter传递它，以防止空字符串元素

1
2
with open(myFile,"r") as f:
    excludeFileContent = list(filter(None, f.read().splitlines()))