如何将文件逐行读取到列表中？

Question

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

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

Answer 1

此代码会将整个文件读入内存并删除每行末尾的所有空白字符（换行符和空格）：

with open(filename) as file:
    lines = [line.rstrip() for line in file]

如果您正在使用大文件，那么您应该逐行读取和处理它：

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

在 Python 3.8 及更高版本中，您可以将 while 循环与 walrus 运算符 像这样：

with open(filename) as file:
    while line := file.readline():
        print(line.rstrip())

根据您计划对文件执行的操作及其编码方式，您可能还需要手动设置 访问模式和字符编码：

with open(filename, 'r', encoding='UTF-8') as file:
    while line := file.readline():
        print(line.rstrip())

Answer 2

请参阅输入和输出：

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

或剥离换行符:

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

Answer 3

这比必要的更明确，但可以满足您的要求。

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

Answer 4

这将从文件中产生一个行“数组”。

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

open 返回一个可以迭代的文件。当您迭代文件时，您会从该文件中获取行。 tuple 可以获取一个迭代器，并从您提供的迭代器中为您实例化一个元组实例。 lines 是根据文件的行创建的元组。

Answer 5

根据Python的文件对象的方法，将文本文件转换为 list 的最简单方法是：

with open('file.txt') as f:
    my_list = list(f)
    # my_list = [x.rstrip() for x in f] # remove line breaks

• 演示

---

如果您只需要迭代文本文件行，您可以使用：

with open('file.txt') as f:
    for line in f:
       ...

---

旧答案：

使用 with 和 readlines() ：

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

如果您不关心关闭文件，则这一行行将起作用：

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

传统方式：

f = open('file.txt') # Open file on read mode
lines = f.read().splitlines() # List with stripped line-breaks
f.close() # Close file

Answer 6

如果您希望包含 \n：

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

如果您不想包含 \n：

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

Answer 7

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

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

Answer 8

有一个文本文件内容：

line 1
line 2
line 3

我们可以在上面的txt的同一目录中使用这个Python脚本

>>> with open("myfile.txt", encoding="utf-8") as file:
...     x = [l.rstrip("\n") 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())

或者：< /strong>

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

或：

def print_output(lines_in_textfile):
    print("lines_in_textfile =", lines_in_textfile)

y = [x.rstrip() for x in open("001.txt")]
print_output(y)

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

with open('001.txt', 'r', encoding='utf-8') as file:
    file = [x.rstrip("\n") for x in file]
    print_output(file)

输出：

lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']
lines_in_textfile = ['line 1', 'line 2', 'line 3']

Answer 9

Python 3.4 中引入的 pathlib 有一个非常方便的功能从文件中读取文本的方法，如下所示：（

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

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

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

Answer 10

要将文件读入列表，您需要执行三件事：

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

幸运的是，Python 使执行这些操作变得非常容易，因此将文件读入列表的最短方法是：

lst = list(open(filename))

但是我将添加更多解释。

打开文件

我假设您想要打开一个特定的文件，并且您不直接处理文件句柄（或类似文件的句柄）。在 Python 中打开文件最常用的函数是 open< /a>，在 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'（二进制模式）会被忽略。

---

现在我已经展示了如何打开文件，让我们谈谈您总是需要再次关闭它的事实。否则，它将保留文件的打开文件句柄，直到进程退出（或 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 对象，它支持Python的迭代协议。每次迭代都会给您一行：

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

这将打印文件的每一行。但请注意，每一行末尾都会包含一个换行符 \n （您可能需要检查您的 Python 是否是使用 通用换行符支持 - 否则您也可以在 Windows 上使用 \r\n 或 \r< /code> 在 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< /a> 函数：

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

如果您想删除尾随换行符，您可以使用列表理解来代替：

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

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

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

这还将包括尾随换行符，如果您不需要它们，我会推荐 [line.rstrip() for line in f] 方法，因为它避免保留两个包含所有行的列表记忆中的线条。

还有一个附加选项可以获取所需的输出，但它相当“次优”： 读取字符串中的完整文件，然后按换行符拆分：

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() ，但如果您想在将行存储到列表中之前对其进行处理，我会建议使用简单的列表理解。

Answer 11

将文件行读入列表的干净且 Python 的方式

---

首先，您应该专注于以高效且 Python 的方式打开文件并读取其内容。这是我个人不喜欢的方式的示例：

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]

• 输出（由于 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ã.

Answer 12

这是对文件使用列表理解的另一种选择；

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

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

Answer 13

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)

您会得到相同的结果。

Answer 14

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

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

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

Answer 15

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

更高级的文件写入/读取

• CSV：超级简单格式（读取和写入)
• JSON：非常适合写入人类可读的数据；非常常用（读取和写入）
• YAML：YAML 是 JSON 的超集，但更易于阅读（读取和写入，JSON 和YAML)
• pickle：一种 Python 序列化格式（读写）
• MessagePack （Python 包 >)：更紧凑的表示（读写）
• HDF5 (Python 包): 非常适合矩阵 (读写)
• XML：也存在*叹息* (阅读 & 写入）

对于您的应用程序，以下内容可能很重要：

• 其他编程语言的支持
• 读/写性能
• 紧凑性（文件大小）

另请参阅：数据序列化格式的比较

如果您想查看有关制作配置文件的方法，您可能需要阅读我的短文配置Python 中的文件。

Answer 16

如果您想从命令行或标准输入读取文件，您还可以使用 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

Answer 17

最简单的方法

一种简单的方法是：

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

在一行中，这将给出：

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

但是，这是非常低效的方法，因为这会在内存中存储内容的 2 个版本（对于小文件来说可能不是一个大问题，但仍然如此）。 [感谢马克·埃默里]。

有 2 种更简单的方法：

1. 将文件用作迭代器

lines = list(open('C:/path/file.txt'))
# ... or if you want to have a list without EOL characters
lines = [l.rstrip() for l in open('C:/path/file.txt')]

2. 如果您使用的是 Python 3.4 或更高版本，最好使用 pathlib 为您的文件创建一个路径，您可以将其用于程序中的其他操作：

from pathlib import Path
file_path = Path("C:/path/file.txt") 
lines = file_path.read_text().split_lines()
# ... or ... 
lines = [l.rstrip() for l in file_path.open()]

Answer 18

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

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

在输出中您将看到行列表。

Answer 19

如果您面临非常大/巨大的文件并且想要更快地阅读（想象一下您处于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)

Answer 20

最简单的方法有一些额外的好处：

lines = list(open('filename'))

or

lines = tuple(open('filename'))

or

lines = set(open('filename'))

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

下面我添加了来自@MarkAmery的重要补充：

由于您没有对文件对象调用 .close ，也没有使用 with 语句，因此在某些 Python 实现中文件在读取后可能不会关闭，并且您的进程将泄漏打开的文件句柄。

在CPython（大多数人使用的正常Python实现）中，这不是问题，因为文件对象将立即被垃圾收集，并且这将关闭文件，但通常认为最好的做法是执行以下操作：：

with open('filename') as f: lines = list(f) 

确保无论您使用什么Python实现，文件都会关闭。

Answer 21

使用这个：

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

Answer 22

如果文档中也有空行，我喜欢读取内容并将其传递给 filter 以防止空字符串元素

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

Answer 23

概要和总结

使用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)
• 迭代 < code>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) ，其中 apropos 来自此处。

在 Python 中，如何将文件逐行读取到列表中？

啊，但由于某种原因您希望将其放入列表中？如果可能的话我会避免这种情况。但如果你坚持...只需将 fileinput.input(filename) 的结果传递给 list：

list(fileinput.input(filename))

另一个直接的答案是调用 f.readlines >，它返回文件的内容（最多可选的提示个字符，因此您可以以这种方式将其分解为多个列表）。

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

filename = 'filename'

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

或者使用 pathlib 模块中的新 Path 对象（我非常喜欢它，将从这里开始使用） on):

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 即可直接创建一个新列表，而不需要对lines:

list(fileinput.input(filename))

结论

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

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

Answer 24

我会尝试下面提到的方法之一。我使用的示例文件的名称为 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 所需的时间几乎相等。

Answer 25

我喜欢使用以下内容。立即阅读台词。

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

或者使用列表理解：

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

Answer 26

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

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

Answer 27

这是一个 Python(3) 帮助器 library 类，我用它来简化文件 I/O：

import os

# handle files using a callback method, prevents repetition
def _FileIO__file_handler(file_path, mode, callback = lambda f: None):
  f = open(file_path, mode)
  try:
    return callback(f)
  except Exception as e:
    raise IOError("Failed to %s file" % ["write to", "read from"][mode.lower() in "r rb r+".split(" ")])
  finally:
    f.close()


class FileIO:
  # return the contents of a file
  def read(file_path, mode = "r"):
    return __file_handler(file_path, mode, lambda rf: rf.read())

  # get the lines of a file
  def lines(file_path, mode = "r", filter_fn = lambda line: len(line) > 0):
    return [line for line in FileIO.read(file_path, mode).strip().split("\n") if filter_fn(line)]

  # create or update a file (NOTE: can also be used to replace a file's original content)
  def write(file_path, new_content, mode = "w"):
    return __file_handler(file_path, mode, lambda wf: wf.write(new_content))

  # delete a file (if it exists)
  def delete(file_path):
    return os.remove() if os.path.isfile(file_path) else None

然后您将使用 FileIO.lines 函数，如下所示：

file_ext_lines = FileIO.lines("./path/to/file.ext"):
for i, line in enumerate(file_ext_lines):
  print("Line {}: {}".format(i + 1, line))

请记住mode（默认情况下为"r"）和filter_fn（默认情况下检查空行）参数是可选的。

您甚至可以删除 read、write 和 delete 方法，只保留 FileIO.lines，甚至可以将将其放入名为 read_lines 的单独方法中。

Answer 28

命令行版本

#!/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