6_things_to_note.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipsと注意点"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div name=\"html-admonition\" style=\"font-size: 0.8em\">\n",
    "<input type=\"button\" onclick=\"location.href='https://translate.google.com/translate?hl=&sl=ja&tl=en&u='+window.location;\" value=\"Google translation\" style=\"color:#ffffff;background-color:#008080; height:25px\" onmouseover=\"this.style.background='#99ccff'\" onmouseout=\"this.style.background='#008080'\"/> in English or the language of your choice.\n",
    "</div><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 警告メッセージを非表示\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 書式について"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードを書く際に以下を注意すること。\n",
    "1. 分かりやすい変数名を使う。\n",
    "    * 具体的な内容を示す変数名は可読性を高める。例えば、インフレ率を`inflation`、インフレ率の変化を`inf_change`。また単位を含めるとより分かりやすくなる。例えば、`kg`や`percent`。`var1`や`var2`と書くと、短くて書きやすいが、他の人や数ヶ月後の自分自身が読み返す時に非常に読み難いコードとなる。\n",
    "1. 変数や関数の命名規則\n",
    "    * 名は小文字とアンダースコア`_`を使う（スネーク・スケールと呼ばれる）。\n",
    "    * 例えば、`inflation_rate`と書き、`Inflation`や`InflationRate`は避ける。大文字で始まる変数は、慣例としてクラスと呼ばれるオブジェクトに使う。\n",
    "1. エディット・モードのセルでコメントを入れる。\n",
    "    * 例えば、`# これはコメントです。`\n",
    "    * 目的：可読性を高める。何を書いているかを確認しながらコードを書くことができる。\n",
    "    * 行頭に`#`を挿入することをコメント・アウト（comment out）という。コメント・アウトされたコードは実行されない。\n",
    "    * （Tip）行頭に`#`を挿入または削除するトグルのショートカット。\n",
    "        * Macの場合、トグルしたい行にカーソルを置き`Command`を押したまま`/`を押下する（`Cmd+/`）。複数行をトグルしたい場合は、それらをハイライトし`Cmd+/`。\n",
    "        * Windowsの場合、トグルしたい行にカーソルを置き`Control`を押したまま`/`を押下する（`Ctrl+/`）。複数行をトグルしたい場合は、それらをハイライトし`Ctrl+/`。        \n",
    "1. インデントを駆使して可読性を高める。（以下の例で改行は必要ないかもしれないが、１行が長い場合に役立つ）\n",
    "    * `(`と`)`の間は改行してもエラーにならない。\n",
    "        ```\n",
    "        my_func(a = 10,\n",
    "                b = 5,\n",
    "                c = 0)\n",
    "        ```\n",
    "    * 改行したい箇所に`\\`を入れる。（Jupyter Notebookでは`{}`の間に改行を入れてもエラーにならない）\n",
    "        ```\n",
    "        my_dict = {a:10, \\\n",
    "                   b:5,  \\\n",
    "                   c:[1,2]}\n",
    "        ```\n",
    "1. スペースや行間を開け読みやすくする。\n",
    "    ```\n",
    "    # 悪い例\n",
    "    def func(x,y):\n",
    "        return x*100+y\n",
    "\n",
    "    # 良い例\n",
    "    def meter_and_centimeter_to_centimeter(meter, centimeter):\n",
    "        return meter * 100 + centimeter\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## スコープ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "スコープとは、変数が所属し直接アクセスできるコードの中の「領域」を示す。類似する概念に名前空間（Namespace）もあるが、スコープの情報を記す「表」のことであり、スコープ（Scope）と同義と理解すれば良い。\n",
    "\n",
    "ここでは基本的に以下のように理解すれば良いであろう。\n",
    "1. Jupyter Notebookを開始した時点から`globalスコープ`が始まる。\n",
    "1. 関数を定義すると、その関数の範囲内で`localスコープ`が生成される。\n",
    "1. 関数の中で入れ子の関数を定義すると、その入れ子関数の範囲内でより狭い`localスコープ`が生成される。\n",
    "1. `globalスコープ`で定義された変数は、`localスコープ`（入れ子関数のより狭い`localスコープ`も含む）からアクセスできるが、`globalスコープ`から`localスコープ`（入れ子関数のより狭い`localスコープ`も含む）の変数にはアクセスできない。\n",
    "1. 関数内の`localスコープ`で定義された変数は、入れ子関数のより狭い`localスコープ`からアクセスできるが、親関数のスコープから入れ子関数の変数にはアクセスできない。\n",
    "\n",
    "次の例を考えよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例１"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "s = \"Kobe University\"  # globalスコープ\n",
    "\n",
    "def func_1():\n",
    "    s = \"神戸大学\"  # localスコープ\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例２"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_2():\n",
    "    a_local = 3\n",
    "    print(a_local)\n",
    "\n",
    "func_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`globalスコープ`から`a_local`をアクセスすると次のエラーが発生する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "a_local"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 教訓"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "関数内で使う変数は関数内で定義する方が意図しない結果につながるリスクを軽減できる。この点を説明するために次の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 10\n",
    "\n",
    "def func_3(x):\n",
    "    return a + x\n",
    "\n",
    "func_3(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**知らずに**以下を設定していたとしよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "func_3(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "このような間違いは関数内で変数を定義することで回避できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func_4(x):\n",
    "    a = 10\n",
    "    return a + x\n",
    "\n",
    "func_4(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 浮動小数点型について"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### 表記"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`では指数表現がよく使われる。\n",
    "\n",
    "`5.123e2`$= 5.123\\times 10^{2}$\n",
    "\n",
    "`5.123e-2`$= 5.123\\times 10^{-2}$\n",
    "\n",
    "この例で`5.123`の部分は「仮数」（mantissa もしくは significand）と呼ばれる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$1/3$を考えよう。\n",
    "\n",
    "$\\dfrac{1}{3}=0.33333333333333333\\cdots\\cdots\\cdots$\n",
    "\n",
    "となり永遠に3が続く。コンピュータのメモリの容量は有限であるため、無限に続く3をメモリに保存しすることは不可能である。従って、どこかで切断して$1/3$の近似値を保存する必要がある。これと同じようなことをPythonは行っている。10進法の数字を2進法に変換し、計算結果を10進法に変換し表示する。その際、多くの数字は$1/3$と同じように近似値となる。その結果、誰でもおかしいと思う結果が発生することになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "0.3 == 0.1 + 0.1 + 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`0.3`と`0.1`と表示されているが、実際には近似値で計算している。その近似値を表示すると"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "format(0.3, '.55f')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで`'.55f'`は小数点以下55桁を表示させる引数。同様に、"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "format(0.1, '.55f')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また、この問題は値が小さな場合だけではなく、大きい値の場合にも類似する問題がある。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**52"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**52 == 2.0**52 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この結果は期待どおりであるが、次の例はそうではない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**53"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2.0**53 == 2.0**53 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これは浮動小数点型で正確に表示できる最大の10進数桁が約15であるために発生する。従って、浮動小数点型に`==`を使い真偽を確かめるのは**危険**である。\n",
    "\n",
    "解決策として`numpy`の`isclose()`関数を使うことができる。この関数は２つの値が十分に近い場合は`True`を返す。では、どれだけ近い場合に`True`を返すのか？詳細は[マニュアル](https://numpy.org/doc/stable/reference/generated/numpy.isclose.html)を参照。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.isclose(0.3, 0.1+0.1+0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "一方、`2.0**53`の例は桁の制限に達しているため対応不可能である。ちなみに、整数だとこのような問題は発生しない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "2**53 == 2**53 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 変数とオブジェクト"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 変数とオブジェクトの関係"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Python`では「全てがオブジェクト」と言われるが、ここでのオブジェクトとは**属性**（**データ**（値や性質など）と**メソッド**（変数特有の関数））から構成される集合体（「塊り」）を指す。例えば、数値`0.1`のオブジェクトを考えよう。`dir()`を使うとどのような属性から構成されているか表示される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [],
   "source": [
    "dir(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "例えば、\n",
    "* `real`は数値の実数部を示す属性であり、`0.1`の実数数値データである。\n",
    "* `as_integer_ratio`は有理数として表すメソッドであり、`（分子、分母）`のタプルとして返す。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(0.1).real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "(0.1).as_integer_ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上の例では、`=`を使い`a`や`x`などの変数に「代入」していないことに注意しよう。これは変数がなくても`0.1`はオブジェクトとして存在していることを示している。では、変数とオブジェクトにはどのような関係があるのだろう。変数`a`を導入するために次のように書いてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 0.1\n",
    "a.real, a.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "以前、次の説明をした。\n",
    "\n",
    "> 多くの品物が保管されている大きな倉庫を考えてみよう。管理者はどの品物がどこに保管されているかを記録するための在庫リスト（記録帳やコンピューター・ファイル）を作成し、そこに品物が保管されている棚を示す記号（や番号）を記入しているとしよう。この例では、\n",
    "> * オブジェクト　→　倉庫の棚に保管されている品物\n",
    "> * 変数　→　在庫リストに記載されている棚の記号\n",
    ">\n",
    "> となる。即ち、変数は品物の実態とは異なる単なる「参照記号」なのである。\n",
    "\n",
    "\n",
    "上の例の`0.1`がPCのメモリに保存された「品物」であり，`a`は参照記号である。その参照記号を使って，`0.1`の属性`real`にアクセスしたり，メソッド`as_integer_ratio()`を使って有理数として表示している。\n",
    "\n",
    "実は、この考え方（品物と参照記号の関係）は関数の名前とオブジェクトとしての関数の関係にも当てはまる。変数とオブジェクトのこのような関係により、関数がメソッドや関数の引数になることが可能となり、関数の返り値にもなり得るのである。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### オブジェクトとメモリー・アドレス"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Pythonのオブジェクトをもう少し考えてみよう。オブジェクトはコンピューター内のメモリに保存され、直ぐに計算などに使えるように準備されている。例えば、`0.1`というオブジェクトを生成してみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コンピューター・メモリーには住所のようにロケーションを示すメモリー・アドレス（以下では「アドレス」と呼ぶ）があり、`id()`関数を使うとそれを表示することができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "２つのオブジェクトが同一のものかどうかを確認するには、このアドレスを比べれば良い。例えば、`a`と同じオブジェクトを示す別の参照記号`b`を生成しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "アドレスが同じなので同じオブジェクトであることが確認できる。また、アドレスが等しいかどうかは`is`を使って確認することもできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`==`ではないことに注意しよう。`==`は`10`という値が同じかどうかを確認するだけで、アドレスとは無関係である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "c = 0.1\n",
    "id(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "c is a, c == a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "整数では$[-5,256]$以外この結果が成り立つ。$[-5,256]$は処理速度を最適化するために、Pythonのセッションが始まると同時に自動でメモリーにキャッシュ（保存）されるためアドレスは同じになる。例えば、次の`d`と`e`は値もアドレスも同じである。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "d = 1\n",
    "e = 1\n",
    "d is e, d == e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に関数を考えてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def func(x):\n",
    "    return x**2\n",
    "\n",
    "func(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この関数のアドレスも`id()`を使い確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "id(func)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜注意＞\n",
    "\n",
    "* `id(func())`とするとエラーが発生する。`()`を付けると「関数を評価する」ためである。\n",
    "* `id(func(2))`とするとエラーは発生しないが、`func(2)`を評価した結果（即ち、`4`）のアドレスを表示することになる。\n",
    "* `func`は関数の「参照記号」であり、それを引数とすることにより関数のアドレスが表示される。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 「浅いコピー」と「深いコピー」"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "オブジェクトと変数の関係は、倉庫に保管されている商品と参照番号の関係と同じだと説明した。このような関係により、次のような問題が発生する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f = [1,2,3]\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "リスト`f`のコピーである`g`を作成する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "g = f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`g`と`f`は同じオブジェクトであり、`is`で確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "g is f, id(g), id(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "即ち、`g`と`f`は別の参照記号ではあるが同じ品物を指している。ここで、`f`にメソッド`append()`を使って`100`を追加しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f.append(100)\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`g`はどうなっているかというと"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`f`と`g`は同じ品物を指している参照番号なので、このような結果となる。\n",
    "\n",
    "`100`が追加された後のアドレスを表示してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f is g, id(f), id(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`100`が追加される前のアドレスと同じである。即ち、`append()`は元のオブジェクトを変化させている。このようなことが発生することを念頭に置いて`f=g`のようなコードを書くべきであり、このことを忘れると意図しない結果につながる。このようなリスクを回避するためには、同じ数値のコピーを異なるオブジェクトとして生成する必要がある。そのためにはメソッド`.copy()`を使う。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f_copy = f.copy()\n",
    "f_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f_copy is f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`.copy()`で生成したコピーは\n",
    "**「浅いコピー」**\n",
    "（shallow copy）と呼ばれる。しかし、浅いコピーの場合でも、リストが二重配列（入れ子）になっている場合は上で説明した同じ問題が発生する。その場合には、標準ライブラリ`copy`の`deepcopy`関数を使い独立したコピーを作ることが可能となる。これを\n",
    "**「深いコピー」**\n",
    "（deep copy）呼ぶ。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "f_deep = deepcopy(f)\n",
    "f_deep"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜以下の場合にリストの浅いコピーが生成される＞**\n",
    "1. メソッド`.copy()`によるコピー\n",
    "1. `list()`関数によるコピー\n",
    "1. リストのインデクシング（indexing）およびスライシング（slicing）によるコピー"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# list()による浅いコピー\n",
    "ff1 = list(f)\n",
    "ff1, ff1 is f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# インデクシング\n",
    "ff2 = f[1]\n",
    "ff2, ff2 is f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# スライシング\n",
    "ff3 = f[:]\n",
    "ff3, ff3 is f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## NumPy：ビューとコピー"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "リストの「浅いコピー」と「深いコピー」の問題は`NumPy`にも存在する。しかし、これも`np.copy()`関数や`array`型のメソッド`.copy()`で回避することができる。また類似する問題としてコピー（copy）とビュー（view）の違いがある。以下ではこの問題を説明する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr = np.array([1,2,3,4,5])\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これをスライスして異なる変数を参照記号として使う。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr_slice = arr[1:3]\n",
    "arr_slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`arr_slice`の`2`を`200`に入れ替える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr_slice[0] = 200\n",
    "arr_slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`arr`を表示しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`arr_slice`を変更したにも関わらず、`arr`も影響を受けている。これは`arr_slice`と`arr`が参照している元のデータが同じであるために発生する。即ち、`arr`は元のデータ全てを表示し、`arr_slice`は同じデータの一部を表示しているのである。`arr_slice`を`arr`のビュー（view）と呼ぶ。\n",
    "\n",
    "```{warning}\n",
    "`arr[0] is arr_slice[1]`としても`False`となる。リストと異なり、`np.array`ではそれぞれの要素がメモリーに配置されていないため、`indexing`でアクセスする度に結果をメモリーに配置することになる。したがって`arr[0]`でアクセスするとその結果があるアドレスに配置され、続く`arr_slice[1]`は別のアドレスに保存されることになり`False`が返される。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "---\n",
    "ではどのような場合に`views`になるのか。残念ながら、複雑な場合分けが必要になり、それを覚え使いこなすにはある程度の慣れが必要だる。従って、`view`をどうしても使わなくてはならない状況を除いては、以下のようにメソッド`.copy()`を使い、コピーを生成して作業することを強く推奨する。`.copy()`は「深いコピー」を生成する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr_copy = arr[1:3].copy()\n",
    "arr_copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`arr_copy`の`3`を`300`に入れ替える。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr_copy[1] = 300\n",
    "arr_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`arr`は影響を受けていない。\n",
    "\n",
    "＜コメント＞\n",
    "\n",
    "`view`の役目はなんなのか、という疑問が生じる。`.copy()`は新たにオブジェクトを生成するが、`view`であれば新たなオブジェクトを生成する必要がない。その分、処理速度が早くなるのである。しかし、実証分析で行う「通常」のデータ処理であれば`.copy()`を使って問題ないだろう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Pandas：ビューとコピー"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`NumPy`と同じように`Pandas`もビュー（view）とコピー（copy）の問題が存在する。確認するために、次のコードを考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame({'a':np.arange(4), 'b':np.arange(4)})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_slice = df.iloc[1:3,:]\n",
    "df_slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`.iloc[]`により`view`が生成されている。\n",
    "\n",
    "それを確認するために元の`DataFrame`である`df`の要素を変更する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.iloc[1,1] = 100\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここではスライシングで生成した場合を考えたが、他の場合でも`view`になったり`copy`になったりする。実は、`NumPy`と同様に場合わけが複雑だが、`NumPy`の場合よりも`view`なのか`copy`なのかの判別が非常に難しい。しかし、`Pandas`は`view`**かもしれない**`DataFrame`や`Series`に変更を加えると警告を出す仕組みになっている。`df_slice`を使って説明する。\n",
    "\n",
    "```\n",
    "df_slice.iloc[1,0] = 200\n",
    "```\n",
    "とすると次のような警告が出る。\n",
    "```\n",
    "/Users/my_name/anaconda3/envs/py4etrics/lib/python3.7/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
    "A value is trying to be set on a copy of a slice from a DataFrame\n",
    "\n",
    "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
    "  \"\"\"Entry point for launching an IPython kernel.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この警告が出る場合は、`view`の疑いが高い（確定ではない）ので、`df`のメソッド`.copy()`を使って「深いコピー」を生成することを薦める。以下の例を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_copy = df.copy().iloc[1:3,:]\n",
    "df_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df.iloc[2,1] = 2000\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`df_copy`は影響を受けていないが、`df_slice`の値は元のデータの変化を反映している。"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernel_info": {
   "name": "py4etrics"
  },
  "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.11.5"
  },
  "nteract": {
   "version": "0.22.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}