복붙노트

[PYTHON] 한 줄씩 파일을 한 줄씩 읽는 방법?

PYTHON

한 줄씩 파일을 한 줄씩 읽는 방법?

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

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

해결법

  1. ==============================

    1.

    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]
  2. ==============================

    2.입력 및 출력을 참조하십시오.

    입력 및 출력을 참조하십시오.

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

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

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

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

  3. ==============================

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

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

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

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

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

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

    5.당신이 원하면 \ n 포함 :

    당신이 원하면 \ n 포함 :

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

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

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

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

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

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

    (수퍼맨 클래스의 구현은 당신을위한 연습 과제로 남아 있습니다.)

    이것은 어떤 파일 크기에서도 잘 작동 할 것이고 단지 1 패스만으로 파일을 검토 할 것입니다. 이것은 일반적으로 범용 파서가 작동하는 방법입니다.

  7. ==============================

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

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

    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 open('file.txt') as fp:
    lines = fp.read().split("\n")
  8. ==============================

    8.목록에 데이터

    목록에 데이터

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

    line 1
line 2
line 3

    >>> 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)
  9. ==============================

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

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

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

    10.목록에 파일 줄 읽기의 깨끗하고 Pythonic 한 방법

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

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

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

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

    lst = list(open(filename))

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

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

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

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

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

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

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

    open(filename, 'rb')

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

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

    사용할 수있는 동안 :

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

    열기와 닫기 사이에 예외가 발생하면 파일을 닫지 못합니다. try 및 finally를 사용하여이를 피할 수 있습니다.

    f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

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

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

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

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

    open 함수는 파일 객체를 반환하고 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!

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

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

    후행 줄 바꿈을 제거하려는 경우 대신 목록 이해를 사용할 수 있습니다.

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

    또는 더 간단하게 : 파일 객체의 .readlines () 메소드는 기본적으로 줄의 목록을 반환합니다 :

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

    이것은 또한 줄 바꿈 문자를 포함 할 것입니다. 만약 당신이 그것을 원하지 않는다면, 메모리에있는 모든 줄을 담고있는 두리스트를 유지하는 것을 피하기 때문에 [line.rstrip () for f in] 접근법을 추천 할 것입니다.

    원하는 출력을 얻는 추가 옵션이 있습니다. 그러나 "차선책"입니다. 전체 파일을 문자열로 읽은 다음 개행 문자로 나눕니다.

    with open(filename) as f:
    lst = f.read().split('\n')

    또는:

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

    분할 문자가 포함되어 있지 않기 때문에 후행 줄 바꿈을 자동으로 처리합니다. 그러나 파일을 문자열로 유지하고 메모리의 행 목록으로 유지하기 때문에 이상적이지 않습니다!

  12. ==============================

    12.나는 이렇게 할거야.

    나는 이렇게 할거야.

    lines = []
with open("myfile.txt") as f:
    for line in f:
        lines.append(line)
  13. ==============================

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

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

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

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

  14. ==============================

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

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

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

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

  15. ==============================

    15.명령 행이나 stdin에서 파일을 읽으려면 fileinput 모듈을 사용할 수도 있습니다 :

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

  16. ==============================

    16.가장 간단한 방법

    가장 간단한 방법

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

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

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

    17.

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

    주의 사항 :

    .txt

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

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

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

  18. ==============================

    18.

    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

    당신은 같은 결과를 얻을 것이다.

  19. ==============================

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

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

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

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

  20. ==============================

    20.진정한 쉬운 방법 :

    진정한 쉬운 방법 :

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

    본격적인 프로그램으로 만들려면 다음을 입력하십시오.

    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 파일을 제대로 읽지 않습니다.

  21. ==============================

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

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

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

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

  22. ==============================

    22.매우 크고 거대한 파일에 직면하고 더 빠르게 읽을 수 있기를 원한다면 (Topcoder / Hackerrank 코딩 경쟁에 있다고 상상해보십시오), 훨씬 큰 덩어리의 줄을 한 번에 메모리 버퍼로 읽을 수 있습니다. 파일 수준에서 줄 단위로 반복하십시오.

    매우 크고 거대한 파일에 직면하고 더 빠르게 읽을 수 있기를 원한다면 (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)
  23. ==============================

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

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

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

    24.Python 3.4에서 소개 된 pathlib는 다음과 같이 파일에서 텍스트를 읽는 데 매우 편리한 방법을 제공합니다.

    Python 3.4에서 소개 된 pathlib는 다음과 같이 파일에서 텍스트를 읽는 데 매우 편리한 방법을 제공합니다.

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

    (splitlines 호출은 파일의 전체 내용을 포함하는 문자열에서 파일의 행 목록으로 바꾸는 것입니다.

    pathlib에는 많은 편리한 기능이 있습니다. read_text는 훌륭하고 간결하며 파일을 열고 닫을 때 걱정할 필요가 없습니다. 파일과 관련된 모든 작업을 한꺼번에 읽을 수 있다면 좋은 선택입니다.

  25. ==============================

    25.이것을 사용하십시오 :

    이것을 사용하십시오 :

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

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

  26. ==============================

    26.다음 코드로 쉽게 할 수 있습니다.

    다음 코드로 쉽게 할 수 있습니다.

    lines = open(filePath).readlines()
  27. ==============================

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

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

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

    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
  29. ==============================

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

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

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

    또는 목록 이해력 사용 :

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

    30.파일 이름을 사용하거나 Path (파일 이름) 객체에서 파일을 처리하거나 직접 open (파일 이름)을 f로 사용하여 다음 중 하나를 수행합니다.

    파일 이름을 사용하거나 Path (파일 이름) 객체에서 파일을 처리하거나 직접 open (파일 이름)을 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

    다시 말하지만, f와 fileinput.input은 둘 다 / return lazy iterator입니다. 한 번만 이터레이터를 사용할 수 있기 때문에 자세한 기능을 피하면서 기능 코드를 제공 할 수 있습니다. 여기서 좀 더 간결한 fileinput.input (filename)을 사용합니다. 여기서 apropos를 사용하십시오.

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

    list(fileinput.input(filename))

    또 다른 직접적인 대답은 파일 내용을 반환하는 f.readlines를 호출하는 것입니다 (옵션 힌트 수까지 가능하므로 여러 목록으로 구분할 수 있습니다).

    이 파일 객체를 두 가지 방법으로 가져올 수 있습니다. 한 가지 방법은 파일 이름을 오픈 내장 명령에 전달하는 것입니다.

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

    리스트는 또한 파일 반복자를 소비하고리스트를 리턴 할 것이다 - 꽤 직접적인 방법이다.

    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 또는 path.open ()을 f로 사용하는 것이 좋습니다.

    31. from https://stackoverflow.com/questions/3277503/how-to-read-a-file-line-by-line-into-a-list by cc-by-sa and MIT license

'PYTHON' 카테고리의 다른 글

[PYTHON] BeautifulSoup4가 숨어있는 곳은 어디입니까?  (0) 2018.11.16
[PYTHON] 어떻게하면 파이썬에서 여러 개의 빈 목록을 만들 수 있습니까?  (0) 2018.11.16
[PYTHON] 어떻게 파이썬에서 HTTP 패킷을 냄새 맡기?  (0) 2018.11.16
[PYTHON] Pandas : 여러 DataFrame에 존재하지 않는 행을 여러 열로 찾습니다.  (0) 2018.11.16
[PYTHON] 파이썬으로 rss 리다이렉트하기 / urllib2  (0) 2018.11.16
,

티스토리툴바