ouvrir lire et fermer un fichier en 1 ligne de code

Maintenant j'utilise:

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

Mais pour améliorer l'apparence du code, je peux faire:

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

Lorsque vous utilisez la syntaxe ci-dessus, comment fermer le fichier pour libérer des ressources système?

Vous n'avez pas vraiment besoin de le fermer - Python le fera automatiquement pendant le ramasse-miettes ou à la sortie du programme. Mais comme @delnan l'a noté, il est préférable de le fermer explicitement pour diverses raisons.

Alors, que pouvez-vous faire pour rester bref, simple et explicite:

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

Maintenant, c'est juste deux lignes et assez lisible, je pense.

Le module Pathlib de la bibliothèque standard de Python fait ce que vous recherchez:

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

N'oubliez pas d'importer le chemin:

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'

Sur Python 27, installez rétroporté pathliboupathlib2

En utilisant CPython, votre fichier sera fermé immédiatement après l'exécution de la ligne, car l'objet fichier est immédiatement récupéré. Il y a cependant deux inconvénients:

1. Dans les implémentations Python différentes de CPython, le fichier n'est souvent pas immédiatement fermé, mais plutôt à un moment ultérieur, hors de votre contrôle.

2. Dans Python 3.2 ou supérieur, cela lancera un ResourceWarning, s'il est activé.

Mieux vaut investir une ligne supplémentaire:

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

Cela garantira que le fichier est correctement fermé en toutes circonstances.

Pas besoin d'importer de bibliothèques spéciales pour ce faire.

Utilisez la syntaxe normale et il ouvrira le fichier pour la lecture puis le fermera.

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

ou

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

qui vous donne un tableau x contenant les lignes, et peut être imprimé comme ceci:

for line in x: print line

Ces one-liners sont très utiles pour la maintenance - essentiellement auto-documentés.

Ce que vous pouvez faire est d'utiliser l' withinstruction et d'écrire les deux étapes sur une seule ligne:

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

L' withinstruction prendra soin d'appeler la __exit__fonction de l'objet donné même si quelque chose de mauvais s'est produit dans votre code; c'est proche de la try... finallysyntaxe. Pour l'objet renvoyé par open, __exit__correspond à la fermeture du fichier.

Cette déclaration a été introduite avec Python 2.6.

utilisez ilio : (inline io):

juste un appel de fonction au lieu de fichier open (), read (), close ().

from ilio import read

content = read('filename')

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

Je pense que le moyen le plus naturel pour y parvenir est de définir une fonction.

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

Ensuite, vous pouvez effectuer les opérations suivantes:

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

Je fais souvent quelque chose comme ça lorsque j'ai besoin de quelques lignes entourant quelque chose que j'ai greffé dans un fichier journal:

$ 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

En utilisant more_itertools.with_iter, il est possible d'ouvrir, lire, fermer et affecter un équivalent outputen une seule ligne (hors instruction d'importation):

import more_itertools as mit


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

Bien que possible, je chercherais une autre approche autre que d'assigner le contenu d'un fichier à une variable, c'est-à-dire une itération paresseuse - cela peut être fait en utilisant un withbloc traditionnel ou dans l'exemple ci-dessus en supprimant join()et en itérant output.

Si vous voulez que chaud et floue sentiment juste aller avec avec .

Pour python 3.6, j'ai exécuté ces deux programmes sous un nouveau départ d'IDLE, donnant des temps d'exécution de:

0.002000093460083008  Test A
0.0020003318786621094 Test B: with guaranteed close

Donc pas beaucoup de différence.

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

PRODUCTION:

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

PRODUCTION:

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