計算化学者のためのPython入門ークラスの使いみちー

# はじめに
このシリーズは計算化学を題材にした Python プログラミングを紹介した「**計算化学者のためのPython入門**」の1つです。
特に「計算化学関連の Python プログラム開発に携わる予定」の読者を想定してます。

- [基礎知識のおさらい](https://qiita.com/TakuroTsutsumi/items/bcc86d243f5b38e93de9)
- [Python練習問題](https://qiita.com/TakuroTsutsumi/items/601f29d819624754e9df)
- [プログラム開発に参加するための心得](https://qiita.com/TakuroTsutsumi/items/cac3f3e7c32acaaef3ec)
- [クラスの使いみち](https://qiita.com/TakuroTsutsumi/items/5f8595bc2ffc68020a9b)
- [サンプルデータ集](https://qiita.com/TakuroTsutsumi/items/5dfb251ad0818d41cd1d)

Python3 は [Google Colab を使えばブラウザだけで実行](https://qiita.com/firedfly/items/9b76d4f4ea2b563777af) できます。


# 本記事の要点

- 計算化学においてもクラスの使い道はたくさんある。
- プログラミング原則、DRY (Don't repeat yourself)、を意識しましょう。
- 執筆者はオブジェクト指向初心者です。お手柔らかにお願いします。



# オブジェクト指向で頻出単語

クラス、メソッド、インスタンス、コンストラクタなどの頻出単語をまとめます。
最初は何を意味しているのかわかりにくいと思いますが、がんばって慣れましょう（~~カタカナ覚えられない…~~）。

- **クラス（class）**
  - 学級というよりも、「**類**」という意味に近いと思います。
  - ポケモンなどの概念を一括りにした類、というイメージです。
- **コンストラクタ（constructor）**
  - construct で「**構築する**」という意味です。
  - クラスを構築するときに最初に呼ばれるメソッドのことを指します。
- **メソッド（method）**
  - これは ```def hoge():``` で定義するメソッドと同じ、「**関数**」を意味する。
  - クラス内に定義された関数もメソッドと呼ぶ。
- **インスタンス（instance）**
  - For instance で「**例えば**」という意味ですね。instance は実例という意味があります。
  - **オブジェクト（object、実体、物）** とも呼ばれる。

[【Python入門】クラスの基本を１から解説する―完全版](https://it-biz.online/python/class-2/)

クラスやコンストラクタ、メソッド、または実際に利用する際のインスタンスは以下のように使います。

```python: test.py
class Pokemon():  # クラスの定義方法
    def __init__(self, name, level, type1, type2=None):  # コンストラクタ：初期設定
        self.name = name     # self.xxxx とすることでクラス内で利用可能になる
        self.level = level   # 詳細は上記のリンクへgo
        self.type1 = type1
        self.type2 = type2
        return

    def show_type(self):  # メソッドを定義
        print("type1 = ", self.type1)
        if self.type2 is not None:
            print("type2 = ", self.type2)
        return

    def greeting(self):  # self が必要な理由：上記のリンクへgo
        print("I'm " + self.name + ". Lv. " + str(self.level) + "!")
        return

# ---- Main program
pikachu = Pokemon("Pikachu", 81, "Electric")  # インスタンス pikachu を定義
pikachu.show_type()   # インスタンス（主語）、メソッド（動詞+目的語）のように使うと見通しが良い
pikachu.greeting()
print("---")
kabigon = Pokemon("Snorlax", 75, "Normal")
kabigon.show_type()
kabigon.greeting()
```

```text: output of test.py
type1 =  Electric
I'm Pikachu. Lv. 81!
---
type1 =  Normal
I'm Snorlax. Lv. 75!
```

# （ざっくりとした）オブジェクト指向

オブジェクト指向プログラミングとは、

- いろいろな機能（メソッド）が詰まったクラスを、
- まるで変数（オブジェクト、インスタンス）のようにみなす／扱うことで、
- プログラムの見通しを良くしたり、保守性を高めることができる
- プログラミングの流儀

のことです。

より詳細には「カプセル化」や「ポリモーフィズム (polymorphism: 多相性)」、「継承と抽象化」という概念があります。

以下の記事がわかりやすかったので共有します。

- [オブジェクト指向とは？特徴や原則をどこよりもわかりやすく解説！](https://camp.trainocate.co.jp/magazine/whats-object-oriented-programming/)


# クラスの使いみち（ポケモン）

上のプログラムの簡易版をオブジェクト指向とそうじゃない流儀で書いてみましょう。

まずはオブジェクト指向です。

```python
class Pokemon():
    def __init__(self, name, level):
        self.name = name
        self.level = level
        return

    def greeting(self):
        print("I'm " + self.name + ". Lv. " + str(self.level) + "!")
        return

# ---- Main program
pikachu = Pokemon("Pikachu", 81)
pikachu.greeting()
print("---")
kabigon = Pokemon("Snorlax", 75)
kabigon.greeting()
```

ここで「クラスをオブジェクトのように扱う」というのは、```pikachu = Pokemon("Pikachu", 81, "Electric")``` の部分を指します。```greeting()``` という挨拶機能を持った```Pokemon```クラスをあたかも変数```pikachu```として扱っています。

このように、ポケモンとして共通の機能（```greeting```）を持った個体（実体：オブジェクト）（Ex. pikachuやkabigon）をつくるという考え方がオブジェクト指向です。このようにすると、**他のポケモンを扱うためにはどうすればいいのか、という見通しがつきやすくなります**。

実はこのプログラムはオブジェクト指向を使わなくても書けます。

```python
def pikachu(name, level):
    print("I'm " + self.name + ". Lv. " + str(self.level) + "!")
    return

def kabigon(name, level):
    print("I'm " + self.name + ". Lv. " + str(self.level) + "!")
    return

# ---- Main program
pikachu("Pikachu", 81)
print("---")
kabigon("Snorlax", 75)
```

ただし、このように書いてしまうと、プログラミング原則「DRY (Don't repeat yourself)」に反してしまいます。
つまり、```print("I'm " + self.name + ". Lv. " + str(self.level) + "!")```をポケモンの数だけ書く必要があります。

こうなってしまうと、挨拶メッセージを変えたくなった場合、全部の行を間違いなく正確に修正する必要があります。
この程度のコードであれば、完璧にアップデートできると思いますが、もしこれが数百匹のポケモン全部に対して定義されていた場合、置換するとしても非常に多くの労力を費やすことになります。**これでは楽するためのプログラムでかえって疲れてしまいます**。

オブジェクト指向の場合、```Pokemon```クラス内の```greeting()```メソッドだけを修正すれば、挨拶メッセージの改良に対応できます。このような点で、オブジェクト指向は保守性に優れていると言えます。


# クラスの使いみち（計算化学）

では、計算化学の世界ではどのようにオブジェクト指向プログラミングを取り入れればいいでしょうか。

## Moleculeクラス

ポケモンと同じ感覚で使われるのが```Molecule```クラスです。
分子（Molecule）が持つ共通の性質（原子名、座標、分子量、沸点、融点 など）を返すメソッドを定義してあげれば、アンモニアやベンゼンといったそれぞれの実体をオブジェクトとして扱えるようになります。

例えば、[PySCF](https://github.com/pyscf/pyscf)プログラムでは```Mole```クラスが定義されています。
- https://github.com/pyscf/pyscf/blob/7b91b3ce5a00947654c9057bdf1a22499278b2bf/pyscf/gto/mole.py#L2084


## 抽象化で子クラスの機能を縛る

クラスの機能として、抽象化と継承があります。詳細は省きますが、サンプルコードを見ればなんとなく意味がわかるはずです。

計算化学に限らず、プログラマーがよく遭遇する状況に「**◯◯と✕✕の機能はほぼ同じなんだけど、△△だけ違う**」というものがあります。
例えば、

- ◯◯と✕✕は、SCF手続きの流れは共通だけど、△△の部分だけ異なる。
- 第一原理MD計算の初期条件サンプリング法の◯◯と✕✕は、ほぼ共通だけど、エネルギー分配の方法だけ違う。
- いろいろな電子状態計算 (ESC) プログラムの結果をxxxxプログラム形式に変換したい。

のような状況です。

ここでも意識すべき原則は「**DRY (Don't repeat yourself)**」です。例えば、最後の ESCparser のサンプルプログラムを書いてみましょう。

このプログラムはESCの出力から**energy、gradientを取得することが求められているとします**。このように異なるクラスだけれども、共通する機能が必要な場合、**抽象化**が役に立ちます。


```python
from abc import ABCMeta, abstractmethod

class ESCparser(metaclass=ABCMeta):  # 抽象クラスを定義
    @abstractmethod                  # この下に定義したメソッド(energy)は
    def energy(self):                # 継承先の子クラスで必ず実装しなければならない
        raise NotImplementedError

    @abstractmethod
    def gradient(self):
        raise NotImplementedError

class GaussianParser(ESCparser):     # ESCparserを継承した子クラスを定義
    def __init__(self):
        xxxx
        return

    def energy(self):                # これを定義しないとエラーになる
        xxxx
        return

    def gradient(self):              # これも定義しないとエラーになる
        xxxx
        return

class GAMESSParser(ESCparser):       # 抽象クラスの継承で機能を"縛る"
    def __init__(self):
        xxxx
        return

    def energy(self):
        xxxx
        return

    def gradient(self):
        xxxx
        return

    def hessian(self):               # 新しいメソッドの追加は可
        xxxx
        return
```

このようにすることで、```GaussianParser```と```GAMESSParser```の機能（メソッド）を縛ることができました。

この抽象クラスと継承は**共同開発において非常に役に立ちます**。

つまり、抽象クラスを定義した開発者は今後```MolproParser```を作る開発者に必要な機能を知らせることができます。一方、新規開発者は迷うことなく```energy```と```gradient```メソッドの実装に取り掛かることができます。マニュアル化するのは面倒だけどプログラムの仕様として重要な部分は抽象クラスを使って縛るのが良いかもしれません。


## 情報を格納する箱

クラスの他の使い道として**情報を受け取る箱**として使うというものがあります（かなりPythonicなのでわかりにくいかもしれませんが）。もしかしたらPySCFもそのように使っているかもしれません。

Pythonではリスト型や辞書型、json形式で書き出す、などいろいろな方法で情報を格納することができます。ただ、これらの場合、格納した情報にアクセスするためには、事前知識が必要になることが多いです。

> 例えば、以下のように。
> ```python
> list_data = save_data2list()    # データをlistに格納
> print(list_data[0][0][0])       # xxxx はどの階層にあるのかな？
> 
> dict_data = save_data2dict()    # データをdict(辞書)に格納
> print(dict_data["ESC"]["xxxx"]) # key(鍵)を知っていればデータにアクセス可能
> 
> save_data2json("save.json")         # データをjson形式で出力
> dict_data = load_json("save.json")  # いちいち読み書きが必要
> ```

このようなことを避けるために、クラスを使うことができます。

ただ、この記事が対象としているPython初心者が扱える範疇を越えているような気がするので、参考書を紹介するにとどめたいと思います（~~車輪の再開発を避けた~~）。

- [Effective Python](https://www.oreilly.co.jp/books/9784873117560/), 書籍, 第二版は[こちら](https://www.oreilly.co.jp/books/9784873119175/)
- [Effective Pythonはその名の通りEffectiveだった - 辞書を入れ子にするべからず！クラスを使うべし](https://qiita.com/jabberwocky0139/items/acb24f8d79dd46d2b792#%E8%BE%9E%E6%9B%B8%E3%82%92%E5%85%A5%E3%82%8C%E5%AD%90%E3%81%AB%E3%81%99%E3%82%8B%E3%81%B9%E3%81%8B%E3%82%89%E3%81%9A%E3%82%AF%E3%83%A9%E3%82%B9%E3%82%92%E4%BD%BF%E3%81%86%E3%81%B9%E3%81%97)


# おわりに

クラスやオブジェクト指向は初心者には難しい（かもしれない）概念です。

一度でわからなくてもいいと思います。何度も遭遇して、自分で少しずつ理解するのが良いと思います。


# リンク

- [プログラマーのための原則（2 万字）](https://qiita.com/yokarikeri/items/cbdef66fca460253cc7f#-dry-dont-repeat-yourself)
- [【Python入門】クラスの基本を１から解説する―完全版](https://it-biz.online/python/class-2/)
- [オブジェクト指向とは？特徴や原則をどこよりもわかりやすく解説！](https://camp.trainocate.co.jp/magazine/whats-object-oriented-programming/)
- [Effective Pythonはその名の通りEffectiveだった](https://qiita.com/jabberwocky0139/items/acb24f8d79dd46d2b792)
- [Pythonの継承とAbstract Base Class](https://qiita.com/ukisoft/items/b7c410b96dde1922a2d0)