Python
PR

Pythonのwith文とは?コンテキストマネージャーの仕組みと作り方

Pythonのwith文とは?コンテキストマネージャーの仕組みと作り方
hr
記事内に商品プロモーションを含む場合があります

Python でファイルを開くときの with open(...) as f: は、多くの入門書で最初に出てくる書き方です。ところが「with を付けると何がうれしいのか」「自分で with に対応したものを作るにはどうするのか」まで説明されることは多くありません。

この記事では、Windows 11 の Python 3.12 で実際に動かした結果つきで、次のことを解説します。

  • with を使わないと例外のときにファイルが 0 バイトのままになる例と、try・finally との対応
  • __enter__ と __exit__ が呼ばれる順番、__exit__ が True を返すと例外が消える注意点
  • contextlib.contextmanager(yield の前後に処理を書く)と、suppress・closing・ExitStack
  • 複数のものを 1 つの with に書く方法、sqlite3 の接続を with で使うときの落とし穴

サンプルは、空のフォルダーに sample.py などの名前で保存し、PowerShell などで py sample.py のように実行してください。ファイルを作るサンプルは、実行したフォルダーに memo.txt などを作ります。

with 文とは:後片付けを必ず実行する仕組み

プログラムでは「使い始め」と「後片付け」がセットになっている処理がよくあります。ファイルを開いたら閉じる、データベースにつないだら切る、ロック(同時に使わせないための鍵)を取ったら外す、といったものです。with 文は、ブロックを抜けるときに後片付けを必ず実行してくれる構文です。途中で例外(エラー)が起きても、return で関数を抜けても実行されます。

with を使わないと、例外のときにファイルが閉じられない

次の関数は、リストの文字列を大文字にしてファイルに書き、最後に close() で閉じます。正常に動けば問題ありませんが、リストに None が混ざっていると、2 行目の line.upper() で例外が起きます。

import os

def save(path, lines):
    f = open(path, "w", encoding="utf-8")
    for line in lines:
        f.write(line.upper() + "\n")
    f.close()

try:
    save("memo.txt", ["apple", None, "cherry"])
except AttributeError as e:
    print("エラー:", e)
    print("ファイルの大きさ:", os.path.getsize("memo.txt"), "バイト")
エラー: 'NoneType' object has no attribute 'upper'
ファイルの大きさ: 0 バイト

1 行目の “APPLE” は write() 済みなのに、ファイルは 0 バイトです。write() した内容はいったんメモリー上の「バッファー」にためられ、close() のときなどにまとめてファイルへ書き出されます。例外で close() の行まで進まなかったため、ファイルは開いたまま、内容も書き出されていません。

開いたままのファイルは、変数が使われなくなったときに Python が閉じてくれることもありますが、いつ閉じられるかは保証されません。その間に別の処理がファイルを読むと、空や途中までの内容が見えてしまいます。

try・finally で書くと閉じられる

例外が起きても必ず閉じるには、close() を finally に書きます。finally は「try ブロックをどう抜けても最後に実行される部分」です。

def save(path, lines):
    f = open(path, "w", encoding="utf-8")
    try:
        for line in lines:
            f.write(line.upper() + "\n")
    finally:
        f.close()

同じ呼び出し方で実行すると、エラーは同じように出ますが、ファイルの大きさは 7 バイトになりました(”APPLE” の 5 バイトと改行の 2 バイト。Windows ではテキストモードで書いた \n が \r\n の 2 バイトになります)。finally で閉じたので、書いた分がきちんとファイルに書き出されています。

with で書くと、同じことが 1 行で済む

with を使うと、try・finally と close() を書かなくても同じ結果(7 バイト)になります。

def save(path, lines):
    with open(path, "w", encoding="utf-8") as f:
        for line in lines:
            f.write(line.upper() + "\n")

with のブロック(字下げした部分)を抜けると、例外が起きていてもファイルが閉じられます。ファイルオブジェクトの closed 属性で確かめても、with を抜けたあとは True、with を使わず例外が起きたあとは False でした。公式のリファレンスでも、with 文は「try…except…finally のよくある使い方を、くり返し使えるようにまとめたもの」と説明されています。

書き方正常に終わったとき途中で例外が起きたとき
open() と close() だけ閉じる閉じない(close() まで進まない)
try・finally で close()閉じる閉じる
with open(…) as f:閉じる閉じる

注意したいのは、with は後片付けをするだけで、例外そのものは止めないことです。上の例でもエラーは呼び出し元へ伝わり、外側の try・except で捕まえています。エラーへの対処は try・except で行います(「Pythonの例外処理入門」を参照)。open() の encoding などの使い方は「Pythonのファイル読み書き」で解説しています。

コンテキストマネージャーとは:__enter__ と __exit__

with の後ろに書けるものをコンテキストマネージャーと呼びます。難しそうな名前ですが、「入るときの処理(__enter__)」と「出るときの処理(__exit__)」の 2 つのメソッドを持ったオブジェクトのことです。open() が返すファイルオブジェクトも、この 2 つを持っています。

自分でクラスを作って、それぞれがいつ呼ばれるかを print で確かめてみます。

class Trace:
    def __init__(self, name):
        print(f"1. __init__({name} を作る)")
        self.name = name

    def __enter__(self):
        print("2. __enter__")
        return f"{self.name} の中身"

    def __exit__(self, exc_type, exc_value, traceback):
        print("4. __exit__")
        print("   exc_type  =", exc_type)
        print("   exc_value =", repr(exc_value))
        print("   traceback =", traceback)
        return False

print("--- 例外が起きない場合 ---")
with Trace("A") as x:
    print("3. ブロックの中:x =", x)
print("5. with のあと")

print("--- 例外が起きた場合 ---")
try:
    with Trace("B") as x:
        print("3. ブロックの中")
        int("abc")
        print("(ここは実行されない)")
    print("(with のあとも実行されない)")
except ValueError as e:
    print("5. 外の except で捕まえた:", e)
--- 例外が起きない場合 ---
1. __init__(A を作る)
2. __enter__
3. ブロックの中:x = A の中身
4. __exit__
   exc_type  = None
   exc_value = None
   traceback = None
5. with のあと
--- 例外が起きた場合 ---
1. __init__(B を作る)
2. __enter__
3. ブロックの中
4. __exit__
   exc_type  = <class 'ValueError'>
   exc_value = ValueError("invalid literal for int() with base 10: 'abc'")
   traceback = <traceback object at 0x0000024FC941EB00>
5. 外の except で捕まえた: invalid literal for int() with base 10: 'abc'

(traceback の 0x… の部分はメモリー上の位置で、実行するたびに変わります。)

まず with の後ろの式(Trace("A"))でオブジェクトが作られ、__enter__ が呼ばれます。as の変数(x)に入るのは、オブジェクト自身ではなく __enter__ の戻り値です。次にブロックが実行され、抜けるときに __exit__ が呼ばれます。例外がなければ 3 つの引数はすべて None、例外があれば例外の種類・例外そのもの・トレースバック(どこで起きたかの情報)が入ります。__exit__ が偽(False や None)を返すと、例外はそのまま外へ伝わります。

with 文の処理の流れを 2 列で示した図。左の例外が起きない場合は、__enter__ が呼ばれて戻り値が as の変数に入り、ブロックを最後まで実行し、__exit__ が 3 つとも None の引数で呼ばれ、with のあとの行へ進む。右のブロックで例外が起きた場合は、__enter__ のあとブロックが途中で止まり、__exit__ に例外の型・値・traceback が届く。__exit__ の戻り値が偽なら例外が外へ伝わり、真なら例外が消えて with のあとの行へ進む。どちらの場合も __exit__ は必ず呼ばれる。
図 1:__enter__ と __exit__ が呼ばれる順番

ブロックの中で return して関数を抜けた場合も、__exit__ は呼ばれました(引数は 3 つとも None)。逆に、__enter__ の中で例外が起きた場合は、ブロックも __exit__ も実行されませんでした。公式リファレンスでも「__enter__ がエラーなく戻った場合は、__exit__ が必ず呼ばれる」と、__enter__ の成功が条件になっています。__enter__ の中で 2 つのものを順に準備するときは、2 つ目で失敗したら 1 つ目を自分で片付ける必要があります。

注意:__exit__ が True を返すと例外が消える

__exit__ が真の値(True など)を返すと、例外は握りつぶされ(なかったことにされ)、with のあとの行から実行が続きます。便利そうに見えますが、エラーに気付けなくなる原因になります。

class Quiet:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("__exit__:", exc_type)
        return True  # 例外を握りつぶす

def load_count(text):
    count = 0
    with Quiet():
        count = int(text)
    return count

print("結果:", load_count("12"))
print("結果:", load_count("abc"))
__exit__: None
結果: 12
__exit__: <class 'ValueError'>
結果: 0

“abc” は数値に変換できないのに、エラーにならず「結果: 0」が返りました。呼び出した側からは、0 件だったのか、変換に失敗したのか区別できません。

もう一つの落とし穴は、何も return しない関数は None を返すことです。None は偽なので例外は伝わり、問題ありません。後片付けだけをする __exit__ は、return を書かない(または return False)のがふつうです。どうしても無視したいときは、exc_type で種類を確かめ、特定の例外のときだけ True を返します。なお、公式リファレンスには「__exit__ の中で、受け取った例外を raise し直すべきではない(それは呼び出し側の役目)」とも書かれています。例外を伝えたいときは raise せず、偽を返します。特定の例外を無視するだけなら、後で紹介する contextlib.suppress を使うほうが簡単です。

contextlib.contextmanager で関数として書く

クラスを作って 2 つのメソッドを書くのは少し手間です。標準ライブラリの contextlib.contextmanager を使うと、yield を 1 回だけ含む関数からコンテキストマネージャーを作れます。yield の前が「入るときの処理」、yield の後が「出るときの処理」になり、yield した値が as の変数に入ります。

from contextlib import contextmanager

@contextmanager
def trace(name):
    print(f"前処理:{name} を準備")
    try:
        yield f"{name} の中身"
    finally:
        print(f"後処理:{name} を片付け")

with trace("A") as x:
    print("ブロックの中:x =", x)
print("with のあと")

try:
    with trace("B"):
        int("abc")
except ValueError as e:
    print("捕まえた:", e)
前処理:A を準備
ブロックの中:x = A の中身
後処理:A を片付け
with のあと
前処理:B を準備
後処理:B を片付け
捕まえた: invalid literal for int() with base 10: 'abc'

関数の上の @contextmanager は「デコレーター」という書き方で、下の関数を with で使える形に包み直す、という意味です。yield は本来ジェネレーター(値を 1 つずつ返す関数)で使うものですが、ここでは「ここで一時停止して、with のブロックを実行させる」目印として使っています。

yield は try・finally で囲む

公式ドキュメントによると、with のブロックで例外が起きると、その例外は関数の中の yield の位置で発生し直します。そのため、try・finally で囲まないと yield の後の行は実行されません。

from contextlib import contextmanager

@contextmanager
def trace(name):
    print(f"前処理:{name}")
    yield
    print(f"後処理:{name}")

try:
    with trace("B"):
        int("abc")
except ValueError as e:
    print("捕まえた:", e)
前処理:B
捕まえた: invalid literal for int() with base 10: 'abc'

「後処理:B」が表示されていません。後片付けを確実に行うには、先ほどの例のように try: yield ... finally: の形にします。

except で捕まえたら raise し直す

yield を try・except で囲んで例外を捕まえると、クラスで True を返したときと同じく、例外が消えてしまいます。ログに残すだけのつもりなら、except の最後で raise と書いて例外を伝え直します。

from contextlib import contextmanager

@contextmanager
def trace():
    print("前処理")
    try:
        yield
    except ValueError as e:
        print("ログ:", e)
        raise  # これがないと例外が消える
    finally:
        print("後処理")

with trace():
    int("abc")
print("with のあとに進んだ")
前処理
ログ: invalid literal for int() with base 10: 'abc'
後処理
Traceback (most recent call last):
(中略)
ValueError: invalid literal for int() with base 10: 'abc'

例外が伝わり、「with のあとに進んだ」は表示されません。raise の行を消して実行すると、「前処理 → ログ → 後処理 → with のあとに進んだ」と表示され、エラーにならずに先へ進みました。

実例:処理時間を測る

「入るときに時刻を記録し、出るときに経過時間を表示する」処理は、contextmanager で短く書けます。測りたい処理を with で囲むだけで使えます。

import time
from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.1f} 秒")

with timer("集計"):
    time.sleep(0.5)
    total = sum(range(1_000_000))
print(total)
集計: 0.5 秒
499999500000

with の中で作った変数(total)は、with のあとでもそのまま使えます。このように「入る・出る」の処理だけなら contextmanager が手軽です。接続オブジェクトのように with の外でもメソッドを使いたいものは、クラスに __enter__ と __exit__ を書くのが自然です。

contextlib の便利な道具:suppress・closing・ExitStack

contextlib には、自分で書かなくても使えるコンテキストマネージャーがいくつか入っています。よく使う 3 つを紹介します。

suppress:指定した例外だけを無視する

suppress(例外の種類) は、ブロックの中でその例外が起きたら無視して、with のあとへ進みます(Python 3.4 で追加)。「ファイルがあれば消す、なければ何もしない」のような処理に向いています。

import os
from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("no_such_file.tmp")
print("ファイルがなくても止まらない")
ファイルがなくても止まらない

try・except で except の中に pass と書くのと同じ意味ですが、「この例外は無視する」という意図が 1 行目で分かります。suppress に Exception のような広い種類を渡すと、先ほどの「握りつぶし」と同じ問題が起きるので、具体的な種類だけを書きます。また、例外が起きた行より後ろにあるブロックの行は実行されない点にも注意してください。

closing:close() を持つものを with で閉じる

closing(もの) は、ブロックを抜けるときにそのものの close() を呼びます。公式ドキュメントでは、contextmanager で try: yield thing、finally: thing.close() と書いた関数とほぼ同じもの、と説明されています。close() はあるのに with で閉じてくれないオブジェクトに使います。代表例は、後で説明する sqlite3 の接続です。

ExitStack:数が決まっていないものをまとめて閉じる

開くファイルの数がリストなどで変わる場合、with を何重にも書けません。ExitStack に enter_context() で登録すると、with を抜けるときにまとめて片付けてくれます。

from contextlib import ExitStack

names = ["a.txt", "b.txt", "c.txt"]
for name in names:
    with open(name, "w", encoding="utf-8") as f:
        f.write(name[0] * 3 + "\n")

with ExitStack() as stack:
    files = [stack.enter_context(open(n, encoding="utf-8")) for n in names]
    for lines in zip(*files):
        print([s.strip() for s in lines])
print([f.closed for f in files])

実行すると ['aaa', 'bbb', 'ccc'] と [True, True, True] が表示され、3 つとも閉じられていました。途中のファイルが開けなかった場合も、それまでに開いた分は閉じられます。2 つ目を存在しないファイル名にして試すと、FileNotFoundError が出たうえで、1 つ目の a.txt は閉じられていました(closed が True)。

複数のものを 1 つの with に書く

読み込み用と書き込み用のファイルのように、2 つ以上を同時に使うときは、カンマで区切って 1 つの with に書けます。公式リファレンスでは、これは with を入れ子にしたのと同じ意味とされています。

with open("in.txt", encoding="utf-8") as src, open("out.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line.upper())

1 行が長くなるときは、Python 3.10 から全体を丸かっこで囲んで改行できます。最後の要素の後ろにカンマを付けてもかまいません。3.9 以前では使えないので、古い環境で動かすコードでは避けます。

with (
    open("in.txt", encoding="utf-8") as src,
    open("out.txt", encoding="utf-8") as result,
):
    print(src.read().split(), result.read().split())
print(src.closed, result.closed)
['apple', 'banana'] ['APPLE', 'BANANA']
True True

(in.txt には apple と banana の 2 行を入れてあり、out.txt は 1 つ前の例で作ったものです。)入れ子と同じなので、入るのは書いた順、出るのは逆の順です。enter と exit を print するクラスで with Trace("A") as a, Trace("B") as b: と書いて試すと、「enter A → enter B → ブロック → exit B → exit A」の順に表示されました。

標準ライブラリのよく使うコンテキストマネージャー

with はファイル以外にもいろいろな場面で使われています。

書き方入るとき出るとき
with open(…) as fファイルを開くファイルを閉じる
with tempfile.TemporaryDirectory() as d一時フォルダーを作る中身ごと削除する
with threading.Lock()(作ったロック)ロックを取るロックを外す
with contextlib.chdir(path)(3.11 から)作業フォルダーを移す元のフォルダーに戻す
with contextlib.suppress(…)(何もしない)指定した例外を無視する
with sqlite3 の接続(何もしない)commit か rollback(閉じない)

一時フォルダーとロックを試したところ、with の中では一時フォルダーに作ったファイルが存在し(exists() が True)、ロックがかかっていました(locked() が True)。with を抜けると、一時フォルダーは中のファイルごと消え、ロックは外れていました(どちらも False)。ファイルやフォルダーの扱いは「Pythonのpathlibの使い方」で解説しています。

sqlite3 の接続は with を抜けても閉じない

ファイルと同じ感覚で with sqlite3.connect(...) as con: と書くと、「with を抜けたら接続も閉じる」と思いがちですが、そうではありません。公式ドキュメントでは、接続の with はトランザクション(ひとまとまりの更新)の確定・取り消しだけを行い、「新しいトランザクションを始めることも、接続を閉じることもしない。閉じるには contextlib.closing() を検討して」と注意書きがあります。

import sqlite3
from contextlib import closing

with sqlite3.connect("memo.db") as con:
    con.execute("CREATE TABLE IF NOT EXISTS memo (body TEXT)")
    con.execute("INSERT INTO memo VALUES (?)", ("1件目",))

# with を抜けたあとでも使える=接続は閉じていない
print(con.execute("SELECT count(*) FROM memo").fetchone())

try:
    with con:
        con.execute("INSERT INTO memo VALUES (?)", ("2件目",))
        raise ValueError("途中で失敗")
except ValueError as e:
    print("エラー:", e)
print(con.execute("SELECT count(*) FROM memo").fetchone())
con.close()

with closing(sqlite3.connect("memo.db")) as con:
    with con:
        con.execute("INSERT INTO memo VALUES (?)", ("3件目",))
try:
    con.execute("SELECT 1")
except sqlite3.ProgrammingError as e:
    print("エラー:", e)
(1,)
エラー: 途中で失敗
(1,)
エラー: Cannot operate on a closed database.
  • 1 つ目の with のあとでも SELECT できた(件数 1)=接続は閉じていない。ブロックが正常に終わったので commit(確定)された
  • 2 つ目の with では例外が起きたので rollback(取り消し)され、件数は 1 のまま。例外そのものは外へ伝わる
  • 外側の closing が閉じる係、内側の with con: が commit・rollback の係。closing を抜けたあとは「閉じたデータベースは操作できない」というエラーになる

sqlite3 の使い方全体は「Pythonのsqlite3入門」で詳しく解説しています。

よくある間違い

with の外でファイルを読む(I/O operation on closed file)

with の中で開いたファイルを、with の外で読もうとするとエラーになります。よくあるのは、関数の中の with からファイルオブジェクトそのものを return してしまう例です。

def read_lines(path):
    with open(path, encoding="utf-8") as f:
        return f

for line in read_lines("in.txt"):
    print(line)
Traceback (most recent call last):
  File "C:\work\pit4.py", line 5, in <module>
    for line in read_lines("in.txt"):
                ^^^^^^^^^^^^^^^^^^^^
ValueError: I/O operation on closed file.

return した時点で with を抜けるので、呼び出し元に届いたときにはファイルは閉じています。with の中で読み終えた結果を返します。

def read_lines(path):
    with open(path, encoding="utf-8") as f:
        return f.read().splitlines()

print(read_lines("in.txt"))

__enter__ が何も返さず、as の変数が None になる

as の変数に入るのは、オブジェクト自身ではなく __enter__ の戻り値です。自作のクラスで return self を忘れると、変数は None になります。

class Conn:
    def __enter__(self):
        print("接続しました")
    def __exit__(self, *args):
        print("切断しました")
    def query(self):
        return "結果"

with Conn() as c:
    print(c)
    c.query()
接続しました
None
切断しました
Traceback (most recent call last):
(中略)
AttributeError: 'NoneType' object has no attribute 'query'

__enter__ の最後に return self を足せば直ります。エラーが起きても「切断しました」が表示されている点にも注目してください。

また、with Trace: のように () を付けずにクラスそのものを書くと、Python 3.12 では TypeError: 'type' object does not support the context manager protocol になります。

まとめ

  • with は「try・finally で後片付け」を短く書く構文。例外や return で抜けても後片付けが実行される。ただし例外そのものは止めない
  • 入るときに __enter__(戻り値が as の変数へ)、出るときに __exit__(例外の種類・値・トレースバックが届く)が呼ばれる
  • __exit__ が True を返すと例外が消える。後片付けだけなら何も返さない
  • 自作は @contextmanager と try: yield … finally: が手軽。無視は suppress、close() は closing、数が変わるなら ExitStack
  • sqlite3 の接続の with は commit・rollback だけで、接続は閉じない

関連する記事・ツール

ABOUT ME
hr
hr
エンジニアとして働いている hr です。仕事や資格勉強で「こんなツールがあれば」と感じたものを、無料Webツールと解説記事にして発信しています。
記事URLをコピーしました