python 행렬 파이썬에서 한 줄씩 파일을 목록으로 읽으려면 어떻게해야합니까?




파이썬 행렬 읽기 (24)

어떻게 파이썬에서 파일의 모든 라인을 읽고 각 라인을리스트에 요소로 저장합니까?

줄 단위로 파일을 읽고 각 줄을 목록 끝에 추가하려고합니다.


목록에 데이터

다음과 같은 데이터가 포함 된 텍스트 파일이 있다고 가정합니다.

텍스트 파일 내용 :

line 1
line 2
line 3
  • 같은 디렉터리에서 cmd를 엽니 다 (마우스 오른쪽 단추로 클릭하고 cmd 또는 PowerShell 선택).
  • 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']

또는...

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

또는...

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

당신이 원하면 \n 포함 :

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

\n 포함시키지 않으려면 :

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

다음을 사용하여 파일을 열어 읽을 수 있습니다.

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

리스트 lines 은 모든 라인을 개별 요소로 포함 할 것이고 파이썬은 0부터 카운팅하기 때문에 lines["linenumber-1"] 을 사용하여 특정 요소를 호출 할 수 있습니다.


명령 행이나 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 하십시오.


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] 

파일에 대한 목록 내포물을 사용하여 또 하나의 옵션이 있습니다.

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

이것은 대부분의 작업이 파이썬 인터프리터 내에서 이루어 지므로보다 효율적인 방법이어야합니다.


목록에 파일 줄 읽기의 깨끗하고 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ã.

그러면 파일의 "배열"이 생깁니다.

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

제안 된대로 간단히 다음을 수행 할 수 있습니다.

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 패스만으로 파일을 검토 할 것입니다. 이것은 일반적으로 범용 파서가 작동하는 방법입니다.


NumPy에서 loadtxt 명령을 사용할 수도 있습니다. 이것은 genfromtxt보다 적은 조건을 검사하기 때문에 더 빠를 수 있습니다.

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

명령 행 버전

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

이것은 open 명령을 캡슐화해야합니다.

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

파일을 닫을 필요가 없다면이 한 줄짜리 프로그램이 작동합니다.

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

다른 옵션은 numpy.genfromtxt 입니다 (예 :

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

그러면 파일에있는 행 수만큼 data 가 NumPy 배열이됩니다.


splitlines () 함수 만 사용하면됩니다. 다음은 그 예입니다.

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

출력에는 라인 목록이 있습니다.


개요 및 요약

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 사용

아래의 각각에 대한 사용 사례를 설명합니다.

파이썬에서 파일을 한 줄씩 어떻게 읽습니까?

이것은 훌륭한 질문입니다. 먼저 몇 가지 샘플 데이터를 만듭니다.

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 lazy iterator입니다. 한 번만 이터레이터를 사용할 수 있기 때문에 자세한 기능을 피하면서 기능 코드를 제공 할 수 있습니다. 여기서 좀 더 간결한 fileinput.input(filename) 을 사용합니다. 여기서 apropos를 사용하십시오.

파이썬에서 한 줄씩 파일을 목록으로 읽으려면 어떻게해야 합니까?

아,하지만 왠지 명단에 넣고 싶습니까? 가능하다면 나는 그것을 피할 것입니다. 그러나 주장하는 경우 ... fileinput.input(filename) 의 결과를 list 전달 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))

결론

파일에서리스트로 줄을 만드는 많은 방법을 보았지만 목록에 많은 양의 데이터가 나타나지 않도록하고 가능하다면 파이썬의 느린 반복을 사용하여 데이터를 처리하는 것이 좋습니다.

즉, fileinput.input 또는 with path.open() as f 좋습니다.


이것을 사용하십시오 :

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

datadata 프레임 유형이며 값을 사용하여 ndarray를 가져옵니다. array.tolist() 를 사용하여 목록을 가져올 수도 있습니다.


이것은 필요한 것보다 분명하지만 당신이 원하는 것을합니다.

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

Python 2 및 Python 3로 텍스트 파일을 읽고 씁니다. 그것은 유니 코드와 함께 작동합니다.

#!/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 : 파이썬 직렬화 형식 ( 읽기 & 쓰기 )
  • MessagePack ( Python 패키지 ) :보다 간결한 표현 ( 읽기 및 쓰기 )
  • HDF5 ( Python 패키지 ) : 행렬에 좋음 ( 읽기 및 쓰기 )
  • XML : 역시 존재 * 한숨 * ( read 및 write )

응용 프로그램의 경우 다음 사항이 중요 할 수 있습니다.

  • 다른 프로그래밍 언어 지원
  • 읽기 / 쓰기 성능
  • 압축률 (파일 크기)

관련 항목 : 데이터 직렬화 형식의 비교

오히려 설정 파일을 만드는 방법을 찾고있는 경우, 필자의 저서 인 Python의 설정 파일 을 읽고 싶을 것입니다.


입력 및 출력 참조 :

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

또는 개행 문자를 제거하는 방법 :

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

편집자 주 : Janus Troelsen의 코멘트에 의해 암시 된이 답변의 원래 공백 제거 명령 line.strip()후행 공백뿐만 아니라 앞뒤 공백을 모두 제거 합니다 .


가장 간단한 방법

간단한 방법은 다음과 같습니다.

  1. 전체 파일을 문자열로 읽습니다.
  2. 줄 단위로 문자열을 나눕니다.

한 줄에서는 다음과 같이 나타낼 수 있습니다.

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

파일을 목록으로 읽으려면 다음 세 가지 작업을 수행해야합니다.

  • 파일 열기
  • 파일 읽기
  • 목록으로 내용 저장

다행스럽게도 파이썬은 파일을 목록으로 읽어들이는 가장 짧은 방법은 다음과 같습니다.

lst = list(open(filename))

그러나 나는 더 많은 설명을 추가 할 것이다.

파일 열기

특정 파일을 열고 싶다고 가정하고 파일 핸들 (또는 파일 같은 핸들)을 직접 다루지는 않습니다. 파이썬에서 파일을 여는 가장 보편적으로 사용되는 함수는 open 되어 있으며 파이썬 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)

파일 확장명을 지정해야합니다. 탐색기에서 볼 때 .txt 또는 .doc 등의 파일 확장명 이 기본적으로 숨겨져 있기 때문에 Windows 사용자에게 특히 중요합니다.

두 번째 인수는 mode . 기본적으로 r 은 "읽기 전용"을 의미합니다. 그게 바로 당신이 필요로하는 것입니다.

하지만 실제로 파일을 만들고 싶거나 파일에 쓰고 싶다면 다른 인수가 필요합니다. 당신이 개요를 원한다면 훌륭한 대답이 있습니다 .

파일을 읽으려면 mode 생략하거나 명시 적으로 전달할 수 있습니다.

open(filename)
open(filename, 'r')

둘 다 읽기 전용 모드로 파일을 엽니 다. Windows에서 이진 파일을 읽으려면 rb 모드를 사용해야합니다.

open(filename, 'rb')

다른 플랫폼에서는 'b' (바이너리 모드)가 무시됩니다.

이제 파일을 open 방법을 보여 주었으므로 항상 다시 close 한다는 사실에 대해 이야기 해 봅시다. 그렇지 않으면 프로세스가 종료되거나 파이썬이 파일 핸들을 garbages 할 때까지 파일 핸들을 파일에 대해 열린 상태로 유지합니다.

사용할 수있는 동안 :

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

그러나 파이썬은 문법 관리자가 더 깔끔한 문법을 ​​제공한다. (그러나 open 의 경우 try 와 거의 동일하다.)

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

마지막 접근법은 파이썬에서 파일을 여는 데 권장되는 접근법입니다!

파일 읽기

좋아요, 파일을 열었습니까? 이제 어떻게 읽습니까?

open 함수는 file 객체를 반환하고 Pythons 반복 프로토콜을 지원합니다. 각 반복마다 다음과 같은 줄을 제공합니다.

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

그러면 파일의 각 행이 인쇄됩니다. 그러나 각 줄에는 끝에 줄 바꿈 문자 \n 이 포함됩니다 (파이썬이 보편적 인 줄 바꿈 지원으로 빌드되었는지 확인하는 것이 좋습니다. 그렇지 않으면 Windows에서 \r\n 또는 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 "newlines")으로 .rstrip()\r !

목록으로 내용 저장

이제 파일을 열고 읽는 방법을 알았으므로 내용을 목록에 저장할 시간입니다. 가장 간단한 옵션은 list 함수를 사용하는 것입니다.

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] 접근법 [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() 이지만 목록에 저장하기 전에 행을 처리하려면 간단한 목록 이해를 권장합니다.

저는 다음을 사용하고 싶습니다. 즉시 라인을 읽으십시오.

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

또는 목록 이해력 사용 :

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

필자의 지식에 따르면 파이썬에는 네이티브 배열 데이터 구조가 없습니다. 그러나 배열보다 사용하기가 훨씬 쉬운 목록 데이터 구조를 지원합니다.

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




readlines