abrir ler e fechar um arquivo em 1 linha de código

Agora eu uso:

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

Mas, para tornar o código melhor, eu posso fazer:

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

Ao usar a sintaxe acima, como fecho o arquivo para liberar recursos do sistema?

Você realmente não precisa fechá-lo - o Python o fará automaticamente durante a coleta de lixo ou na saída do programa. Mas, como observou @delnan, é uma prática recomendada fechá-lo explicitamente por vários motivos.

Então, o que você pode fazer para mantê-lo breve, simples e explícito:

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

Agora são apenas duas linhas e bem legíveis, eu acho.

O módulo Pathlib da Biblioteca Padrão do Python faz o que você procura:

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

Não se esqueça de importar o 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'

No Python 27, instale o backport pathliboupathlib2

Usando o CPython, seu arquivo será fechado imediatamente após a execução da linha, porque o objeto do arquivo é imediatamente coletado como lixo. Existem duas desvantagens:

1. Nas implementações Python diferentes do CPython, o arquivo geralmente não é fechado imediatamente, mas posteriormente, além do seu controle.

2. No Python 3.2 ou superior, isso gerará um ResourceWarning, se ativado.

Melhor investir uma linha adicional:

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

Isso garantirá que o arquivo seja fechado corretamente em todas as circunstâncias.

Não há necessidade de importar nenhuma biblioteca especial para fazer isso.

Use a sintaxe normal e ele abrirá o arquivo para leitura e depois o fechará.

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

ou

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

que fornece uma matriz x contendo as linhas e pode ser impressa da seguinte forma:

for line in x: print line

Essas one-liners são muito úteis para manutenção - basicamente auto-documentadas.

O que você pode fazer é usar a withinstrução e escreva as duas etapas em uma linha:

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

A withinstrução cuidará de chamar a __exit__função do objeto fornecido, mesmo que algo de ruim tenha acontecido no seu código; está perto da try... finallysintaxe. Para o objeto retornado por open, __exit__corresponde ao fechamento do arquivo.

Esta declaração foi introduzida no Python 2.6.

use ilio : (inline io):

apenas uma chamada de função em vez de abrir o arquivo (), ler (), fechar ().

from ilio import read

content = read('filename')

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

Eu acho que a maneira mais natural de conseguir isso é definir uma função.

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

Então você pode fazer o seguinte:

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

Freqüentemente faço algo assim quando preciso obter algumas linhas em torno de algo que recebi em um arquivo de log:

$ 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

Usando more_itertools.with_iter, é possível abrir, ler, fechar e atribuir um equivalente outputem uma linha (excluindo a declaração de importação):

import more_itertools as mit


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

Embora possível, eu procuraria outra abordagem além de atribuir o conteúdo de um arquivo a uma variável, ou seja, iteração lenta - isso pode ser feito usando um withbloco tradicional ou no exemplo acima, removendo join()e iterando output.

Se você quer aquele sentimento quente e confuso, vá em frente .

Para o python 3.6, executei esses dois programas sob um novo começo do IDLE, fornecendo tempos de execução de:

0.002000093460083008  Test A
0.0020003318786621094 Test B: with guaranteed close

Portanto, não há muita diferença.

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

RESULTADO:

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

RESULTADO:

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