Pythonまとめ（３．クラスとデコレータ）

独自クラス

基本的な構文

class CounterClass(superclass): # スーパクラスがない場合(objの場合)は()ごと省略可能
    total = 0                   # クラス変数（すべてのインスタンスで共通の変数）
    def __init__(self, name):   # コンストラクタ
        self.name = name        # インスタンス変数
    def getName(self):          # インスタンスメソッド
        return self.name
    @classmethod
    def getCount(cls):          # クラスメソッド
        return cls.total
    @staticmethod
    def convertFrom():          # スタティックメソッド
        pass # 何らかの処理

親クラスの取得

super()関数で親クラスのメソッドを参照できる。コンストラクタで親クラスのコンストラクタを呼び出す例を示す。

    def __init__(self, name):   # コンストラクタ
        super().__init__(name)

可視性

Pythonでは各メソッドや変数の可視性を指定できない。代わりにアンダースコア_から始まる名前にすることでその変数やメソッドは外部から利用することを想定していないことを示す。通常はアンダースコアで始まる関数や変数を外部から参照するべきでない。

class Human:
(con)    _name = "example"
(con)
Human._name
(out)'example'

マングリングと可視性

アンダースコア2つ__で始まる変数名はマングリング(名前修飾)が行われる。classname.__attributeはclassname._classname__atributeのように_クラス名が付与される。その結果として外部からのアクセスが意図して実装しない限りできなくなる。

class Human:
(con)    __name = "example"
(con)
Human.__name
(out)Traceback (most recent call last):
(out)  File "<stdin>", line 1, in <module>
(out)AttributeError: type object 'Human' has no attribute '__name'
Human._Human__name
(out)'example'

ただし、マングリングは継承クラスとの名前の重複を防ぐための仕組みであり、外部からの隠蔽を目的とする機構ではない。また、厳密にはマングリングはアンダースコア2つ以上で始まり、アンダースコア1つ以下で終わる名前に適用される。なので__name__はマングリングの対象とはならない。

class Reader:
(con)    def _readdata(self):
(con)        print("Reader->readdata")
(con)
(con)    def read(self):
(con)        self._readdata()
(con)
class CSVReader(Reader):
(con)    def _readdata(self):
(con)        print("CSVReader->readdata")
(con)        super().read()
(con)
(con)    def read(self):
(con)        self._readdata()
(con)

creader = CSVReader()
creader.read()
(out)CSVReader->read
(out)CSVReader->readdata
(out)Reader->read
(out)CSVReader->readdata
(out)Reader->read
(out)CSVReader->readdata
(out)Reader->read
(out)(省略)
(out)Traceback (most recent call last):
(out)  File "<stdin>", line 1, in <module>
(out)  File "<stdin>", line 8, in read
(out)  File "<stdin>", line 4, in _readdata
(out)  File "<stdin>", line 7, in read
(out)  File "<stdin>", line 4, in _readdata
(out)  File "<stdin>", line 7, in read
(out)(省略)
(out)RecursionError: maximum recursion depth exceeded

class Reader:
(con)    def __readdata(self):
(con)        print("Reader->readdata")
(con)
(con)    def read(self):
(con)        print("Reader->read")
(con)        self.__readdata()
(con)
class CSVReader(Reader):
(con)    def __readdata(self):
(con)        print("CSVReader->readdata")
(con)        super().read()
(con)
(con)    def read(self):
(con)        print("CSVReader->read")
(con)        self.__readdata()
(con)
creader = CSVReader()
creader.read()
(out)CSVReader->read
(out)CSVReader->readdata
(out)Reader->read
(out)Reader->readdata

プロパティ

プロパティはメンバ変数のようにアクセスできる関数である。getterやsetter付きのメンバ変数と考えてもいいだろう。@propertyデコレータをつけたメソッドがそのプロパティのgetterとなり、@propertyname.setterデコレータをつけたメソッドがそのプロパティのsetterとなる。

プロパティへのアクセスは()をつけずに、インスタンス変数と同じようにアクセスする。

class PropertyTest:
(con)    def __init__(self) -> None:
(con)        self._balance = 0
(con)
(con)    @property
(con)    def balance(self):
(con)        return self._balance
(con)
(con)    @balance.setter
(con)    def balance(self,value):
(con)        if value<0: raise ValueError()
(con)        self._balance = value
(con)
proptest = PropertyTest()
proptest.balance
(out)0
proptest.balance = 10
proptest.balance
(out)10

@propertyデコレータはpropertyクラスのオブジェクトを作成している。以下のコードは上と同等の実装である。

class PropertyTest2:
(con)    def __init__(self) -> None:
(con)        self._balance = 0
(con)
(con)    def getbalance(self):
(con)        return self._balance
(con)
(con)    def setbalance(self, value):
(con)        if value<0: raise ValueError()
(con)        self._balance = value
(con)
(con)    # 引数は順にgetter, setter, deleter, docstring
(con)    balance = property(getbalance, setbalance, None, None)
(con)

プロパティのユースケースとしては以下のようなものが考えられる。

• 値を設定するときにチェックを行う
• 他の属性値の影響で値が変わる

他の属性値の影響を受けるプロパティの例を示す。

class PropertyNameTest:
(con)    def __init__(self, firstname, familyname) -> None:
(con)        self.firstname = firstname
(con)        self.familyname = familyname
(con)
(con)    @property
(con)    def fullname(self):
(con)        return f"{self.firstname} {self.familyname}"
(con)
proptest = PropertyNameTest("Ned", "Peyton")
proptest.fullname
(out)'Ned Peyton'

特殊メソッド

Pythonでは特殊メソッド（スペシャルメソッド）を実装することでオブジェクトの動作を定義できる。例えば数値的な要素を持つクラスであれば__add__メソッドを実装することで演算子+による加算が行えるようになる。

インスタンスの生成・削除に関する特殊メソッド

__new__メソッドの実装の違いにより、__init__メソッドが呼び出される場合とそうでない場合の例を示す。Sample1クラスの__init__メソッドは数値リストを返しているため、__init__メソッドが呼び出されない。

class Sample1():
(con)    def __new__(cls):
(con)        print("new")
(con)        return [1, 2, 3]
(con)
(con)    def __init__(self): # この__init__は呼び出されない
(con)        print("init")
(con)
class Sample2():
(con)    def __new__(cls):
(con)        print("new")
(con)        return super().__new__(cls)
(con)
(con)    def __init__(self):
(con)        print("init")
(con)
Sample1()
(out)new
(out)[1, 2, 3]
Sample2()
(out)new
(out)init
(out)<__main__.Sample2 object at 0x000001F1465C0470>

文字列・バイト列に変換する特殊メソッド

公式(repr)と非公式(str)の違いはdatetimeの実装を見るとわかりやすい。datetimeにおいてreprが返す文字列は、実行可能なPythonコードとなっている。このコードを実行すると同値のオブジェクトが得られる。このような条件さえ整えば同じオブジェクトを再生成できるような値が望ましいのがreprである。

import datetime

now = datetime.datetime.now()
repr(now)
(out)'datetime.datetime(2024, 12, 22, 21, 41, 11, 88599)'
str(now)
(out)'2024-12-22 21:41:11.088599'

# 文字列をPythonコードとして実行するeval関数にreprの結果を渡す
eval( repr(now) )
(out)datetime.datetime(2024, 12, 22, 21, 41, 11, 88599)

比較に関するメソッド

obj > otherを実行したときに、もしotherがobjのサブクラスの場合はotherのメソッドが優先される。つまりobj.__gt__(other)ではなく、その対となるother.__le__(obj)が実行される。

数値演算に関するメソッド

self + otherのような二項演算子でも特殊メソッドobject.__add__(self, other)が呼び出される。これを実装することで数値のように動作するクラスを作成できる。すべての数値演算に関するメソッドはPython3 Documentation 数値型をエミュレートするを参照すること

属性に関するメソッド

オブジェクトに関連付けられ、通常ドットを使用してobject.nameの形でアクセスできるものを属性またはアトリビュートとよぶ。属性へアクセスすると内部的には以下のメソッドが呼び出されている。

これらのメソッドをカスタマイズすることで挙動を変更できる。メソッドの呼び出し状況を確認するために標準出力するように変更してみる。

from typing import Any

class Item(object):
(con)    def __init__(self) -> None:
(con)        self.stock = 0
(con)
(con)    def __setattr__(self, __name: str, __value: Any) -> None:
(con)        print(f"__setattr__ called:{__name},{__value}")
(con)        super().__setattr__(__name,__value)
(con)
(con)    def __getattribute__(self, __name: str) -> None:
(con)        print(f"__getattribute__ called:{__name}")
(con)        return super().__getattribute__(__name)
(con)
(con)    def __delattr__(self, __name: str) -> None:
(con)        print(f"__delattr__ called:{__name}")
(con)        super().__delattr__(__name)
(con)

i = Item()
(out)__setattr__ called:stock,0
i.stock = 100
(out)__setattr__ called:stock,100
i.stock
(out)__getattribute__ called:stock
(out)100
del i.stock
(out)__delattr__ called:stock
i.name = "ItemName"
(out)__setattr__ called:name,ItemName

__setattr__メソッドは定義されていない属性であれば自動で追加する動作がデフォルトである。なので最後のi.name = "ItemName"はエラーにならない。一方で__getattribute__メソッドは定義されていない属性だとAttributeErrorが発生する。

i = Item()
(out)__setattr__ called:stock,0
i.name
(out)__getattribute__ called:name
(out)Traceback (most recent call last):
(out)  File "<stdin>", line 1, in <module>
(out)  File "<stdin>", line 11, in __getattribute__
(out)__getattribute__ called:__dict__
(out)__getattribute__ called:__class__
(out)AttributeError: 'Item' object has no attribute 'name'

もしクラスに__getattr__メソッドが定義されている場合、存在しない属性にアクセスした場合(主に__getattribute__でAttributeErrorが発生した場合)に__getattr__メソッドが呼び出される。そこでデフォルト値を定義するなどの挙動を制御できる。なお、__getattribute__は、アクセスしようとした属性の値を返すか、AttributeErrorを送出しなければならない。

from typing import Any

class Item(object):
(con)    def __init__(self) -> None:
(con)        self.stock = 0
(con)
(con)    def __setattr__(self, __name: str, __value: Any) -> None:
(con)        print(f"__setattr__ called:{__name},{__value}")
(con)        super().__setattr__(__name,__value)
(con)
(con)    def __getattribute__(self, __name: str) -> None:
(con)        print(f"__getattribute__ called:{__name}")
(con)
(con)    def __delattr__(self, __name: str) -> None:
(con)        print(f"__delattr__ called:{__name}")
(con)        super().__delattr__(__name)
(con)
(con)    def __getattr__(self, __name: str):
(con)        print(f"__getattr__ called:{__name}")
(con)        match __name:
(con)            case "stock":
(con)                self.stock = 0
(con)                return self.stock
(con)            case "name":
(con)                self.name = "Void"
(con)                return self.name
(con)            case _:
(con)                raise AttributeError(f"Unsupported attribute:{__name}")
(con)
i = Item()
(out)__setattr__ called:stock,0
i.stock
(out)__getattribute__ called:stock
(out)0
i.name
(out)__getattribute__ called:name
(out)__getattr__ called:name
(out)__setattr__ called:name,Void
(out)__getattribute__ called:name
(out)'Void'

(out)

属性へのアクセスは組み込み関数getattr、setattrでも行える。getattrでは属性が存在しないときのデフォルト値を指定できるメリットがある。

i = Item()
(out)__setattr__ called:stock,0
setattr(i, "stock", "100")
(out)__setattr__ called:stock,100
getattr(i, "name", "DEFAULTNAME")  # 呼び出し時点では存在しないが__getattr__がサポートしている属性
(out)__getattribute__ called:name
(out)__getattr__ called:name
(out)__setattr__ called:name,Void
(out)__getattribute__ called:name
(out)'Void'
getattr(i, "price", 10000)         # 存在しない、__getattr__もサポートしていない属性で、デフォルト値の指定あり
(out)__getattribute__ called:price
(out)__getattr__ called:price
(out)10000
getattr(i, "id")                   # 存在しない、__getattr__もサポートしていない属性で、デフォルト値の指定なし
(out)__getattribute__ called:id
(out)__getattr__ called:id
(out)Traceback (most recent call last):
(out)  File "<stdin>", line 1, in <module>
(out)  File "<stdin>", line 27, in __getattr__
(out)__getattribute__ called:__dict__
(out)__getattribute__ called:__class__
(out)AttributeError: Unsupported attribute:id

遅延評価

__getattribute__などを利用して属性の遅延評価が行える。遅延評価を簡単に言うなら、属性の値が必要になってから属性値を計算することで、インスタンス生成時にかかる時間・処理コストや、値を保持するために必要なメモリなどを抑えるというものである。

たとえば初期化に時間がかかるアトリビュート：nameがあるとしよう。普通の実装では、nameを使用するかによらずインスタンスを生成するときにコンストラクタでnameを初期化するために時間がかかる。以下のプログラムでは擬似的にtime.sleepで時間がかかるようにしている。

import time

class SlowItem(object):
(con)    def __init__(self) -> None:
(con)        time.sleep(3) # nameの計算に時間がかかる
(con)        self.name = "default name"
(con)
item = SlowItem() # この処理に時間がかかる
item.name         # この処理は時間がかからない
(out)'default name'

遅延評価を行うサンプルを示す。次に示す実装では初めてnameを取得しようとしたときにnameの初期化が行われ、時間がかかる。もしnameが使われなければ時間がかかることはない。また、一度初期化が行われれば、次から時間がかかることもない。

import time

class DelayedItem(object):
(con)    def __init__(self) -> None:
(con)        pass
(con)
(con)    def __getattr__(self, __name: str):
(con)        match __name:
(con)            case "name":
(con)                time.sleep(3) # nameの計算に時間がかかる
(con)                setattr(self, "name", "default name")
(con)                return "default name"
(con)            case _:
(con)                raise AttributeError(f"Unsupported attribute:{__name}")
(con)
item = DelayedItem() # この処理に時間がかからない
item.name            # この処理は時間がかかる
(out)'default name'
item.name            # この処理は時間がかからない
(out)'default name'

次にメモリ使用量へ影響する例を見てみる。10万個の数値データを持つクラスを生成してみた。

from memory_profiler import profile

class Item:
    def __init__(self) -> None:
        self.codes = [x for x in range(0,100000)]

class ItemDelayed:
    def __getattr__(self, __name: str):
        if  __name == (codes := "codes"):
            value = [x for x in range(0,100000)]
            setattr(self, codes, value)
            return value
        else:
            raise AttributeError(f"Unsupported attribute:{__name}")

@profile
def main():
    item = Item()
    item.codes
    itemDelayed = ItemDelayed()
    itemDelayed.codes

main()

Line #    Mem usage    Increment  Occurrences   Line Contents
=============================================================
    16     45.0 MiB     45.0 MiB           1   @profile
    17                                         def main():
    18     49.6 MiB      4.6 MiB           1       item = Item()
    19     49.6 MiB      0.0 MiB           1       item.codes
    20     49.6 MiB      0.0 MiB           1       itemDelayed = ItemDelayed()
    21     53.4 MiB      3.8 MiB           1       itemDelayed.codes

これはmemory_profilerライブラリを使用して、行ごとにメモリ使用量の増減を出力したものである。Itemクラスではインスタンス生成時にメモリが増加しているのに対し、ItemDelayedクラスではcodesへアクセスが発生したときにメモリが増加していることが分かる。

デコレータ

デコレータは複数の関数またはクラスに対して共通の加工を行う機能である。

デコレータ利用の背景と動作イメージ

2つの数字を加算する関数add_numberがある。add_numberは変更することなく、この処理の開始前後で標準出力にメッセージを出力する処理を行いたい。

def add_number(int1,int2):
    return int1+int2

これは内部でadd_numberを呼び出す別の関数を作成すれば簡単に実現できる。

def add_number_debug(int1,int2):
    print("add_number start")
    v = add_number(int1,int2)
    print("add_number end")
    return v

このように、定型の加工を既存の関数に行いたいというケースがある。それを実現する方法の1つがデコレータである。

まずは、この「関数の開始前後で標準出力にメッセージを出力する加工」をプログラムで行ってみる。つまり「add_number関数を引数として受け取りadd_number_debug関数を返す」関数を作成する。次のmodifier関数は加工する関数を引数targetにとり、その前後に出力を追加した関数wrapper_functionを定義し、それを返している。

def add_number(int1,int2):
(con)    return int1+int2
(con)
def modifier(target):
(con)    def wrapper_function(int1,int2):
(con)        print( "add_number start")
(con)        v = target(int1,int2)
(con)        print( "add_number end")
(con)        return v
(con)
(con)    return wrapper_function
(con)
add_number_debug = modifier(add_number)

add_number_debug(1,3)
(out)add_number start
(out)add_number end
(out)4

ここで作成したmodifierは引数が2つに固定されており、出力内容もadd_numberという関数に固定されている。それを任意の引数の個数、関数名に対応するように改善した関数を加工する関数printmethodは以下のようになる。

def printmethod(target:callable):
    def wrapper_function(*positionalargs, **keywordargs):
        print(f"{getattr(target, '__name__', 'Function')} start")
        v = target(*positionalargs, **keywordargs)
        print(f"{getattr(target, '__name__', 'Function')} end")
        return v
    
    return wrapper_function

これで任意の関数に開始前後で標準出力にメッセージを出力する加工が実装できた。さて、ここで加工したい関数に対して@printmethodを付与して実行してみる。

def printmethod(target:callable):
(con)    def wrapper_function(*positionalargs, **keywordargs):
(con)        print(f"{getattr(target, '__name__', 'Function')} start")
(con)        v = target(*positionalargs, **keywordargs)
(con)        print(f"{getattr(target, '__name__', 'Function')} end")
(con)        return v
(con)
(con)    return wrapper_function
(con)
@printmethod
(con)def concat_string(str1, str2):
(con)    return str1 + str2
(con)
concat_string("str", "ing")
(out)concat_string start
(out)concat_string end
(out)'string'

concat_stringにprintmethodによる加工が適用されることが分かる。つまり、デコレータとはデコレーションしてくれる関数を指定するものである。

引数をとるデコレータ

動作を調整するパラメータを引数にとるデコレータも作成できる。この場合は二重のwrapper_functionを作成する。

import datetime
import time

def recordtime(tzinfo:datetime.tzinfo=datetime.timezone.utc):
(con)    def wrapper_function(target:callable):
(con)        def inner_function(*positionalargs, **keywordargs):
(con)            print( f"{datetime.datetime.now(tzinfo)} start")
(con)            v = target(*positionalargs, **keywordargs)
(con)            time.sleep(2.5)
(con)            print( f"{datetime.datetime.now(tzinfo)} end")
(con)            return v
(con)        return inner_function
(con)    return wrapper_function
(con)
@recordtime()
(con)def add_number1(int1,int2):
(con)    return int1+int2
(con)
@recordtime(datetime.timezone(datetime.timedelta(hours=+9), 'JST'))
(con)def add_number2(int1,int2):
(con)    return int1+int2
(con)
add_number1(1,2)
(out)2024-12-22 13:21:04.527602+00:00 start
(out)2024-12-22 13:21:07.028624+00:00 end
(out)3
add_number2(1,2)
(out)2024-12-22 22:21:09.565653+09:00 start
(out)2024-12-22 22:21:12.066474+09:00 end
(out)3

def wrapper_function(target:callable):
    def inner_function(*positionalargs, **keywordargs):
        tzinfo = datetime.timezone(datetime.timedelta(hours=+9), 'JST')
        print( f"{datetime.datetime.now(tzinfo)} start")
        v = target(*positionalargs, **keywordargs)
        time.sleep(2.5)
        print( f"{datetime.datetime.now(tzinfo)} end")
        return v
    
    return inner_function