abrir leer y cerrar un archivo en 1 línea de código

Ahora uso:

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

Pero para que el código se vea mejor, puedo hacer:

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

Cuando uso la sintaxis anterior, ¿cómo cierro el archivo para liberar recursos del sistema?

Realmente no tiene que cerrarlo: Python lo hará automáticamente durante la recolección de basura o al salir del programa. Pero como señaló @delnan, es una mejor práctica cerrarlo explícitamente por varias razones.

Entonces, qué puede hacer para que sea breve, simple y explícito:

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

Ahora son solo dos líneas y bastante legible, creo.

El módulo Pathlib de la biblioteca estándar de Python hace lo que está buscando:

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

No olvides importar Ruta:

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'

En Python 27, instale backported pathlibopathlib2

Usando CPython, su archivo se cerrará inmediatamente después de que se ejecute la línea, porque el objeto del archivo se recolecta inmediatamente como basura. Sin embargo, hay dos inconvenientes:

1. En implementaciones de Python diferentes a CPython, el archivo a menudo no se cierra de inmediato, sino más tarde, más allá de su control.

2. En Python 3.2 o superior, esto arrojará un ResourceWarning, si está habilitado.

Es mejor invertir una línea adicional:

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

Esto asegurará que el archivo se cierre correctamente en todas las circunstancias.

No es necesario importar ninguna biblioteca especial para hacer esto.

Use la sintaxis normal y abrirá el archivo para leerlo y luego lo cerrará.

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

o

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

que le da una matriz x que contiene las líneas, y puede imprimirse así:

for line in x: print line

Estas frases son muy útiles para el mantenimiento, básicamente autodocumentadas.

Lo que puede hacer es usar la withdeclaración y escribir los dos pasos en una línea:

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

La withdeclaración se encargará de llamar a la __exit__función del objeto dado incluso si algo malo sucedió en su código; Está cerca de la try... finallysintaxis. Para el objeto devuelto por open, __exit__corresponde al cierre del archivo.

Esta declaración se ha introducido con Python 2.6.

use ilio : (io en línea):

solo una llamada de función en lugar de abrir (), leer (), cerrar ().

from ilio import read

content = read('filename')

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

Creo que la forma más natural de lograr esto es definir una función.

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

Entonces puedes hacer lo siguiente:

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

Con frecuencia hago algo como esto cuando necesito obtener algunas líneas que rodean algo que he agrupado en un archivo de 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

Utilizando more_itertools.with_iter, es posible abrir, leer, cerrar y asignar un equivalente outputen una línea (excluyendo la declaración de importación):

import more_itertools as mit


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

Aunque es posible, buscaría otro enfoque que no sea asignar el contenido de un archivo a una variable, es decir, la iteración perezosa; esto se puede hacer usando un withbloque tradicional o en el ejemplo anterior quitando join()e iterando output.

Si quieres esa sensación cálida y difusa, simplemente ve con .

Para Python 3.6 ejecuté estos dos programas bajo un nuevo comienzo de IDLE, dando tiempos de ejecución de:

0.002000093460083008  Test A
0.0020003318786621094 Test B: with guaranteed close

Así que no hay mucha diferencia.

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

SALIDA:

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

SALIDA:

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