En Python, si je retourne à l'intérieur d'un “avec” block, le fichier reste proche?

De considérer les éléments suivants:

with open(path, mode) as f:
    return [line for line in f if condition]

Sera le fichier doit être fermé correctement, ou ne l'aide return quelque sorte court-circuiter le gestionnaire de contexte?

InformationsquelleAutor Lightbreeze | 2012-03-27

179

Oui, il agit comme le finally bloc après un try bloc, c'est à dire qu'il s'exécute toujours (à moins que le python, un processus se termine d'une manière inhabituelle, bien sûr).

Il est également mentionné dans l'un des exemples de PEP-343 qui est la norme pour la with déclaration:
```
with locked(myLock):
    # Code here executes with myLock held.  The lock is
    # guaranteed to be released when the block is left (even
    # if via return or by an uncaught exception).
```
Quelque chose à souligner, cependant, que vous ne pouvez pas facilement attraper les exceptions levées par le open() appel sans mettre l'ensemble de la with bloc à l'intérieur d'un try..except bloc qui n'est généralement pas ce que l'on veut.
- else pourrait être ajouté à with à résoudre que try with except problème. edit: ajouté à la langue
- Je ne sais pas si c'est pertinent, mais à ma connaissance Process.terminate() est l'un des rares (le seul?) scénario qui ne garantit pas à l'appel d'un finally déclaration: "a Noter que la sortie des gestionnaires et, enfin, des clauses, etc., ne sera pas exécuté."
- href="https://docs.python.org/library/os.html#os._exit" >os._exit est parfois utilisé - qu'il sort de l'Python processus sans appel de nettoyage des gestionnaires.
- Peut-être à narguer le serpent un peu, mais si je retourne un générateur d'expression à partir de l'intérieur de la with bloc, la garantie ne tenez aussi longtemps que le générateur de garde fourniture de valeurs? aussi longtemps que rien y fait référence? I. e. dois-je utiliser del ou d'affecter une valeur à la variable qui contient l'objet du générateur?
- Qu'advient-il si quelque chose est construit qui dépend de l'ouverture d'un fichier - comme return mmap.mmap(f.fileno(), path.stat().st_size)? Sera le fichier fermé, la rupture de la carte mémoire? Ou le fait que la mémoire de la carte dépend du fichier descripteur de garder le dossier ouvert pour le champ d'application de l'objet retourné?
InformationsquelleAutor ThiefMaster
29

Oui.
```
def example(path, mode):
    with open(path, mode) as f:
        return [line for line in f if condition]
```
..est à peu près équivalent à:
```
def example(path, mode):
    f = open(path, mode)

    try:
        return [line for line in f if condition]
    finally:
        f.close()
```
Avec plus de précision, le __exit__ méthode dans un gestionnaire de contexte est toujours appelée lors de la sortie du bloc (indépendamment des exceptions, retours, etc). Le fichier de l'objet __exit__ méthode appelle juste f.close() (e.g ici, dans Disponible)
- Une expérience intéressante pour montrer la garantie que vous obtenez de la finally keywrod est: def test(): try: return True; finally: return False.
InformationsquelleAutor dbr

Oui. Plus généralement, la __exit__ méthode de Avec La Déclaration Gestionnaire De Contexte va en effet être appelé en cas de return de l'intérieur du contexte. Cela peut être testé avec les éléments suivants:

class MyResource:
    def __enter__(self):
        print('Entering context.')
        return self

    def __exit__(self, *exc):
        print('EXITING context.')

def fun():
    with MyResource():
        print('Returning inside with-statement.')
        return
    print('Returning outside with-statement.')

fun()

La sortie est:

Entering context.
Returning inside with-statement.
EXITING context.

La sortie ci-dessus confirme que __exit__ a été appelé, malgré le début de return. En tant que tel, le gestionnaire de contexte n'est pas contournée.

InformationsquelleAutor Acumenus

Oui, mais il peut y avoir des effets secondaires dans d'autres cas, car il peut faire quelque chose (comme pour la vidange de la mémoire tampon) dans __exit__ bloc

import gzip
import io

def test(data):
    out = io.BytesIO()
    with gzip.GzipFile(fileobj=out, mode="wb") as f:
        f.write(data)
        return out.getvalue()

def test1(data):
    out = io.BytesIO()
    with gzip.GzipFile(fileobj=out, mode="wb") as f:
        f.write(data)
    return out.getvalue()

print(test(b"test"), test1(b"test"))

# b'\x1f\x8b\x08\x00\x95\x1b\xb3[\x02\xff' b'\x1f\x8b\x08\x00\x95\x1b\xb3[\x02\xff+I-.\x01\x00\x0c~\x7f\xd8\x04\x00\x00\x00'

InformationsquelleAutor virusdefender

Vous devez vous connecter pour publier un commentaire.