apri leggi e chiudi un file in 1 riga di codice

Adesso uso:

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

Ma per migliorare l'aspetto del codice, posso fare:

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

Quando si utilizza la sintassi sopra, come si chiude il file per liberare risorse di sistema?

Non è necessario chiuderlo: Python lo farà automaticamente durante la garbage collection o all'uscita dal programma. Ma come ha notato @delnan, è meglio chiuderlo esplicitamente per vari motivi.

Quindi, cosa puoi fare per mantenerlo breve, semplice ed esplicito:

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

Ora sono solo due righe e piuttosto leggibili, credo.

Il modulo Pathlib della libreria standard Python fa quello che stai cercando:

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

Non dimenticare di importare Path:

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'

Su Python 27 installare backported pathlibopathlib2

Usando CPython, il tuo file verrà chiuso immediatamente dopo l'esecuzione della linea, poiché l'oggetto file viene immediatamente raccolto in modo errato. Ci sono due svantaggi, però:

1. Nelle implementazioni Python diverse da CPython, il file spesso non viene immediatamente chiuso, ma piuttosto in un secondo momento, al di fuori del tuo controllo.

2. In Python 3.2 o versioni successive, verrà generato un ResourceWarning, se abilitato.

Meglio investire una linea aggiuntiva:

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

Ciò assicurerà che il file sia chiuso correttamente in tutte le circostanze.

Non è necessario importare alcuna libreria speciale per farlo.

Usa la sintassi normale e aprirà il file per la lettura, quindi lo chiuderà.

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

o

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

che ti dà un array x contenente le linee e può essere stampato in questo modo:

for line in x: print line

Questi one-liner sono molto utili per la manutenzione, in pratica sono autodocumentati.

Quello che puoi fare è usare l' withistruzione e scrivere i due passaggi su una riga:

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

L' withistruzione avrà cura di chiamare la __exit__funzione dell'oggetto dato anche se nel tuo codice è successo qualcosa di brutto; è vicino alla try... finallysintassi. Per l'oggetto restituito da open, __exit__corrisponde alla chiusura del file.

Questa affermazione è stata introdotta con Python 2.6.

usa ilio : (inline io):

solo una chiamata di funzione invece del file open (), read (), close ().

from ilio import read

content = read('filename')

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

Penso che il modo più naturale per raggiungere questo obiettivo sia definire una funzione.

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

Quindi è possibile effettuare le seguenti operazioni:

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

Faccio spesso una cosa del genere quando devo inserire alcune righe intorno a qualcosa che ho inserito in un file di registro:

$ 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

Utilizzando more_itertools.with_iter, è possibile aprire, leggere, chiudere e assegnare un equivalente outputin una riga (esclusa la dichiarazione di importazione):

import more_itertools as mit


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

Per quanto possibile, cercherei un altro approccio diverso dall'assegnare il contenuto di un file a una variabile, cioè un'iterazione lenta - questo può essere fatto usando un withblocco tradizionale o nell'esempio sopra rimuovendo join()e iterando output.

Se vuoi quella sensazione calda e sfocata basta andare con .

Per python 3.6 ho eseguito questi due programmi con un nuovo inizio di IDLE, dando runtime di:

0.002000093460083008  Test A
0.0020003318786621094 Test B: with guaranteed close

Quindi non c'è molta differenza.

#--------*---------*---------*---------*---------*---------*---------*---------*
# 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

PRODUZIONE:

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

PRODUZIONE:

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