Если вы хотите обратиться к одному и тому же объекту, просто используйте «self»:
class A:
def some_func(self):
another_func(self)
Если вы хотите создать новый объект того же класса, просто выполните его:
class A:
def some_func(self):
foo = A()
Если вы хотите получить доступ к объекту класса metaclass (скорее всего, не то, что вы хотите), снова выполните его:
class A:
def some_func(self):
another_func(A) # note that it reads A, not A()
with open(filename) 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]
Используйте это:
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()
.
Если вы хотите получить очень большой / огромный файл и хотите читать быстрее (представьте, что вы участвуете в конкурсе по кодированию 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)
#!/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
С помощью 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
выше оба являются / return lazy итераторы. Вы можете использовать итератор только один раз, поэтому для обеспечения функционального кода, избегая многословия, я буду использовать несколько более краткий 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
(который я очень полюбил и буду использовать с этого момента) ):
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
было бы немного более прямым и, возможно, полезным, если у вас уже есть существующий list:
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
красиво и лаконично, и вам не нужно беспокоиться об открытии и закрытии файла. Если все, что вам нужно сделать с файлом, это прочитать все сразу, это хороший выбор.
Вот еще один вариант, используя списки в файлах:
lines = [line.rstrip() for line in open('file.txt')]
Это должно быть более эффективным способом, так как большая часть работы выполняется внутри интерпретатора Python.
Вот класс Python (3) помощника library s>, который я использую для упрощения файлового ввода-вывода:
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
, например this:
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
.
Если вы хотите, чтобы \n
было включено:
with open(fname) as f:
content = f.readlines()
Если вы не хотите, чтобы \n
было включено:
with open(fname) as f:
content = f.read().splitlines()
Это более явно, чем необходимо, но делает то, что вы хотите.
with open("file.txt", "r") as ins:
array = []
for line in ins:
array.append(line)
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
вы получите те же результаты.
Если вы хотите прочитать файл из командной строки или из 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
Чистый и 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ã.
Согласно Методы Файловых Объектов , самый простой способ конвертировать текстовый файл в list
:
with open('file.txt') as f:
my_list = list(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().split("\n") # Create a list containing all lines
f.close() # Close file
Это даст "массив" строк из файла.
lines = tuple(open(filename, 'r'))
open
возвращает файл, по которому можно выполнять итерации. Когда вы выполняете итерацию по файлу, вы получаете строки из этого файла. tuple
может принимать итератор и инстанцировать экземпляр кортежа из переданного ему итератора. lines
- кортеж, созданный из строк файла.
См. Input and Ouput:
with open('filename') as f:
lines = f.readlines()
или с удалением символа новой строки:
lines = [line.rstrip('\n') for line in open('filename')]