13class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# クラス"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "クラスは変数（メンバ変数）と関数（メソッド）をまとめて管理できるオブジェクトの型を定義する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## インスタンス化\n",
    "\n",
    "以下の例では2次元上の点を表すクラス`Point`を定義している。`Point`クラスのインスタンスのメンバ変数として`x`と`y`を定義し、それぞれ`0.`に初期化している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self):\n",
    "        self.x = 0.\n",
    "        self.y = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "クラスをインスタンス化して`Point`オブジェクトを作成する。このとき、作成されたオブジェクトを引数として`__init__`関数が呼び出される。`__init__`関数を定義するときに、最初の引数の変数名を`self`にするのはお約束。そのオブジェクト（`self`変数で参照される）に対して`.`演算子を適用することで、メンバ変数`x`と`y`を`0.`に初期化している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Point()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`p`の型は`Point`型である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Point at 0x7ff5083c1250>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Point"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "インスタンスのメンバ変数には`.`演算子でアクセスできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "メンバ変数の値をクラスの外からでも変更できる（基本的にPythonのメンバ変数はpublicである）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.x = 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "インスタンスのメンバ変数をクラスの外からでも宣言・代入できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.a = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（当たり前ではあるが）`Point`クラスを新しくインスタンス化して別のオブジェクトを作成しても、既に作成済みのオブジェクトに影響を与えることはない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = Point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__init__`関数で引数を受け取り、メンバ変数を初期化することも可能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x=0., y=0.):\n",
    "        self.x = x\n",
    "        self.y = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Point(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__init__`関数の引数にデフォルト値を設定しておいたので、引数を省略しインスタンスを作成しても構わない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = Point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## メソッド\n",
    "\n",
    "インスタンスのメンバ変数に対する操作などをメンバ関数（メソッド）として記述できる。メンバ関数の第１引数としてインスタンスが渡されるため、第１引数を`self`という変数名にするのが慣例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x=0., y=0.):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def set(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def transpose(self):\n",
    "        self.x, self.y = self.y, self.x\n",
    "        \n",
    "    def hamming(self):\n",
    "        return self.x + self.y\n",
    "    \n",
    "    def dot(self, other):\n",
    "        return self.x * other.x + self.y * other.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Point`クラスをインスタンス化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Point`クラスのインスタンス`p`のメンバ関数を呼び出す。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.set(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上のメンバ関数の呼び出しは、以下の呼び出しと等価（第１引数が`self`となる理由が分かる）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "Point.set(p, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "メンバ関数の中でメンバ変数の値を変更する例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "メンバ関数が値を返す例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.hamming()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "メンバ関数の引数として別のオブジェクトを渡す例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Point(2, 3)\n",
    "q = Point(5, 4)\n",
    "p.dot(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "あるオブジェクトがどのようなメンバ変数・関数を持っているのか確認するには、[dir](https://docs.python.org/ja/3/library/functions.html#dir)関数を用いる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'dot',\n",
       " 'hamming',\n",
       " 'set',\n",
       " 'transpose',\n",
       " 'x',\n",
       " 'y']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 継承"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "あるクラスをベースとしてメンバ変数・関数を追加し、新しいクラスを定義することを継承と呼ぶ。2次元の点を表すクラス`Point`をベースに、3次元の点を表すクラス`Point3D`を作成する。このとき、`Point`クラスは親クラスと呼ばれる。以下の例における`super().__init__`は、`Point3D`クラスから見て親クラスである`Point`クラスの`__init__`関数を呼び出している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point3D(Point):\n",
    "    def __init__(self, x=0., y=0., z=0.):\n",
    "        super().__init__(x, y)\n",
    "        self.z = z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3次元の点を表すインスタンスを作成する。z軸の値を格納できるようになっている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Point3D(3, 4, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ところが、hammingメンバ関数を呼び出しても、期待する結果（9）が得られない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.hamming()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これは、`Point3D`クラスではhammingメンバ関数が明示的には実装されていないため、`Point`クラスのhammingメンバ関数が呼び出され、x軸とy軸の値しか使われていないためである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Point.hamming of <__main__.Point3D object at 0x7ff508321e80>>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.hamming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "z軸の値も考慮してハミング距離を求めるには、`Point3D`クラスにおいて`hamming`関数を上書きする必要がある。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point3D(Point):\n",
    "    def __init__(self, x=0., y=0., z=0.):\n",
    "        super().__init__(x, y)\n",
    "        self.z = z\n",
    "        \n",
    "    def hamming(self):\n",
    "        return self.x + self.y + self.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Point3D(3, 4, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.hamming()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上の変更により、`Point3D`クラスのhammingメンバ関数が呼び出されることが確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Point3D.hamming of <__main__.Point3D object at 0x7ff5083211c0>>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.hamming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 特殊メソッド\n",
    "\n",
    "自分で定義したクラスのオブジェクトに対して、`+`演算子の動作や`str`関数を呼び出したときの動作を特殊メソッドに記述できる。以下は２次元の点を表現する`Point`クラスの特殊メソッドを実装する例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    \"\"\" Two-dimensional vector. \"\"\"\n",
    "    \n",
    "    def __init__(self, x=0., y=0.):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\" str(p) \"\"\"\n",
    "        return f'({self.x}, {self.y})'\n",
    "\n",
    "    def __repr__(self):\n",
    "        \"\"\" repr(p) \"\"\"\n",
    "        return f'Point({self.x}, {self.y})'\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        \"\"\" self + other \"\"\"\n",
    "        return Point(self.x + other.x, self.y + other.y)\n",
    "    \n",
    "    def __sub__(self, other):\n",
    "        \"\"\" self - other \"\"\"\n",
    "        return Point(self.x - other.x, self.y - other.y)\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        \"\"\" self * other \"\"\"\n",
    "        return Point(self.x * other.x, self.y * other.y)\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        \"\"\" other * self \"\"\"\n",
    "        return Point(self.x * other, self.y * other)\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        \"\"\" self / other \"\"\"\n",
    "        return Point(self.x / other.x, self.y / other.y)\n",
    "\n",
    "    def __floordiv__(self, other):\n",
    "        \"\"\" self // other \"\"\"\n",
    "        return Point(self.x // other.x, self.y // other.y)\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        \"\"\" self == other \"\"\"\n",
    "        return self.x == other.x and self.y == other.y\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        \"\"\" self != other \"\"\"\n",
    "        return self.x != other.x or self.y != other.y\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        \"\"\" self < other \"\"\"\n",
    "        return self.x < other.x and self.y < other.y\n",
    "    \n",
    "    def __le__(self, other):\n",
    "        \"\"\" self <= other \"\"\"\n",
    "        return self.x <= other.x and self.y <= other.y\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        \"\"\" self > other \"\"\"\n",
    "        return self.x > other.x and self.y > other.y\n",
    "    \n",
    "    def __ge__(self, other):\n",
    "        \"\"\" self >= other \"\"\"\n",
    "        return self.x >= other.x and self.y >= other.y\n",
    "\n",
    "    def set(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def transpose(self):\n",
    "        self.x, self.y = self.y, self.x\n",
    "        \n",
    "    def hamming(self):\n",
    "        return self.x + self.y\n",
    "    \n",
    "    def dot(self, other):\n",
    "        return self.x * other.x + self.y * other.y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Point`クラスのインスタンス`p1`と`p2`を作成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Point(2, 3)\n",
    "p2 = Point(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`+`, `-`, `*`, `/`演算子を使うと、`__add__`, `__sub__`, `__mul__`または`__rmul__`, `__truediv__`が呼び出される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(7, 9)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 + p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(3, 3)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2 - p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(10, 18)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 * p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(6, 9)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(2.5, 2.0)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2 / p1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`==`, `!=`, `<`, `<=`, `>`, `>=`演算子を使うと、`__eq__`, `__ne__`, `__lt__`, `__le__`, `__gt__`, `__ge__`が呼び出される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 == p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 != p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 < p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 <= p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 > p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 >= p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[str](https://docs.python.org/3/library/functions.html#func-str)関数はオブジェクトを文字列として読みやすい形式で表現する（ことを想定しているため、そのようになるように`__str__`関数を実装しておいた）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(2, 3)'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[repr](https://docs.python.org/3/library/functions.html#repr)関数はオブジェクトをプログラムとして実行可能な表現に変換する（ことを想定しているため、そのようになるように`__repr__`関数を実装しておいた）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Point(2, 3)'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "オブジェクトを単に評価させたときにはrepr関数が呼び出される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(2, 3)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "repr関数が返す文字列はそのままPythonのプログラムとして評価できることを想定しているため、例えば[eval](https://docs.python.org/3/library/functions.html#eval)関数でプログラムとして実行できるようにしておくとよい。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(7, 9)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(repr(p1)) + p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "source": [
    "---\n",
    "\n",
    "[Python早見帳](https://chokkan.github.io/python/) © Copyright 2020-2021 by [岡崎 直観 (Naoaki Okazaki)](https://www.chokkan.org/). この作品は<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-nd/4.0/\">クリエイティブ・コモンズ 表示 - 非営利 - 改変禁止 4.0 国際 ライセンス</a>の下に提供されています。<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-nd/4.0/\"><img alt=\"クリエイティブ・コモンズ・ライセンス\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc-nd/4.0/80x15.png\" /></a>"
   ]
  }
 ],
 "metadata": {
  "@context": {
   "CreativeWork": "http://schema.org/CreativeWork",
   "Organization": "http://schema.org/Organization",
   "Person": "http://schema.org/Person",
   "author": "http://schema.org/author",
   "copyrightHolder": "http://schema.org/copyrightHolder",
   "copyrightYear": "http://schema.org/copyrightYear",
   "license": "http://schema.org/license",
   "name": "http://schema.org/name",
   "title": "http://schema.org/name",
   "url": "http://schema.org/url"
  },
  "@type": "CreativeWork",
  "author": [
   {
    "@type": "Person",
    "name": "Naoaki Okazaki",
    "url": "https://www.chokkan.org/"
   }
  ],
  "copyrightHolder": [
   {
    "@type": "Person",
    "name": "Naoaki Okazaki",
    "url": "https://www.chokkan.org/"
   }
  ],
  "copyrightYear": 2021,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "license": "https://creativecommons.org/licenses/by-nc-nd/4.0/deed.ja",
  "title": "Python早見帳"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}