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

Вот вспомогательный класс Python (3) библиотеки , который я использую для упрощения файлового ввода-вывода:

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.

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

lines = list(open('filename'))

или

lines = tuple(open('filename'))

или

lines = set(open('filename'))

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

Ниже я добавил важное дополнение от @MarkAmery :

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

В CPython (обычная реализация Python , которую использует большинство людей), это не проблема, так как файловый объект будет немедленно удален из мусора, и это будет закройте файл, но, тем не менее, обычно рекомендуется делать что-то вроде :

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

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

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

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

Я бы попробовал один из нижеперечисленных способов. Файл примера, который я использую, имеет имя 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 <57826354328226> стандартной библиотеки 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.']

Схема и резюме

С помощью 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) where по поводу отсюда.

Как в 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.

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

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

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

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

Мне нравится использовать следующее. Немедленное чтение строк.

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

Или используя понимание списка:

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

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

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

К счастью, 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(), но если вы хотите обработать строки перед сохранением их в списке, я бы рекомендовал простое понимание списка.

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

Версия командной строки

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

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

line 1
line 2
line 3

Мы можем использовать этот скрипт Python в том же каталоге, что и txt выше

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

Или:

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

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

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

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

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

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

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

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

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 проход. Обычно так работают общие парсеры.

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

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

Согласно методам 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

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

Простой способ:

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

Этот код прочитает весь файл в память и удалит все пробелы (новые строки и пробелы) в конце каждой строки:

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

Если вы работаете с большим файлом, вам следует вместо этого прочитать и обработать его построчно:

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

В Python 3.8 и выше вы можете использовать цикл while с оператором моржа следующим образом:

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

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

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

См. Ввод и вывод:

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

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

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

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

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

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

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

open возвращает файл, который можно повторять. Когда вы перебираете файл, вы получаете строки из этого файла. tuple может взять итератор и создать для вас экземпляр кортежа из итератора, который вы ему предоставили. lines - кортеж, созданный из строк файла.