本文へスキップ

PythonのOptionalとNoneチェック

python-optional-none

Optionalとは

PythonのOptionalとは、ある型の値かNoneのどちらかになる値の型である。
Optional[str]はstr | Noneの略記で、2つは同一の型である。

  • 戻り値をstrと宣言すると、呼び出し側ではNoneを確認しない利用が型エラーにならず、実行時のAttributeErrorで初めて発覚する
  • 型をstr | Noneと宣言すると、Noneを確認せずにstrのメソッドを呼び出す行は、mypyとpyrightによる実行前の型チェックでエラーになる
    • if email is None: returnの後やassert email is not Noneの後では、型チェッカーがemailをstr型と判定する
    • if value:による確認も型の上ではエラーにならないが、0や空文字列もNoneと同じ分岐の対象になる
  • Optionalは値の型の指定で、引数を省略可能にする指定ではない
    • 省略可能な引数にはデフォルト値の指定が必要である
    • デフォルト値がNoneなら型にも| Noneが必要である
  • 属性をNoneでないと確認した後に、その属性を変更するメソッドを呼び出しても、mypyとpyrightは確認の結果を維持する
    • 属性の値が実行時にNoneになってAttributeErrorで失敗するコードが、型エラーにならない
    • 対処は確認の前に属性の値をローカル変数に代入し、その変数を確認して利用する方法である

前提となる用語

Union型

Union型は、値が複数の型のうちのいずれかであることの型での表現である。
int | str型の変数にはintの値とstrの値のどちらも代入できる。
str | NoneはstrとNoneのUnion型で、Noneの値の型の表記はNoneである。

型の絞り込み

型の絞り込み(type narrowing)とは、if文などの条件をもとに、型チェッカーが分岐の中での変数の型の範囲を宣言より限定する処理である。
str | None型のemailは、if email is None: returnの後ではstr型と判定される。
x is Noneの形の条件では、成立する分岐の型はNone、成立しない分岐の型は残りの型に 限定される 。

戻り値の型がstrならNoneの戻り値がエラーになる

以降の例は名前からメールアドレスを検索する関数で説明する。
例のtyping.assert_typeはPython 3.11以降の関数で、診断はmypyとpyrightの標準の設定での出力である。
mypyの--no-strict-optionalやpyrightのtypeCheckingMode: "off"の設定では、以降のNoneに関するエラーは発生しない。
辞書のget()の戻り値はキーがなければNoneなので、戻り値の型がstrの関数はエラーになる。

users: dict[str, str] = {"alice": "alice@example.com"}

def find_email(name: str) -> str:
    return users.get(name)
# mypy
# error: Incompatible return value type (got "str | None", expected "str")  [return-value]
# pyright
# error: Type "str | None" is not assignable to return type "str"
#   Type "str | None" is not assignable to type "str"
#     "None" is not assignable to "str" (reportReturnType)

型の確認は実行時には行われず、find_email("bob")の結果はNoneで、エラーにならない。
この関数の定義のエラーを無視すると、呼び出し側はstrの宣言を前提に判定され、Noneの確認のない利用も型エラーにならない。

str | None型のままではstrのメソッドの呼び出しがエラーになる

戻り値の型をstr | Noneにすると、関数の定義はエラーにならない。
代わりに、呼び出し側でNoneの確認をせずにstrのメソッドを呼び出す行がエラーになる。

def find_email(name: str) -> str | None:
    return users.get(name)

print(find_email("bob").upper())
# mypy
# error: Item "None" of "str | None" has no attribute "upper"  [union-attr]
# pyright
# error: "upper" is not a known attribute of "None" (reportOptionalMemberAccess)
# 実行時
# AttributeError: 'NoneType' object has no attribute 'upper'

戻り値の型がstrの関数では、このAttributeErrorは辞書に存在しない名前(bobなど)で呼び出したときに初めて発生する。
str | Noneにすると、引数の値に関係なく、型チェックの時点でこの行がエラーになる。

Noneの確認を追加すると、エラーにならない。

from typing import assert_type

def show(name: str) -> str:
    email = find_email(name)
    if email is None:
        return "unknown"
    assert_type(email, str)
    return email.upper()

print(show("bob"))    # unknown
print(show("alice"))  # ALICE@EXAMPLE.COM

assert_typeは、型チェッカーの判定の結果と第2引数の型の不一致をエラーにする関数で、実行時には何もしない。

Noneになりえない箇所なら、assert email is not Noneでもemailはstr型と判定される。
assertは条件が不成立なら実行時にAssertionErrorを発生させ、Noneのままの処理の継続を防止する。
python -Oで起動すると、assert文は実行されない。

Noneの確認はif email:ではなくis Noneで記述する

if count:による確認でも、型チェッカーは分岐の中のcountの型からNoneを除外する。
しかしif count:は0や空文字列でも不成立で、None以外の値もelseの側の処理になる。

def show(count: int | None) -> str:
    if count:
        return f"{count}件"
    return "不明"

def show_not_none(count: int | None) -> str:
    if count is not None:
        return f"{count}件"
    return "不明"

print(show(0))           # 不明
print(show_not_none(0))  # 0件

2つの関数はどちらもmypyとpyrightでエラーにならないが、show(0)は不明、show_not_none(0)は0件になる。
型チェッカーは0がelseの側の処理になることを指摘しない。
intやstrには偽と判定される値(0や"")があるので、Noneの確認をis Noneかis not Noneで記述する。

Optional[X]とX | Noneは同一の型である

Optional[X]はUnion[X, None]の 略記 である。
Python 3.10で PEP 604 のX | Yの構文が追加され、X | Noneの表記も可能になった。
型チェッカーは3つの表記を 同一の型として処理する 。

from typing import Optional, Union, assert_type

def f(value: Optional[int]) -> None:
    assert_type(value, int | None)  # ok

print(Optional[int] == int | None, Union[int, None] == int | None)  # True True

OptionalとUnionは、|の構文の追加以前からの表記として、型の仕様の「Historical and deprecated features」の章に分類されている。
Python 3.10以降を対象にしたコードでは、X | Noneの表記ならtypingのimportも不要である。

Optionalを入れ子にしても型はOptional[int]と同一で、「値がない」と「値がないことを表す値がある」を型では区別できない。

def g(value: Optional[Optional[int]]) -> None:
    assert_type(value, int | None)  # ok

print(Optional[Optional[int]] == Optional[int])  # True

Optionalの引数も省略は不可能である

名前のOptionalは省略可能を連想させるが、デフォルト値のないOptional[str]型の引数は省略するとエラーになる。

def greet(name: Optional[str]) -> str:
    return f"Hello, {name}"

print(greet())
# mypy
# error: Missing positional argument "name" in call to "greet"  [call-arg]
# pyright
# error: Argument missing for parameter "name" (reportCallIssue)
# 実行時
# TypeError: greet() missing 1 required positional argument: 'name'

逆に、デフォルト値がNoneの引数の型がstrなら、デフォルト値と型が一致せずエラーになる。

def greet(name: str = None) -> str:
    return f"Hello, {name}"
# mypy
# error: Incompatible default for parameter "name" (default has type "None", parameter has type "str")  [assignment]
# pyright
# error: Expression of type "None" cannot be assigned to parameter of type "str"
#   "None" is not assignable to "str" (reportArgumentType)

省略可能でNoneも許可する引数には、型とデフォルト値の両方を指定する。

def greet(name: str | None = None) -> str:
    return f"Hello, {name}"

print(greet())     # Hello, None
print(greet("a"))  # Hello, a

PEP 484の以前のバージョンは、デフォルト値がNoneの引数の型を暗黙にOptionalとみなすことを型チェッカーに許可していた。
現在のPEP 484と型の仕様は、この扱いを推奨せず、型へのNoneの明記を求める方向を型チェッカーに示している。
mypyは0.991から この暗黙のOptionalを標準の設定で無効にし、--implicit-optionalの指定がある場合だけ許可する。
mypy 0.990より前や--implicit-optionalの設定では、name: str = Noneはエラーにならない。

Noneの確認の後の判定が実行時と一致しない場合

メソッドの呼び出しによる属性の変更は型の絞り込みの追跡の対象外で、判定の結果が実行時の値と一致しないことがある。
次の説明用のクラスSessionでは、logout()が属性userをNoneにする。

class Session:
    def __init__(self) -> None:
        self.user: str | None = "alice"

    def logout(self) -> None:
        self.user = None

s = Session()
if s.user is not None:
    s.logout()
    print(s.user.upper())
# mypy: Success: no issues found in 1 source file
# pyright: 0 errors, 0 warnings, 0 informations
# 実行時
# AttributeError: 'NoneType' object has no attribute 'upper'

型チェッカーはs.logout()の後もs.userをstr型と判定し、mypyとpyrightのどちらもエラーにしない。
この例のように、確認の後に呼び出した処理が条件を無効にする問題は、 現在の型チェッカーでは検出できない 。

確認の時点の値で処理してよい場合は、属性の値をローカル変数に代入してから確認する。

s = Session()
user = s.user
if user is not None:
    s.logout()
    print(user.upper())  # ALICE
    print(s.user)        # None

logout()はローカル変数のuserを変更しないので、型チェッカーの判定と実行時の値が一致する。
userは確認の時点の値で、logout()の後の属性の現在の値ではない。

内側の関数から外側の変数を参照する場合も、確認の結果が維持されるかは、外側の変数への後からの代入の有無で異なる。

def run(email: str | None) -> None:
    if email is None:
        return

    def inner() -> str:
        return email.upper()  # ok

    print(inner())

def run_reassigned(email: str | None) -> None:
    if email is None:
        return

    def inner() -> str:
        return email.upper()
    # mypy
    # error: Item "None" of "str | None" has no attribute "upper"  [union-attr]
    # pyright
    # error: "upper" is not a known attribute of "None" (reportOptionalMemberAccess)

    email = None
    print(inner())

innerの定義の後にemailへの代入がなければ、mypy 1.4以降とpyrightはinnerの中でもemailをstr型と判定する。
代入があればinnerの呼び出しの時点での値が不明なので、宣言のstr | Noneの判定になる。

Noneの値とキーの欠如を区別する

None自体が有効な値の場合、Noneを値の欠如の表現に利用すると、2つの状態の区別が不可能になる。
値の型がint | Noneの辞書では、値がNoneのキーと、存在しないキーのget()の結果がどちらもNoneである。

settings: dict[str, int | None] = {"timeout": None}
print(settings.get("timeout"), settings.get("retries"))  # None None
print("timeout" in settings, "retries" in settings)      # True False

get()のデフォルト値に専用の値(番兵)を指定すると、実行時には区別できる。
object()を番兵にした場合、実行時には区別できても、isによる比較の後にvalueの型はint | Noneに限定されない。

from typing import assert_type

_MISSING = object()

def show(key: str) -> None:
    value = settings.get(key, _MISSING)
    if value is _MISSING:
        print(key, "missing")
    else:
        assert_type(value, int | None)
# mypy
# error: Expression is of type "object", not "int | None"  [assert-type]
# pyright
# error: "assert_type" mismatch: expected "int | None" but received "int | object | None" (reportAssertTypeFailure)

object()の値の型はobjectで、isによる比較ではobject型を除外できないからである。
PEP 484 はこの用途の番兵に要素が1つのEnumを利用する方法を示している。
Enumの要素は、値が1つだけの型として判定され、isによる比較で除外の対象になる。

from enum import Enum
from typing import Final, assert_type

class Missing(Enum):
    TOKEN = 0

MISSING: Final = Missing.TOKEN

def show(key: str) -> None:
    value = settings.get(key, MISSING)
    if value is MISSING:
        print(key, "missing")
    else:
        assert_type(value, int | None)  # ok
        print(key, value)

show("timeout")  # timeout None
show("retries")  # retries missing

他の言語の値の欠如の型との違い

言語 値の欠如の型 入れ子の場合
Python int | None(Union型) Optional[int]と同一
Haskell Maybe Int(Just 1かNothing) Maybe (Maybe Int)は別の型
Scala Option[Int](Some(1)かNone) Option[Option[Int]]は別の型
Kotlin Int?(null許容型) Int?と同一

HaskellのMaybeとScalaのOptionの値は、JustやSomeの構築子の中に元の値がある構造である。
構築子の有無で、NothingとJust Nothingのように値の欠如と、欠如を表現する値の存在を区別できる。
PythonのOptionalは構築子のないUnion型なので、前の節の辞書のように区別が必要な場合は番兵を別に用意する。
その代わりに、str | None型の引数にはstrの値をそのまま指定でき、値の取り出しの記述も不要である。

関連事例

  • データ分析支援

    事例:過去実績を提案に活用する分析の仕組み

    広告代理店との取り組みです。同社は過去実績の示唆を次の提案へ反映し、結果をどのように予測したか、その背景まで提案先のクライアントへ説明できるようになりました。KDOT は案ごとの見込みと判断材料を比較できる仕組みを業務アプリとして実装しました。さらに業務アプリの中核となる処理ロジックと機械学習モデルについて、特許手続きを担う弁理士が技術の新規性や工夫を検討するための資料を作成しました。その後この発明には特許が付与されました。

  • データ基盤構築 / 技術顧問(技術企業向け)

    事例:効果検証の分析処理基盤

    効果検証を提供する分析会社との取り組みです。同社は分析者の人数に比例してしか売上と利益を伸ばせない事業の形を、効果検証をプロダクトとして提供することで変革しようとしていました。手法とモデルは同社のまま、社内では開発できなかった、データと機械学習の重い推定を製品として動かす仕組みの開発を、開発支援会社の KDOT に任せました。推定を案件ごとの手作業ではなくシステムで実行できるようになったことで、同社は人数に比例しない形で売上と利益を伸ばすことを目指せるようになりました。

お問い合わせ・ご相談

システム開発、データ活用、プロダクトづくりのことならお気軽にご相談ください。要件が固まる前の整理や、お見積もりだけのご依頼も承ります。