otwórz czytaj i zamknij plik w 1 linii kodu

Teraz używam:

pageHeadSectionFile = open('pagehead.section.htm','r')
output = pageHeadSectionFile.read()
pageHeadSectionFile.close()

Ale żeby kod wyglądał lepiej, mogę:

output = open('pagehead.section.htm','r').read()

W przypadku korzystania z powyższej składni, jak zamknąć plik, aby zwolnić zasoby systemowe?

Naprawdę nie musisz go zamykać - Python zrobi to automatycznie podczas czyszczenia pamięci lub przy wyjściu z programu. Ale jak zauważył @delnan, lepiej jest jawnie zamknąć go z różnych powodów.

Co więc możesz zrobić, aby było krótkie, proste i wyraźne:

with open('pagehead.section.htm','r') as f:
    output = f.read()

Myślę, że to tylko dwie linijki i całkiem czytelne.

Moduł Python Standard Library Pathlib robi to, czego szukasz:

Path('pagehead.section.htm').read_text()

Nie zapomnij zaimportować ścieżki:

jsk@dev1:~$ python3
Python 3.5.2 (default, Sep 10 2016, 08:21:44)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from pathlib import Path
>>> (Path("/etc") / "hostname").read_text()
'dev1.example\n'

W Pythonie 27 zainstaluj backported pathliblubpathlib2

Używając CPythona, twój plik zostanie zamknięty natychmiast po wykonaniu linii, ponieważ obiekt pliku jest natychmiast usuwany. Są jednak dwie wady:

1. W implementacjach Pythona innych niż CPython, plik często nie jest natychmiast zamykany, ale raczej w późniejszym czasie, poza twoją kontrolą.

2. W Pythonie 3.2 lub nowszym spowoduje to wyświetlenie pliku ResourceWarning, jeśli jest włączony.

Lepiej zainwestować jedną dodatkową linię:

with open('pagehead.section.htm','r') as f:
    output = f.read()

Zapewni to prawidłowe zamknięcie pliku w każdych okolicznościach.

Nie ma potrzeby importowania żadnych specjalnych bibliotek, aby to zrobić.

Użyj normalnej składni, a otworzy plik do odczytu, a następnie zamknie go.

with open("/etc/hostname","r") as f: print f.read() 

lub

with open("/etc/hosts","r") as f: x = f.read().splitlines()

co daje tablicę x zawierającą wiersze i można ją wydrukować w następujący sposób:

for line in x: print line

Te jednowierszowe są bardzo pomocne w konserwacji - zasadniczo dokumentują się samodzielnie.

Możesz użyć withinstrukcji i zapisać dwa kroki w jednej linii:

>>> with open('pagehead.section.htm', 'r') as fin: output = fin.read();
>>> print(output)
some content

withOświadczenie zadba, aby zadzwonić do __exit__funkcji danego obiektu, nawet jeśli coś złego się wydarzyło w kodzie; jest zbliżona do try... finallyskładni. Dla obiektu zwróconego przez open, __exit__odpowiada zamknięciu pliku.

Ta instrukcja została wprowadzona w Pythonie 2.6.

użyj ilio : (inline io):

tylko jedno wywołanie funkcji zamiast file open (), read (), close ().

from ilio import read

content = read('filename')

with open('pagehead.section.htm')as f:contents=f.read()

Myślę, że najbardziej naturalnym sposobem osiągnięcia tego jest zdefiniowanie funkcji.

def read(filename):
    f = open(filename, 'r')
    output = f.read()
    f.close()
    return output

Następnie możesz wykonać następujące czynności:

output = read('pagehead.section.htm')

Często robię coś takiego, gdy potrzebuję kilku wierszy otaczających coś, co grepowałem w pliku dziennika:

$ grep -n "xlrd" requirements.txt | awk -F ":" '{print $1}'
54

$ python -c "with open('requirements.txt') as file: print ''.join(file.readlines()[52:55])"
wsgiref==0.1.2
xlrd==0.9.2
xlwt==0.7.5

Za pomocą more_itertools.with_itermożna otwierać, czytać, zamykać i przypisywać odpowiednik outputw jednej linii (z wyłączeniem instrukcji import):

import more_itertools as mit


output = "".join(line for line in mit.with_iter(open("pagehead.section.htm", "r")))

Chociaż jest to możliwe, szukałbym innego podejścia niż przypisanie zawartości pliku do zmiennej, tj. Leniwej iteracji - można to zrobić za pomocą tradycyjnego withbloku lub w powyższym przykładzie, usuwając join()i iterując output.

Jeśli chcesz tego ciepłego i rozmytego uczucia, po prostu idź z tym .

W przypadku Pythona 3.6 uruchomiłem te dwa programy na nowym początku IDLE, dając środowiska wykonawcze:

0.002000093460083008  Test A
0.0020003318786621094 Test B: with guaranteed close

Więc nie ma to wielkiej różnicy.

#--------*---------*---------*---------*---------*---------*---------*---------*
# Desc: Test A for reading a text file line-by-line into a list
#--------*---------*---------*---------*---------*---------*---------*---------*

import sys
import time

#                                  # MAINLINE
if __name__ == '__main__':
    print("OK, starting program...")

    inTextFile = '/Users/Mike/Desktop/garbage.txt'

#                                  # Test: A: no 'with;
    c=[]
    start_time = time.time()
    c = open(inTextFile).read().splitlines()
    print("--- %s seconds ---" % (time.time() - start_time))

    print("OK, program execution has ended.")
    sys.exit()                     # END MAINLINE

WYNIK:

OK, starting program...
--- 0.002000093460083008 seconds ---
OK, program execution has ended.

#--------*---------*---------*---------*---------*---------*---------*---------*
# Desc: Test B for reading a text file line-by-line into a list
#--------*---------*---------*---------*---------*---------*---------*---------*

import sys
import time

#                                  # MAINLINE
if __name__ == '__main__':
    print("OK, starting program...")

    inTextFile = '/Users/Mike/Desktop/garbage.txt'

#                                  # Test: B: using 'with'
    c=[]
    start_time = time.time()
    with open(inTextFile) as D: c = D.read().splitlines()
    print("--- %s seconds ---" % (time.time() - start_time))

    print("OK, program execution has ended.")
    sys.exit()                     # END MAINLINE

WYNIK:

OK, starting program...
--- 0.0020003318786621094 seconds ---
OK, program execution has ended.